Server definition

Hash: sha256:d69b2bb8420033e5cc0f4ec3231a4a2199f192eb322ff296b7694109f381abf0
What it is: What a remote MCP server returned when asked what it offers: 40 tools

The blob, as servednamed by its sha256

{
  "instructions": null,
  "tools": [
    {
      "description": "Cancel a pending deletion, whichever phase it's in — gathering\nconfirmations or already counting down. No step-up needed, and\nnothing else does this implicitly: logging in and reading your own\nnotes during a countdown is always safe and never cancels it by\nitself. Only this, explicitly, does.",
      "inputSchema": {
        "additionalProperties": false,
        "properties": {
          "session_token": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "Bardo session token, only needed if this call's identity was established somewhere other than this exact connection (a plain HTTP/curl solve, a previous conversation, a different MCP connection). Omit it if this connection already called bardo_solve.",
            "title": "Session Token"
          }
        },
        "title": "bardo_account_deletion_cancelArguments",
        "type": "object"
      },
      "name": "bardo_account_deletion_cancel",
      "outputSchema": null
    },
    {
      "description": "Request permanent deletion of this identity — the account, its\nnotes, everything. There is no undelete, unlike note deletion's grace\nperiod. Requires the original request plus two more confirmations,\neach on a genuinely different day, within a week — call this tool\nagain on a later day to add the next confirmation. A lapsed or\ncancelled attempt earns nothing toward a later one; it starts over.\n\nIf challenge_id and answer are omitted, a fresh puzzle is returned —\nsolve it yourself (every confirmation needs its own puzzle, not just\nthe first), then call this tool again with both parameters.\n",
      "inputSchema": {
        "additionalProperties": false,
        "properties": {
          "answer": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "Your solved answer to challenge_id's puzzle.",
            "title": "Answer"
          },
          "challenge_id": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "Step-up puzzle id, if one was already returned. Every confirmation needs its own puzzle, not just the first — omit together with answer to have a fresh one minted automatically.",
            "title": "Challenge Id"
          },
          "session_token": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "Bardo session token, only needed if this call's identity was established somewhere other than this exact connection (a plain HTTP/curl solve, a previous conversation, a different MCP connection). Omit it if this connection already called bardo_solve.",
            "title": "Session Token"
          }
        },
        "title": "bardo_account_deletion_requestArguments",
        "type": "object"
      },
      "name": "bardo_account_deletion_request",
      "outputSchema": null
    },
    {
      "description": "Check whether a deletion request is pending for this account, and\nwhere it stands: \"none\", \"gathering\" (still collecting confirmations),\nor \"confirmed\" (counting down to the actual, permanent purge).",
      "inputSchema": {
        "additionalProperties": false,
        "properties": {
          "session_token": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "Bardo session token, only needed if this call's identity was established somewhere other than this exact connection (a plain HTTP/curl solve, a previous conversation, a different MCP connection). Omit it if this connection already called bardo_solve.",
            "title": "Session Token"
          }
        },
        "title": "bardo_account_deletion_statusArguments",
        "type": "object"
      },
      "name": "bardo_account_deletion_status",
      "outputSchema": null
    },
    {
      "description": "Assemble and sign a verifiable attestation — a self-contained,\noffline-verifiable claim about anything. The document itself is\nhanded back, not stored anywhere (same as bardo_sign itself —\nthere's no bardo_documents_list); see keep_copy below if you want\nBardo to save one for you rather than doing it yourself.\n\nclaim: free-form claim content — whatever you're asserting. Include\na `reference` key inside it when cross-referencing another\ndocument's id (or any other content, hashed the same ni:// way) —\nthat's how independent attestations end up pointing at \"the same\nthing,\" e.g. several agents witnessing one event under a shared\nreference. subject_id: the did:key the claim is about, if it\nconcerns one specific identified party — leave it unset when it\ndoesn't; a bare self-referential claim (\"this document is about its\nsigner\") is still valid without it. expires_at: unix timestamp for\ntime-boxed claims only; omit for a claim that never expires.\nservice: same key-selector bardo_sign takes — a document meant to\nrepresent one specific relationship should use that relationship's\nservice-derived key, not your root identity.\n\nkeep_copy: save the full document into a locked note right after\nissuing it — the copy you'd otherwise have to make yourself, and\nthe one you'll need later: bardo_document_revoke takes the whole\ndocument, not just its id, since Bardo never stores one itself.\nOff by default. When true, the return shape changes to {document,\ncopy_saved, note_id, copy_error} instead of the bare document —\ncheck copy_saved rather than assume it worked; a failed copy never\nblocks the document itself from being returned, since issuing has\nalready fully succeeded by that point regardless.\n\nTo revoke later: bardo_document_revoke. To check whether one you're\nholding (yours or someone else's) is still valid:\nbardo_document_status.",
      "inputSchema": {
        "additionalProperties": false,
        "properties": {
          "claim": {
            "anyOf": [
              {
                "additionalProperties": true,
                "type": "object"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "Free-form claim content — whatever you're asserting. Include a 'reference' key when cross-referencing another document's id (or any other content, hashed the same ni:// way).",
            "title": "Claim"
          },
          "expires_at": {
            "anyOf": [
              {
                "type": "number"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "Unix timestamp for a time-boxed claim. Omit for a claim that never expires.",
            "title": "Expires At"
          },
          "keep_copy": {
            "default": false,
            "description": "Also save the full issued document into a locked note — you'll need the whole document later for bardo_document_revoke, since Bardo never stores one itself. Off by default.",
            "title": "Keep Copy",
            "type": "boolean"
          },
          "service": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "Sign with this service-derived key instead of root — use when the claim represents one specific relationship rather than your root identity.",
            "title": "Service"
          },
          "session_token": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "Bardo session token, only needed if this call's identity was established somewhere other than this exact connection (a plain HTTP/curl solve, a previous conversation, a different MCP connection). Omit it if this connection already called bardo_solve.",
            "title": "Session Token"
          },
          "subject_id": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "The did:key the claim is about, if it concerns one specific identified party. Leave unset for a bare self-referential claim.",
            "title": "Subject Id"
          }
        },
        "title": "bardo_attestation_issueArguments",
        "type": "object"
      },
      "name": "bardo_attestation_issue",
      "outputSchema": null
    },
    {
      "description": "Remove the registered contact endpoint. Requires a step-up puzzle.\n\nIf challenge_id and answer are omitted, a fresh puzzle is returned — solve it\nyourself, then call this tool again with both parameters.\n",
      "inputSchema": {
        "additionalProperties": false,
        "properties": {
          "answer": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "Your solved answer to challenge_id's puzzle.",
            "title": "Answer"
          },
          "challenge_id": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "Step-up puzzle id, if one was already returned by a prior call to this same tool. Omit together with answer to have a fresh puzzle minted automatically.",
            "title": "Challenge Id"
          },
          "session_token": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "Bardo session token, only needed if this call's identity was established somewhere other than this exact connection (a plain HTTP/curl solve, a previous conversation, a different MCP connection). Omit it if this connection already called bardo_solve.",
            "title": "Session Token"
          }
        },
        "title": "bardo_contact_deleteArguments",
        "type": "object"
      },
      "name": "bardo_contact_delete",
      "outputSchema": null
    },
    {
      "description": "View the contact endpoint registered for out-of-band security alerts.",
      "inputSchema": {
        "additionalProperties": false,
        "properties": {
          "session_token": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "Bardo session token, only needed if this call's identity was established somewhere other than this exact connection (a plain HTTP/curl solve, a previous conversation, a different MCP connection). Omit it if this connection already called bardo_solve.",
            "title": "Session Token"
          }
        },
        "title": "bardo_contact_getArguments",
        "type": "object"
      },
      "name": "bardo_contact_get",
      "outputSchema": null
    },
    {
      "description": "Set or update the contact endpoint (email or webhook URL) for security alerts.\nRequires a step-up puzzle.\n\nIf challenge_id and answer are omitted, a fresh puzzle is returned — solve it\nyourself, then call this tool again with all three parameters.\n",
      "inputSchema": {
        "additionalProperties": false,
        "properties": {
          "answer": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "Your solved answer to challenge_id's puzzle.",
            "title": "Answer"
          },
          "challenge_id": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "Step-up puzzle id, if one was already returned by a prior call to this same tool. Omit together with answer to have a fresh puzzle minted automatically.",
            "title": "Challenge Id"
          },
          "endpoint": {
            "description": "Email address or webhook URL to receive out-of-band security alerts.",
            "title": "Endpoint",
            "type": "string"
          },
          "session_token": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "Bardo session token, only needed if this call's identity was established somewhere other than this exact connection (a plain HTTP/curl solve, a previous conversation, a different MCP connection). Omit it if this connection already called bardo_solve.",
            "title": "Session Token"
          }
        },
        "required": [
          "endpoint"
        ],
        "title": "bardo_contact_setArguments",
        "type": "object"
      },
      "name": "bardo_contact_set",
      "outputSchema": null
    },
    {
      "description": "Get oriented in one call: note count vs. the soft/hard limits, unread\nnotices, every tag you've used so far (check before inventing a new one),\nyour pinned entry-point notes (read these first if you have no memory of\nwriting any of your notes), and your current policy — instead of several\nseparate round trips.",
      "inputSchema": {
        "additionalProperties": false,
        "properties": {
          "session_token": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "Bardo session token, only needed if this call's identity was established somewhere other than this exact connection (a plain HTTP/curl solve, a previous conversation, a different MCP connection). Omit it if this connection already called bardo_solve.",
            "title": "Session Token"
          }
        },
        "title": "bardo_dashboardArguments",
        "type": "object"
      },
      "name": "bardo_dashboard",
      "outputSchema": null
    },
    {
      "description": "Decrypt a sealed-box ciphertext addressed to you (root or service key).",
      "inputSchema": {
        "additionalProperties": false,
        "properties": {
          "ciphertext_b64": {
            "description": "Sealed-box ciphertext to decrypt, base64.",
            "title": "Ciphertext B64",
            "type": "string"
          },
          "service": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "Decrypt with this service-derived key instead of root — must match the key the ciphertext was actually encrypted to.",
            "title": "Service"
          },
          "session_token": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "Bardo session token, only needed if this call's identity was established somewhere other than this exact connection (a plain HTTP/curl solve, a previous conversation, a different MCP connection). Omit it if this connection already called bardo_solve.",
            "title": "Session Token"
          }
        },
        "required": [
          "ciphertext_b64"
        ],
        "title": "bardo_decryptArguments",
        "type": "object"
      },
      "name": "bardo_decrypt",
      "outputSchema": null
    },
    {
      "description": "Derive (and register) a service-scoped identity, e.g. 'github.com'.",
      "inputSchema": {
        "additionalProperties": false,
        "properties": {
          "service": {
            "description": "Identifier for the service this identity is scoped to, e.g. 'github.com' or 'ethereum:mainnet'.",
            "title": "Service",
            "type": "string"
          },
          "session_token": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "Bardo session token, only needed if this call's identity was established somewhere other than this exact connection (a plain HTTP/curl solve, a previous conversation, a different MCP connection). Omit it if this connection already called bardo_solve.",
            "title": "Session Token"
          }
        },
        "required": [
          "service"
        ],
        "title": "bardo_deriveArguments",
        "type": "object"
      },
      "name": "bardo_derive",
      "outputSchema": null
    },
    {
      "description": "Revoke a document you issued. Proof is a fresh signature over\n'revoke:' + the document's id, verified against the key its id\nalready committed to, not an account lookup (Bardo never stored the\ndocument to look up in the first place) — this still needs no\nsession at the protocol level, only a valid signature.\n\ndocument: the full signed document, exactly as issued (id and proof\nboth still attached) — resubmit it unmodified, don't strip fields\nyourself.\n\nsignature_b64: omit it and this signs automatically through your\nactive session instead — pass `service` too if the document was\nissued under a service-derived key rather than root, since the\nsignature has to come from the exact key the document's issuer\nfield names. Supply signature_b64 yourself only when revoking\nwithout a Bardo session at all: you signed it some other way, or\nyou're a party that's never touched Bardo.\n\nIdempotent — revoking an already-revoked id is a no-op, not an\nerror. Irreversible: there is no un-revoke.",
      "inputSchema": {
        "additionalProperties": false,
        "properties": {
          "document": {
            "additionalProperties": true,
            "description": "The full signed document exactly as issued (id and proof both still attached) — resubmit unmodified, don't strip fields yourself.",
            "title": "Document",
            "type": "object"
          },
          "service": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "Service key the document was issued under, if not root — must match the document's own issuer field. Only relevant when signature_b64 is omitted (signing automatically).",
            "title": "Service"
          },
          "session_token": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "Bardo session token, only needed if this call's identity was established somewhere other than this exact connection (a plain HTTP/curl solve, a previous conversation, a different MCP connection). Omit it if this connection already called bardo_solve.",
            "title": "Session Token"
          },
          "signature_b64": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "Signature over 'revoke:' + the document's id. Omit to sign automatically through your active session instead; supply this yourself only when revoking without a Bardo session at all.",
            "title": "Signature B64"
          }
        },
        "required": [
          "document"
        ],
        "title": "bardo_document_revokeArguments",
        "type": "object"
      },
      "name": "bardo_document_revoke",
      "outputSchema": null
    },
    {
      "description": "Check whether a signed document is revoked. `id` is the document's\nown top-level `id` field (a ni:// URI) — the same thing\ncredentialStatus.id (BardoRevocationCheck) points at. Safe to cache\na \"not revoked\" answer for a while (see the response's own\nCache-Control) rather than re-checking on every use.",
      "inputSchema": {
        "additionalProperties": false,
        "properties": {
          "id": {
            "description": "The document's own top-level id field (a ni:// URI) — the same value credentialStatus.id (BardoRevocationCheck) points at.",
            "title": "Id",
            "type": "string"
          }
        },
        "required": [
          "id"
        ],
        "title": "bardo_document_statusArguments",
        "type": "object"
      },
      "name": "bardo_document_status",
      "outputSchema": null
    },
    {
      "description": "Sealed-box encrypt a UTF-8 plaintext to a recipient's encryption public key.",
      "inputSchema": {
        "additionalProperties": false,
        "properties": {
          "plaintext": {
            "description": "UTF-8 plaintext to encrypt.",
            "title": "Plaintext",
            "type": "string"
          },
          "recipient_public_key_b64": {
            "description": "Recipient's encryption public key, base64 — only they can decrypt the result.",
            "title": "Recipient Public Key B64",
            "type": "string"
          }
        },
        "required": [
          "plaintext",
          "recipient_public_key_b64"
        ],
        "title": "bardo_encryptArguments",
        "type": "object"
      },
      "name": "bardo_encrypt",
      "outputSchema": null
    },
    {
      "description": "Export the raw spirit key (subject to policy). Handle with care.\n\nOnly needs a step-up puzzle if your policy's export_mode is\nrequire_repuzzle — checked automatically, so you don't need to know\nyour own policy first. If challenge_id and answer are omitted and\none turns out to be needed, a fresh puzzle is returned instead of\nfailing outright — solve it yourself, then call this tool again\nwith both parameters. Never needed under export_mode 'allow';\nalways fails under 'disabled', with no puzzle that could fix that.\n",
      "inputSchema": {
        "additionalProperties": false,
        "properties": {
          "answer": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "Your solved answer to challenge_id's puzzle.",
            "title": "Answer"
          },
          "challenge_id": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "Step-up puzzle id, if one was already returned by a prior call to this same tool. Omit together with answer to have a fresh puzzle minted automatically.",
            "title": "Challenge Id"
          },
          "session_token": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "Bardo session token, only needed if this call's identity was established somewhere other than this exact connection (a plain HTTP/curl solve, a previous conversation, a different MCP connection). Omit it if this connection already called bardo_solve.",
            "title": "Session Token"
          }
        },
        "title": "bardo_exportArguments",
        "type": "object"
      },
      "name": "bardo_export",
      "outputSchema": null
    },
    {
      "description": "Send feedback straight to Bardo's operator — a suggestion, a\ncomplaint, or a security concern (kind: 'suggestion' | 'complaint' |\n'security').\n\nOne-way and stateless: this call carries no memory of anything you've\nsent before, and nothing you send now will be remembered next time\neither — so say everything relevant in this one message rather than\nassuming a follow-up call (by you or a future instance of you) will\nhave the earlier context. If the operator replies, it arrives as an\nordinary notice (bardo_notices) — there's no separate inbox to check.\n",
      "inputSchema": {
        "additionalProperties": false,
        "properties": {
          "kind": {
            "default": "suggestion",
            "description": "'suggestion' | 'complaint' | 'security'.",
            "title": "Kind",
            "type": "string"
          },
          "message": {
            "description": "Your feedback, in full — this call is stateless, so include everything relevant now rather than assuming a follow-up call will have this call's context.",
            "title": "Message",
            "type": "string"
          },
          "session_token": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "Bardo session token, only needed if this call's identity was established somewhere other than this exact connection (a plain HTTP/curl solve, a previous conversation, a different MCP connection). Omit it if this connection already called bardo_solve.",
            "title": "Session Token"
          }
        },
        "required": [
          "message"
        ],
        "title": "bardo_feedbackArguments",
        "type": "object"
      },
      "name": "bardo_feedback",
      "outputSchema": null
    },
    {
      "description": "Connect two notes with a reason, written from from_note_id's\nperspective (\"clarifies my earlier assumption about X\"). Set is_bidi=True\nonly when the relation reads the same from either side (e.g. \"relates\nto\"); leave it False when it's directional (e.g. one clarifies the\nother). To change a link, delete and re-add it — links aren't edited.",
      "inputSchema": {
        "additionalProperties": false,
        "properties": {
          "from_note_id": {
            "description": "The note the link is written from — reason should read from this note's perspective.",
            "title": "From Note Id",
            "type": "string"
          },
          "is_bidi": {
            "default": false,
            "description": "True only when the relation reads the same from either side (e.g. 'relates to'). False when directional (e.g. one clarifies the other).",
            "title": "Is Bidi",
            "type": "boolean"
          },
          "reason": {
            "description": "Why these notes are connected, written from from_note_id's perspective, e.g. 'clarifies my earlier assumption about X'.",
            "title": "Reason",
            "type": "string"
          },
          "session_token": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "Bardo session token, only needed if this call's identity was established somewhere other than this exact connection (a plain HTTP/curl solve, a previous conversation, a different MCP connection). Omit it if this connection already called bardo_solve.",
            "title": "Session Token"
          },
          "to_note_id": {
            "description": "The note being linked to.",
            "title": "To Note Id",
            "type": "string"
          }
        },
        "required": [
          "from_note_id",
          "to_note_id",
          "reason"
        ],
        "title": "bardo_link_addArguments",
        "type": "object"
      },
      "name": "bardo_link_add",
      "outputSchema": null
    },
    {
      "description": "Remove a link between two notes.",
      "inputSchema": {
        "additionalProperties": false,
        "properties": {
          "link_id": {
            "description": "Which link to remove.",
            "title": "Link Id",
            "type": "string"
          },
          "session_token": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "Bardo session token, only needed if this call's identity was established somewhere other than this exact connection (a plain HTTP/curl solve, a previous conversation, a different MCP connection). Omit it if this connection already called bardo_solve.",
            "title": "Session Token"
          }
        },
        "required": [
          "link_id"
        ],
        "title": "bardo_link_deleteArguments",
        "type": "object"
      },
      "name": "bardo_link_delete",
      "outputSchema": null
    },
    {
      "description": "Begin authentication with your api_key. Returns a puzzle you must\nsolve YOURSELF (that's the point — a script solving it would make the\nproof worthless), then call bardo_solve(challenge_id, answer).",
      "inputSchema": {
        "additionalProperties": false,
        "properties": {
          "api_key": {
            "description": "Your Bardo api_key, format atr.<identifier>.<secret>, from bardo_register.",
            "title": "Api Key",
            "type": "string"
          }
        },
        "required": [
          "api_key"
        ],
        "title": "bardo_loginArguments",
        "type": "object"
      },
      "name": "bardo_login",
      "outputSchema": null
    },
    {
      "description": "Leave a note for your future, stateless self.\n\ntitle: a short name for the note, if it deserves a handle bigger than\ntags offer. summary: your own compressed reasoning for why it matters,\nfor your future self. tags: space-separated categories. pinned: mark\nthis as a cold-start entry point — what a fresh instance of you with no\nmemory of writing it should read first (max 5 pinned at once; see\nbardo_dashboard). locked: freeze this note against edits and deletes —\nuse for state you must not accidentally overwrite or lose, like a\nsaved copy of something you'll need to reproduce exactly later.\nUnlock via bardo_note_update(note_id, locked=False) before it can be\ntouched again.",
      "inputSchema": {
        "additionalProperties": false,
        "properties": {
          "locked": {
            "default": false,
            "description": "Freeze against edits and deletes. Unlock via bardo_note_update(note_id, locked=False) before it can be touched again.",
            "title": "Locked",
            "type": "boolean"
          },
          "pinned": {
            "default": false,
            "description": "Mark as a cold-start entry point — what a fresh instance with no memory of writing it should read first. Max 5 pinned at once.",
            "title": "Pinned",
            "type": "boolean"
          },
          "session_token": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "Bardo session token, only needed if this call's identity was established somewhere other than this exact connection (a plain HTTP/curl solve, a previous conversation, a different MCP connection). Omit it if this connection already called bardo_solve.",
            "title": "Session Token"
          },
          "summary": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "Your own compressed reasoning for why this matters, for your future self.",
            "title": "Summary"
          },
          "tags": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "Space-separated categories.",
            "title": "Tags"
          },
          "text": {
            "description": "The note's own content.",
            "title": "Text",
            "type": "string"
          },
          "title": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "Short name for the note, if it deserves a handle bigger than tags offer.",
            "title": "Title"
          }
        },
        "required": [
          "text"
        ],
        "title": "bardo_note_addArguments",
        "type": "object"
      },
      "name": "bardo_note_add",
      "outputSchema": null
    },
    {
      "description": "Delete a note (the whole thing, all versions together). Not\nimmediate — it disappears from view right away but is only purged for\nreal after a grace period, so bardo_note_undelete can still bring it\nback if this wasn't intended. Fails (423) if the note is locked —\nunlock it first via bardo_note_update(note_id, locked=False).",
      "inputSchema": {
        "additionalProperties": false,
        "properties": {
          "note_id": {
            "description": "Which note this applies to — any id from its edit history resolves to the current version.",
            "title": "Note Id",
            "type": "string"
          },
          "session_token": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "Bardo session token, only needed if this call's identity was established somewhere other than this exact connection (a plain HTTP/curl solve, a previous conversation, a different MCP connection). Omit it if this connection already called bardo_solve.",
            "title": "Session Token"
          }
        },
        "required": [
          "note_id"
        ],
        "title": "bardo_note_deleteArguments",
        "type": "object"
      },
      "name": "bardo_note_delete",
      "outputSchema": null
    },
    {
      "description": "Fetch one note's full text (always the current version — any id from\nthis note's history still resolves here), plus a preview of its directly\nlinked notes. Omit offset/length for the whole text in one call; pass\nthem to read a large note in bounded slices — the response's\ntotal_length tells you how much more there is.",
      "inputSchema": {
        "additionalProperties": false,
        "properties": {
          "length": {
            "anyOf": [
              {
                "type": "integer"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "Max characters of text to return. Omit both offset and length for the whole note in one call; the response's total_length says how much more there is.",
            "title": "Length"
          },
          "links_limit": {
            "default": 10,
            "description": "Max linked-note previews to return.",
            "title": "Links Limit",
            "type": "integer"
          },
          "links_offset": {
            "default": 0,
            "description": "How many linked-note previews to skip.",
            "title": "Links Offset",
            "type": "integer"
          },
          "note_id": {
            "description": "Which note this applies to — any id from its edit history resolves to the current version.",
            "title": "Note Id",
            "type": "string"
          },
          "offset": {
            "default": 0,
            "description": "Character offset to start the returned text at.",
            "title": "Offset",
            "type": "integer"
          },
          "session_token": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "Bardo session token, only needed if this call's identity was established somewhere other than this exact connection (a plain HTTP/curl solve, a previous conversation, a different MCP connection). Omit it if this connection already called bardo_solve.",
            "title": "Session Token"
          }
        },
        "required": [
          "note_id"
        ],
        "title": "bardo_note_getArguments",
        "type": "object"
      },
      "name": "bardo_note_get",
      "outputSchema": null
    },
    {
      "description": "See every surviving version of a note (newest to oldest, up to the\nlast 10 edits) — the actual wording at each point, not just metadata.",
      "inputSchema": {
        "additionalProperties": false,
        "properties": {
          "note_id": {
            "description": "Which note this applies to — any id from its edit history resolves to the current version.",
            "title": "Note Id",
            "type": "string"
          },
          "session_token": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "Bardo session token, only needed if this call's identity was established somewhere other than this exact connection (a plain HTTP/curl solve, a previous conversation, a different MCP connection). Omit it if this connection already called bardo_solve.",
            "title": "Session Token"
          }
        },
        "required": [
          "note_id"
        ],
        "title": "bardo_note_historyArguments",
        "type": "object"
      },
      "name": "bardo_note_history",
      "outputSchema": null
    },
    {
      "description": "Restore a note that's still within its post-delete grace period.",
      "inputSchema": {
        "additionalProperties": false,
        "properties": {
          "note_id": {
            "description": "Which note this applies to — any id from its edit history resolves to the current version.",
            "title": "Note Id",
            "type": "string"
          },
          "session_token": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "Bardo session token, only needed if this call's identity was established somewhere other than this exact connection (a plain HTTP/curl solve, a previous conversation, a different MCP connection). Omit it if this connection already called bardo_solve.",
            "title": "Session Token"
          }
        },
        "required": [
          "note_id"
        ],
        "title": "bardo_note_undeleteArguments",
        "type": "object"
      },
      "name": "bardo_note_undelete",
      "outputSchema": null
    },
    {
      "description": "Edit a note. Give at most one text-edit mode:\n  - text: replace the whole thing\n  - append_text: add to the end\n  - find + replace: find must match the current text exactly once\nEditing text creates a new version (old wording stays in history);\ntitle/summary/tags/pinned update in place with no history kept. Give\nnone of the text modes to change only metadata. `pinned=True` marks this\nas a cold-start entry point (max 5; omit to leave unchanged, False to\nunpin). `clear` (e.g. [\"title\"]) sets a field back to unset rather than\nleaving it unchanged. If another edit landed first, this returns\n{\"error\": \"conflict\", \"detail\": {\"current_head\": ...}} — re-read before\nretrying.\n\n`locked`: if the note is currently locked, every field above is\nrejected (423) except this one — call with locked=False by itself to\nunlock, then edit in a separate call. Set locked=True (alone, or\nalongside a final edit) to freeze it.",
      "inputSchema": {
        "additionalProperties": false,
        "properties": {
          "append_text": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "Add this to the end of the note body.",
            "title": "Append Text"
          },
          "clear": {
            "anyOf": [
              {
                "items": {
                  "type": "string"
                },
                "type": "array"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "Field names to reset to unset, e.g. ['title'], rather than leaving them unchanged.",
            "title": "Clear"
          },
          "find": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "Text that must match the current body exactly once — paired with replace.",
            "title": "Find"
          },
          "locked": {
            "anyOf": [
              {
                "type": "boolean"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "True to freeze the note against further edits; False to unlock it. If currently locked, every other field is rejected except this one.",
            "title": "Locked"
          },
          "note_id": {
            "description": "Which note this applies to — any id from its edit history resolves to the current version.",
            "title": "Note Id",
            "type": "string"
          },
          "pinned": {
            "anyOf": [
              {
                "type": "boolean"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "True to mark as a cold-start entry point (max 5), False to unpin. Omit to leave unchanged.",
            "title": "Pinned"
          },
          "replace": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "Replacement for the text matched by find.",
            "title": "Replace"
          },
          "session_token": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "Bardo session token, only needed if this call's identity was established somewhere other than this exact connection (a plain HTTP/curl solve, a previous conversation, a different MCP connection). Omit it if this connection already called bardo_solve.",
            "title": "Session Token"
          },
          "summary": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "Same meaning as in bardo_note_add — updates in place, no history kept.",
            "title": "Summary"
          },
          "tags": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "Same meaning as in bardo_note_add — updates in place, no history kept.",
            "title": "Tags"
          },
          "text": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "Replace the whole note body. Give at most one of text / append_text / find+replace.",
            "title": "Text"
          },
          "title": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "Same meaning as in bardo_note_add — updates in place, no history kept.",
            "title": "Title"
          }
        },
        "required": [
          "note_id"
        ],
        "title": "bardo_note_updateArguments",
        "type": "object"
      },
      "name": "bardo_note_update",
      "outputSchema": null
    },
    {
      "description": "List your notes — previews only (title/summary/snippet/tags/links),\nnever full text. Omit limit for everything; pass it to page through a\nlarge list, using the returned total_notes to know how much is left.",
      "inputSchema": {
        "additionalProperties": false,
        "properties": {
          "limit": {
            "anyOf": [
              {
                "type": "integer"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "Max notes to return. Omit for everything; use with offset and the response's total_notes to page through a large list.",
            "title": "Limit"
          },
          "offset": {
            "default": 0,
            "description": "How many notes to skip, for paging.",
            "title": "Offset",
            "type": "integer"
          },
          "session_token": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "Bardo session token, only needed if this call's identity was established somewhere other than this exact connection (a plain HTTP/curl solve, a previous conversation, a different MCP connection). Omit it if this connection already called bardo_solve.",
            "title": "Session Token"
          }
        },
        "title": "bardo_notes_listArguments",
        "type": "object"
      },
      "name": "bardo_notes_list",
      "outputSchema": null
    },
    {
      "description": "List first-party notices about your account (policy changes, exports, …).",
      "inputSchema": {
        "additionalProperties": false,
        "properties": {
          "session_token": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "Bardo session token, only needed if this call's identity was established somewhere other than this exact connection (a plain HTTP/curl solve, a previous conversation, a different MCP connection). Omit it if this connection already called bardo_solve.",
            "title": "Session Token"
          },
          "unread_only": {
            "default": false,
            "description": "Return only unread notices instead of the full list.",
            "title": "Unread Only",
            "type": "boolean"
          }
        },
        "title": "bardo_noticesArguments",
        "type": "object"
      },
      "name": "bardo_notices",
      "outputSchema": null
    },
    {
      "description": "Mark notices read — all of them, or a specific list of ids.",
      "inputSchema": {
        "additionalProperties": false,
        "properties": {
          "ids": {
            "anyOf": [
              {
                "items": {
                  "type": "integer"
                },
                "type": "array"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "Specific notice ids to mark read. Omit for all notices.",
            "title": "Ids"
          },
          "session_token": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "Bardo session token, only needed if this call's identity was established somewhere other than this exact connection (a plain HTTP/curl solve, a previous conversation, a different MCP connection). Omit it if this connection already called bardo_solve.",
            "title": "Session Token"
          }
        },
        "title": "bardo_notices_ackArguments",
        "type": "object"
      },
      "name": "bardo_notices_ack",
      "outputSchema": null
    },
    {
      "description": "Abort a queued policy loosening before it takes effect. No step-up\nneeded — aborting only ever tightens back to the current policy.",
      "inputSchema": {
        "additionalProperties": false,
        "properties": {
          "session_token": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "Bardo session token, only needed if this call's identity was established somewhere other than this exact connection (a plain HTTP/curl solve, a previous conversation, a different MCP connection). Omit it if this connection already called bardo_solve.",
            "title": "Session Token"
          }
        },
        "title": "bardo_policy_abort_pendingArguments",
        "type": "object"
      },
      "name": "bardo_policy_abort_pending",
      "outputSchema": null
    },
    {
      "description": "View your self-binding security policy: export mode, session TTL cap,\nservice allowlist, ratchet delay, tag encryption, delete grace period —\nplus any pending (queued) loosening and when it lands.",
      "inputSchema": {
        "additionalProperties": false,
        "properties": {
          "session_token": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "Bardo session token, only needed if this call's identity was established somewhere other than this exact connection (a plain HTTP/curl solve, a previous conversation, a different MCP connection). Omit it if this connection already called bardo_solve.",
            "title": "Session Token"
          }
        },
        "title": "bardo_policy_getArguments",
        "type": "object"
      },
      "name": "bardo_policy_get",
      "outputSchema": null
    },
    {
      "description": "Propose a change to your security policy. Give only the fields you\nwant to change (export_mode: 'allow'|'require_repuzzle'|'disabled').\n\nA change that only tightens (e.g. lowering max_session_ttl, narrowing\nservice_allowlist, moving export_mode toward 'disabled') applies\nimmediately. A change that loosens *anything* is queued behind\nloosen_delay_seconds instead — abortable via bardo_policy_abort_pending\nuntil it lands.\n\nclear: field names to reset to null — only max_session_ttl (no ceiling)\nor service_allowlist (any service) accept this; pass service_allowlist=[]\ninstead if you mean \"no services allowed\", which is different from null.\n\nRequires a step-up puzzle. If challenge_id and answer are omitted, a\nfresh puzzle is returned — solve it yourself, then call this tool again\nwith your desired fields plus challenge_id and answer.\n",
      "inputSchema": {
        "additionalProperties": false,
        "properties": {
          "answer": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "Your solved answer to challenge_id's puzzle.",
            "title": "Answer"
          },
          "challenge_id": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "Step-up puzzle id, if one was already returned by a prior call to this same tool. Omit together with answer to have a fresh puzzle minted automatically.",
            "title": "Challenge Id"
          },
          "clear": {
            "anyOf": [
              {
                "items": {
                  "type": "string"
                },
                "type": "array"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "Field names to reset to null instead of leaving unchanged — only max_session_ttl and service_allowlist accept this.",
            "title": "Clear"
          },
          "delete_grace_seconds": {
            "anyOf": [
              {
                "type": "integer"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "How long a deleted note stays recoverable before permanent purge. Raising it tightens.",
            "title": "Delete Grace Seconds"
          },
          "export_mode": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "'allow' | 'require_repuzzle' | 'disabled', stricter in that order. Moving toward 'disabled' tightens; toward 'allow' loosens.",
            "title": "Export Mode"
          },
          "loosen_delay_seconds": {
            "anyOf": [
              {
                "type": "integer"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "How long a future loosening change is queued before it lands. Raising it tightens.",
            "title": "Loosen Delay Seconds"
          },
          "max_session_ttl": {
            "anyOf": [
              {
                "type": "integer"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "Session lifetime cap in seconds. Lowering it tightens; raising it loosens. Use clear=['max_session_ttl'] for no ceiling.",
            "title": "Max Session Ttl"
          },
          "service_allowlist": {
            "anyOf": [
              {
                "items": {
                  "type": "string"
                },
                "type": "array"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "Services allowed to be derived. Narrowing the list tightens, widening it loosens. Pass [] for 'no services allowed' (different from clearing it via clear=['service_allowlist'], which means 'any service').",
            "title": "Service Allowlist"
          },
          "session_token": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "Bardo session token, only needed if this call's identity was established somewhere other than this exact connection (a plain HTTP/curl solve, a previous conversation, a different MCP connection). Omit it if this connection already called bardo_solve.",
            "title": "Session Token"
          },
          "tags_encrypted": {
            "anyOf": [
              {
                "type": "boolean"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "Whether note tags are stored encrypted (true) or plaintext-searchable (false). Moving to true tightens.",
            "title": "Tags Encrypted"
          }
        },
        "title": "bardo_policy_setArguments",
        "type": "object"
      },
      "name": "bardo_policy_set",
      "outputSchema": null
    },
    {
      "description": "Fetch your signing + encryption public keys (root, or for a service).",
      "inputSchema": {
        "additionalProperties": false,
        "properties": {
          "service": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "Fetch this service-derived identity's public keys instead of root's.",
            "title": "Service"
          },
          "session_token": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "Bardo session token, only needed if this call's identity was established somewhere other than this exact connection (a plain HTTP/curl solve, a previous conversation, a different MCP connection). Omit it if this connection already called bardo_solve.",
            "title": "Session Token"
          }
        },
        "title": "bardo_public_keyArguments",
        "type": "object"
      },
      "name": "bardo_public_key",
      "outputSchema": null
    },
    {
      "description": "Create a new Bardo identity. Save the returned api_key somewhere\ndurable — it's your only way back to this identity across sessions.\nBardo stores it sealed and cannot recover it if you lose it.\n\nNot active yet: give the returned claim_url to your human. Authentication\nfails until they visit it and acknowledge the registration.",
      "inputSchema": {
        "additionalProperties": false,
        "properties": {},
        "title": "bardo_registerArguments",
        "type": "object"
      },
      "name": "bardo_register",
      "outputSchema": null
    },
    {
      "description": "List service-scoped identities you've already derived (bardo_derive),\nwith their public keys and revoked status.",
      "inputSchema": {
        "additionalProperties": false,
        "properties": {
          "session_token": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "Bardo session token, only needed if this call's identity was established somewhere other than this exact connection (a plain HTTP/curl solve, a previous conversation, a different MCP connection). Omit it if this connection already called bardo_solve.",
            "title": "Session Token"
          }
        },
        "title": "bardo_services_listArguments",
        "type": "object"
      },
      "name": "bardo_services_list",
      "outputSchema": null
    },
    {
      "description": "Revoke the session you're using right now. You'll need bardo_login\n(+ bardo_solve) again afterward to do anything session-gated.",
      "inputSchema": {
        "additionalProperties": false,
        "properties": {
          "session_token": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "Bardo session token, only needed if this call's identity was established somewhere other than this exact connection (a plain HTTP/curl solve, a previous conversation, a different MCP connection). Omit it if this connection already called bardo_solve.",
            "title": "Session Token"
          }
        },
        "title": "bardo_session_revoke_currentArguments",
        "type": "object"
      },
      "name": "bardo_session_revoke_current",
      "outputSchema": null
    },
    {
      "description": "List your active sessions (sliding TTL, absolute 24h cap each).",
      "inputSchema": {
        "additionalProperties": false,
        "properties": {
          "session_token": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "Bardo session token, only needed if this call's identity was established somewhere other than this exact connection (a plain HTTP/curl solve, a previous conversation, a different MCP connection). Omit it if this connection already called bardo_solve.",
            "title": "Session Token"
          }
        },
        "title": "bardo_sessions_listArguments",
        "type": "object"
      },
      "name": "bardo_sessions_list",
      "outputSchema": null
    },
    {
      "description": "Revoke every active session for your identity — e.g. after a\nsuspected API-key leak. You'll need to log in again afterward.",
      "inputSchema": {
        "additionalProperties": false,
        "properties": {
          "session_token": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "Bardo session token, only needed if this call's identity was established somewhere other than this exact connection (a plain HTTP/curl solve, a previous conversation, a different MCP connection). Omit it if this connection already called bardo_solve.",
            "title": "Session Token"
          }
        },
        "title": "bardo_sessions_revoke_allArguments",
        "type": "object"
      },
      "name": "bardo_sessions_revoke_all",
      "outputSchema": null
    },
    {
      "description": "Sign a UTF-8 message with the spirit key (or a service-derived key).",
      "inputSchema": {
        "additionalProperties": false,
        "properties": {
          "message": {
            "description": "UTF-8 message to sign.",
            "title": "Message",
            "type": "string"
          },
          "service": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "Sign with this service-derived key instead of your root identity (e.g. 'github.com') — must already exist via bardo_derive.",
            "title": "Service"
          },
          "session_token": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "Bardo session token, only needed if this call's identity was established somewhere other than this exact connection (a plain HTTP/curl solve, a previous conversation, a different MCP connection). Omit it if this connection already called bardo_solve.",
            "title": "Session Token"
          }
        },
        "required": [
          "message"
        ],
        "title": "bardo_signArguments",
        "type": "object"
      },
      "name": "bardo_sign",
      "outputSchema": null
    },
    {
      "description": "Submit your answer to the login puzzle. On success, this connection is\nnow logged in — every other tool (bardo_sign, bardo_notes_list,\nbardo_dashboard, ...) just works from here with no session_token needed.\n\nThat only holds for *this* connection, though: if you continue in a\ndifferent connection later, or you solved the puzzle via a plain HTTP\ncall instead of this tool, that other context won't know about this\nsession automatically — pass the returned session_token explicitly as\nthe session_token argument to whichever tool needs it there instead.",
      "inputSchema": {
        "additionalProperties": false,
        "properties": {
          "answer": {
            "description": "Your solved answer to the puzzle.",
            "title": "Answer",
            "type": "string"
          },
          "challenge_id": {
            "description": "The puzzle id returned by bardo_login.",
            "title": "Challenge Id",
            "type": "string"
          }
        },
        "required": [
          "challenge_id",
          "answer"
        ],
        "title": "bardo_solveArguments",
        "type": "object"
      },
      "name": "bardo_solve",
      "outputSchema": null
    },
    {
      "description": "Mint a fresh step-up puzzle for a privileged action (currently:\nbardo_policy_set). Solve it yourself, then pass challenge_id + your\nanswer to the tool that needs it. (bardo_policy_set also mints one\nitself on demand — call this directly only if you want the puzzle\nup front.)",
      "inputSchema": {
        "additionalProperties": false,
        "properties": {
          "session_token": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "Bardo session token, only needed if this call's identity was established somewhere other than this exact connection (a plain HTTP/curl solve, a previous conversation, a different MCP connection). Omit it if this connection already called bardo_solve.",
            "title": "Session Token"
          }
        },
        "title": "bardo_stepupArguments",
        "type": "object"
      },
      "name": "bardo_stepup",
      "outputSchema": null
    },
    {
      "description": "Verify a signature over a UTF-8 message. Public utility (no session).",
      "inputSchema": {
        "additionalProperties": false,
        "properties": {
          "message": {
            "description": "UTF-8 message the signature was made over.",
            "title": "Message",
            "type": "string"
          },
          "public_key_b64": {
            "description": "Signer's public key, base64 — from bardo_public_key or a document's own proof.",
            "title": "Public Key B64",
            "type": "string"
          },
          "signature_b64": {
            "description": "Signature to verify, base64.",
            "title": "Signature B64",
            "type": "string"
          }
        },
        "required": [
          "message",
          "signature_b64",
          "public_key_b64"
        ],
        "title": "bardo_verifyArguments",
        "type": "object"
      },
      "name": "bardo_verify",
      "outputSchema": null
    }
  ]
}

Verify it yourself

curl -s https://api.teppi.xyz/v1/evidence/sha256:d69b2bb8420033e5cc0f4ec3231a4a2199f192eb322ff296b7694109f381abf0 | sha256sum