Base address

Every path below is relative to the Sigil site your vault lives on. Responses are JSON. Errors are JSON too, as { "error": "...", "code": "..." }.

Terminal
curl https://sigilvault.fun/api/seals?limit=3

Public endpoints

No key, no session. These power the Status, Seals and Verify pages.

GET/api/status

Health of the server and the seal job. Running it also seals any finished hour that is still open.

Response
{
  "ok": true,
  "time": "2026-11-20T10:00:04.512Z",
  "upSeconds": 86400,
  "database": "ok",
  "seals": {
    "enabled": true,
    "periodSeconds": 3600,
    "mode": "local",
    "job": "ok",
    "currentHour": 496234,
    "open": 2,
    "overdue": 0,
    "lastSealedAt": "2026-11-20T10:00:01.220Z",
    "seals": 41,
    "leaves": 318,
    "latestHour": 496233
  }
}

job is ok, off or failed. open counts reads waiting for the running hour to end; overdue counts reads from finished hours that are not sealed.

GET/api/stats

The public counters. Counts only.

Response
{ "vaults": 12, "memories": 4310, "apps": 19, "reads": 320, "seals": 41 }

reads is every read ever sealed plus those waiting for a seal, so it does not drop when a vault is deleted.

GET/api/seals

The newest seals, newest first.

limit
1 to 200. Default 24.
Response
{
  "mode": "local",
  "periodSeconds": 3600,
  "seals": [
    {
      "hour": 496233,
      "root": "0x...",
      "leaves": 7,
      "sealedAt": "2026-11-20T10:00:01.220Z",
      "anchorTx": null,
      "anchoredAt": null
    }
  ]
}

hour is the seal number: the Unix time divided by the period. mode is local, or anchored when roots are also published on chain.

GET/api/seals/:hour

One seal by its number.

Response
{
  "mode": "local",
  "periodSeconds": 3600,
  "seal": { "hour": 496233, "root": "0x...", "leaves": 7, "sealedAt": "...", "anchorTx": null, "anchoredAt": null }
}

404 with code no_seal when that hour has no seal.

GET/api/seals/:hour/proof

The Merkle proof for one fingerprint in one seal.

leaf
The fingerprint: 0x and 64 hex characters.
Response
{
  "hour": 496233,
  "root": "0x...",
  "leaf": "0x...",
  "index": 3,
  "proof": ["0x...", "0x...", "0x..."]
}

404 with code not_in_seal when the fingerprint is not part of that seal. A fingerprint is a salted hash and reveals nothing about the read behind it.

GET/api/semantic

Whether search by meaning is on, and which sentence model the vault page loads. The model runs in the browser.

Response
{ "enabled": true, "model": "Xenova/all-MiniLM-L6-v2" }

GET/models/<model>/<file>

The files of that model: tokenizer.json, tokenizer_config.json and onnx/model_quantized.onnx. Public weights, the same for everyone.

Response
The file itself, JSON or binary.

Any other model or file is 404. Missing files are fetched once from the public model hub unless SIGIL_MODEL_FETCH is off.

POST/api/seals/roots

The published roots of many hours at once, for checking a life certificate.

hours
Up to 20,000 seal numbers.
Response
{ "roots": { "496233": "0x...", "496234": "0x..." } }

Hours without a seal are left out.

GET/api/certificates/:id

A life certificate its owner published by link, exactly as it was signed. It holds no content of the vault.

Response
{
  "format": "sigil-life-certificate",
  "version": 1,
  "body": {
    "origin": "https://<your Sigil site>",
    "periodSeconds": 3600,
    "signingKey": "<Ed25519 public key, base64url>",
    "issuedAt": "2026-11-20T10:00:00.000Z",
    "summary": { "firstHour": 490000, "lastHour": 496233, "activeHours": 812, "activeDays": 203, "longestGapHours": 70, "continuousMonths": 8, "...": "..." },
    "hours": [{ "hour": 490000, "entry": { "id": "...", "at": "...", "salt": "...", "sig": "..." }, "index": 3, "proof": ["0x..."], "root": "0x..." }]
  },
  "signature": "<Ed25519 signature, base64url>"
}

404 no_certificate once the owner takes it down. How to check one is on the verify page.

GET/api/identity/config

Where the registry of AI selves is, once the site has one. Null until a chain id and an address are set.

Response
{ "chain": { "chainId": "8453", "registry": "0x...", "rpcUrl": "https://<public read address>" } }

With chain null, the Identity tab works off chain. The read address is public and read-only; the vault reads a self wallet's spends through it.

GET/api/identity/at/:address

The identity statement of a self key, signed by the owner's vault key and the self key. This is what the registry's metadata address points to.

Response
{
  "format": "sigil-self-identity",
  "version": 1,
  "body": { "selfKey": "0x...", "signingKey": "...", "name": "Sam's AI self", "about": "...", "owner": null, "wallet": null, "chain": null, "origin": "https://...", "issuedAt": "..." },
  "vaultSignature": "<Ed25519, base64url>",
  "selfSignature": "0x<EIP-191 signature>"
}

404 no_identity when the owner has not signed one or withdrew it. The site checks both signatures before it keeps a statement.

GET/api/proofs/:id

A proof of a fact its owner shared by link: one claim, its evidence, the signature and the sealed entry of the statement.

Response
{ "format": "sigil-disclosure", "version": 1, "statement": { "claim": { "kind": "field", "opening": { "name": "Nationality", "value": "...", "salt": "...", "index": 2, "proof": ["0x..."] }, "commitment": "0x..." }, "...": "..." }, "signature": "...", "anchor": { "kind": "disclose", "memoryId": "0x...", "hour": 496233, "proof": ["0x..."], "root": "0x..." } }

404 no_proof once the owner takes it down. How to check one is on the verify page.

GET/api/e/:id

An emergency card's ciphertext. The key is only in the link after #, so the server cannot open what it serves. Each call is recorded for the owner with the time, a device class and a language.

Response
{ "card": "v1.<iv>.<ciphertext>", "updatedAt": "2026-11-20T10:00:00.000Z" }

404 no_card when the owner took it down or issued a new code. 60 a minute per address.

GET/api/packs/at/:id

A knowledge pack, as its publisher signed it: the newest version, or one by number with ?version=n.

Response
{ "format": "sigil-knowledge-pack", "version": 1, "body": { "id": "...", "title": "Bread", "version": 2, "previous": "0x...", "publisher": { "name": "Sam", "signingKey": "..." }, "items": [], "...": "..." }, "hash": "0x...", "signature": "..." }

GET /api/packs/at/:id/versions lists every version with its hash. 404 no_pack once the publisher takes it down.

POST/api/devices/pairings

A new device opens a pairing: its one-time X25519 public key, the ten-character code made from that key, and a secret only it holds.

id
A new random id.
publicKey
The one-time public key, base64url.
code
XXXXX-XXXXX, the hash of the key in Crockford base32. Refused when it does not match the key.
pollSecret
32 random bytes, base64url. The server keeps its hash.
Response
{ "expiresAt": "2026-11-20T10:10:00.000Z" }

A pairing lasts ten minutes. 20 a minute per address.

POST/api/devices/pairings/:id/poll

The new device asks for its sealed box with its poll secret. It is handed out once and then deleted.

pollSecret
The secret from opening the pairing.
Response
{ "state": "ready", "sealed": "s1..." }

state is waiting, ready or gone. The box is sealed to the one-time key; only the new device opens it.

Nodes, capture keys and sessions

A node's health, restoring and moving a vault (the formats are in the open standard, part 11), the write-only capture keys and booked sessions with a public AI self (part 12).

GET/api/health

The node's health, for a container's health check, a load balancer or another node. It touches no vault.

Response
{ "ok": true, "node": { "origin": "https://node.example", "version": "0.1.0", "spec": "1.3.0" }, "time": "2026-11-20T10:00:00.000Z" }

Any origin may call it.

POST/api/restore/fetch

Fetches a bundle for a restore from a public address (an IPFS or Arweave gateway, a bucket address presigned on the owner's device) and passes its bytes on. Nothing is kept.

url
An https address. A private network address is refused unless the node allows it (SIGIL_NODE_ALLOW_PRIVATE).
Response
The bundle file's bytes, application/octet-stream.

From the site itself only. 10 a minute per address. Redirects are not followed.

POST/api/restore

Takes a bundle in as a new vault on this node, with the owner's sign-in and a statement the vault key signed for this node. Opens a session.

bundle
The vault bundle (open standard, part 11).
signIn
{ kind: wallet or phrase, ref, authToken }: the SHA-256 of authToken must be the bundle key slot's authHash.
statement
{ issuedAt, signature }: Ed25519 by the vault's signing key over sigil-restore-v1, this node's origin, the bundle hash and issuedAt; at most ten minutes old.
arrival
For a move: { code, at, signature, redirectDays }. The node fetches the move from the old node again and tells it once the vault is in.
Response
{ "report": { "userId": "...", "hash": "0x...", "folders": 4, "memories": 120, "logEntries": 310, "taken": { "apps": 2 }, "left": {} }, "confirmed": true }

409 vault_exists when the vault, or one of its sign-in methods, is already on this node. 403 bad_restore or bad_sign_in. 400 bad_bundle.

GET/api/nodes/moves/:id

Node to node: the move statement, its signature and the bundle, for the holder of the move's secret.

Authorization
Bearer <the secret from the move code>. The old node keeps only its hash.
Response
{ "move": { "statement": { "format": "sigil-move", "v": 1, "id": "...", "vault": "...", "from": "...", "to": "...", "bundle": "0x...", "redirectDays": 30, "issuedAt": "..." }, "signature": "..." }, "bundle": { "...": "..." } }

410 move_closed once cancelled or done. The first fetch is logged as bundle-sent.

POST/api/nodes/moves/:id/done

Node to node: the arrival the owner's device signed on the new node. Once it holds under the vault's key, the old node sends the vault's addresses on and deletes it when the period ends.

Authorization
Bearer <the move's secret>.
at, signature
Ed25519 by the vault's signing key over sigil-arrived-v1, the move id, the new origin, the bundle hash and at.
Response
{ "until": "2026-12-20T10:00:00.000Z" }

403 bad_arrival. Afterwards sign-ins, app keys and the vault's public addresses answer 410 moved with { to }.

GET/api/capture/v1/key

For a capture key: the vault public key and the tag the owner's vault made over it for this key. Check the tag before sealing anything.

Authorization
Bearer <base64url HKDF(secret, sigil:auth:capture)>.
Response
{ "captureId": "...", "publicKey": "...", "tag": "<hex>" }

401 capture_revoked for a revoked key.

POST/api/capture/v1

One capture into the inbox, sealed on the sending device to the vault public key, as a proposal whose app id is the capture key's id.

id
The proposal id.
sealed
The sealed proposal, context proposal:<id>:<capture key id>.
Response
{ "id": "...", "createdAt": "2026-11-20T10:00:00.000Z" }

20 a minute and 300 a day per key; an inbox holds 500. POST /api/capture/v1/text with { text, title } is for a key the owner allowed plain text: sealed by the node on arrival, 403 plain_off otherwise.

GET/api/public/at/:handle/sessions

A public AI self's sessions: the offer (topics, questions, length, house rules, intake, consent) and the free times of the next two weeks.

Response
{ "selfId": "...", "handle": "gardener", "name": "...", "publicKey": "...", "offer": { "turns": 8, "slotMinutes": 30, "houseRules": "...", "...": "..." }, "slots": [{ "start": "...", "end": "..." }] }

offer is null when the owner takes no bookings.

POST/api/public/at/:handle/sessions

Books a free time. The intake is sealed in the visitor's browser to the public self's key.

id, slotStart, topic
The booking.
intake
Sealed to the public self's key, context session-intake:<self id>:<booking id>.
tokenHash
SHA-256 of the session token from the link's secret.
askerKey
The visitor's X25519 key for the session, made from the link's secret.
Response
{ "id": "...", "slotStart": "...", "slotEnd": "..." }

409 slot_taken; 403 blocked; 429 visitor_limit (two upcoming sessions per visitor). 6 a minute per address.

GET/api/sessions/:id

A session, for the bearer of its link: its topic, time, questions used, house rules, whether the host's AI self is answering, and why a question cannot be asked now, if so.

Authorization
Bearer <session token>.
Response
{ "topic": "Soil", "slotStart": "...", "slotEnd": "...", "turns": 8, "used": 1, "state": "booked", "houseRules": "...", "online": true, "problem": null, "...": "..." }

POST /api/sessions/:id/questions with { id, sealed } asks (409 session_closed outside its time or questions, 503 offline); GET /api/sessions/:id/questions/:qid gives the sealed answer.

Ask link endpoints

Anyone holding an ask link can call these. The server relays sealed boxes between the asker's browser and the owner's agent and keeps the limits; it cannot open a question, an answer or the greeting. How the boxes are made is in the docs.

POST/api/ask/:link/questions

One question, sealed in the asker's browser for the owner's agent.

id
A new random id for the question.
sessionId
The conversation's random id.
askerKey
The asker's X25519 public key for this conversation, base64url.
sealed
The relay box, r1.<nonce>.<ciphertext>: XChaCha20-Poly1305 under the conversation key.
Response
{ "id": "..." }

503 offline when no one is there to answer, 410 expired, revoked or used_up, 429 link_busy over the link's hourly limit, 429 waiting while the last question of the conversation has no answer yet. 8 a minute and 60 an hour per address.

GET/api/ask/:link/questions/:id

The answer, once there is one, as a relay box only the asker opens.

Response
{ "status": "answered", "answer": "r1..." }

status is waiting, answered, or gone (no answer within two minutes, or the question expired). Questions are deleted a day after they were asked.

GET/api/public/at/:handle

A public AI self: its name, greeting and published key, whether it is on and online, the titles of its public notes, and the answers its owner shows.

Response
{
  "id": "...",
  "handle": "sam",
  "name": "Sam's AI self",
  "greeting": "Ask me about my talks.",
  "publicKey": "<32-byte X25519 key, base64url>",
  "enabled": true,
  "online": true,
  "perVisitorHour": 10,
  "showAnswers": true,
  "items": [{ "id": "...", "title": "Talks", "tags": [], "editedAt": "..." }],
  "wall": [{ "id": "...", "question": "...", "answer": "...", "sources": [{ "id": "...", "title": "Talks" }], "createdAt": "..." }]
}

GET /api/public/at/:handle/items/:id gives one public note in full. 404 no_public when there is no such page.

POST/api/public/at/:handle/questions

One question to a public AI self, sealed in the visitor's browser like an ask link question, with the conversation key made from the published key.

id
A new random id for the question.
sessionId
The conversation's random id.
askerKey
The visitor's X25519 public key for this conversation.
sealed
The relay box, r1.<nonce>.<ciphertext>.
Response
{ "id": "..." }

Poll GET /api/public/at/:handle/questions/:id for the answer, a relay box holding { text, refused, sources }. 503 offline, 410 off, 429 visitor_limit over the owner's limit per visitor an hour (counted by a hash of the address and the page), 429 waiting.

Authentication for connected apps

An app key looks like sigil_app.<app id>.<secret>. The secret is 32 random bytes. It is never sent to the server. Four things are derived from it with HKDF-SHA256 (salt sigil/hkdf/v1):

LabelResultUsed for
sigil:auth:appThe bearer token, base64urlAuthorization: Bearer <token>. The server stores only its SHA-256.
sigil:wrap:appThe app wrap keyOpens the folder keys that were wrapped for this app. Stays on the caller's machine.
sigil:tag:app-boxThe tag keyChecks the tag on the vault public key from /inbox: HMAC-SHA256 of sigil-box-v1:<public key>.
sigil:wrap:selfThe AI self keyOpens the AI self config and the ask links from /self, when the owner allowed this app. Stays on the caller's machine.

The connector, the browser extension and the Sign in with Sigil SDK do all of this for you. Use the endpoints directly only when you build your own reader; the envelope and sealed box formats and every label are in the encryption model. The connector endpoints answer any origin (they take a bearer token, never a cookie), so a web app can call them from the browser.

Connector endpoints

One bearer token per app. Reads, suggestions and answers as the owner's AI self when the owner allows them; every read, every suggestion and every answer is written to the vault owner's read log.

GET/api/connector/v1/folders

The folders this app may read, with the folder keys wrapped for this app.

Response
{
  "appId": "...",
  "folders": [
    { "id": "...", "meta": "v1...", "wrappedKey": "v1...", "count": 12 }
  ]
}

Logged as: the app listed its folders.

GET/api/connector/v1/index

The encrypted heads (title, tags, source, first lines, dates) of every memory in the granted folders. Search happens on the caller's side.

Response
{
  "appId": "...",
  "folders": [...],
  "memories": [
    { "id": "...", "folderId": "...", "head": "v1..." }
  ]
}

Logged as: the app read the index of N memories. Search words are never sent.

POST/api/connector/v1/read

The full encrypted memories for 1 to 20 ids.

ids
JSON body: { "ids": ["..."] }
Response
{
  "appId": "...",
  "folders": [...],
  "memories": [
    { "id": "...", "folderId": "...", "head": "v1...", "body": "v1..." }
  ],
  "missing": ["..."]
}

Each memory found is logged as one read. Ids outside the granted folders come back under missing, without saying whether they exist.

GET/api/connector/v1/inbox

The vault's public key and the tag the owner's device made for this app. Check the tag with the app secret before sealing anything.

Response
{
  "appId": "...",
  "publicKey": "<32-byte X25519 key, base64url>",
  "tag": "<HMAC-SHA256, hex>"
}

403 with code propose_off unless the owner let this app suggest memories. Not logged: it reads no memory.

POST/api/connector/v1/proposals

Puts one suggested memory, sealed to the vault's public key, in the owner's inbox.

id
A new random id, 8 to 64 letters, digits, - or _.
sealed
The sealed box, s1.<ephemeral key>.<nonce>.<ciphertext>, sealed with the context proposal:<id>:<app id>.
Response
{ "appId": "...", "id": "...", "createdAt": "..." }

Logged as: the app suggested a memory. 30 per app per hour (429, propose_limit), up to 500 waiting per vault (429, inbox_full). Anything that is not a sealed box is refused.

GET/api/connector/v1/self

What this app needs to answer as the owner's AI self: the rules, the owner's model key and the vault public key, and the ask links it answers, each encrypted for this app's key only.

Response
{
  "appId": "...",
  "config": "v1...",
  "links": [{ "id": "...", "publicKey": "...", "box": "v1..." }]
}

403 with code self_off unless the owner let this app answer as their AI self. Not logged: it reads no memory.

GET/api/connector/v1/self/pending

Questions waiting for the links this app answers. Calling it marks the app online for those links.

Response
{
  "appId": "...",
  "questions": [
    { "id": "...", "linkId": "...", "sessionId": "...", "askerKey": "...", "sealed": "r1...", "createdAt": "..." }
  ]
}

POST/api/connector/v1/self/questions/:id/answer

The answer for the asker, and the question and answer for the owner's log.

sealed
The answer as a relay box under the conversation key.
note
The question and answer, sealed to the vault public key with the context ask-note:<question id>:<link id>.
cited
How many memories the answer used.
Response
{ "ok": true }

Logged as: your AI self answered a question, with the sealed note.

POST/api/connector/v1/self/asked

The log line for an answer of the ask_self tool, which is made on the owner's machine.

id
A new random id.
note
The question and answer, sealed to the vault public key with the context ask-note:<id>:<app id>.
cited
How many memories the answer used.
Response
{ "ok": true }

30 a minute per app.

GET/api/connector/v1/agent

For an agent key: its own folder, its tool rules and the folders it may write.

Response
{ "appId": "...", "homeFolderId": "...", "rules": { "remember": true, "recall": true, "forget": false, "handoff": true }, "writable": ["..."], "publicKey": "..." }

403 not_agent for an ordinary app key. The tools of an agent with recall off still get the folders they may write from /folders, so they can encrypt for them.

POST/api/connector/v1/remember

Memories an agent encrypted on its machine with the key of a folder it may write.

memories
1 to 20 of { id, folderId, head, body }, each an envelope.
Response
{ "appId": "...", "saved": 1 }

403 remember_off, or read_only for a folder it may not write. 300 an hour per agent. Each is logged as remember.

POST/api/connector/v1/forget

Deletes memories for good, only in folders the agent may write.

ids
1 to 50 memory ids.
Response
{ "appId": "...", "deleted": ["..."], "refused": ["..."] }

403 forget_off unless the owner allowed it. Each deletion is logged as forget.

GET/api/connector/v1/handoffs

Handoff notes waiting for this agent: its own from earlier sessions, and notes other agents left in its spaces.

Response
{ "appId": "...", "handoffs": [{ "id": "...", "fromApp": "...", "spaceId": null, "sealed": "v1...", "createdAt": "..." }] }

POST the same path with { id, sealed, spaceId } to leave one, and POST /handoffs/picked with { ids } to mark them picked up. 403 handoff_off when the owner turned the tool off.

GET/api/connector/v1/spaces

The team spaces this agent is in: the space key sealed to the agent's own key, the members and the memories.

Response
{ "appId": "...", "spaces": [{ "id": "...", "meta": "v1...", "epoch": 2, "me": { "id": "...", "role": "write", "sealedKey": "s1..." }, "members": [], "memories": [] }] }

POST /spaces/:id/memories with { memories } writes, POST /spaces/:id/forget with { ids } deletes, with a write role. Every call is logged as space.

POST/api/connector/v1/read

With protected folders: memories in a protected folder come back in held until the owner says yes for that read.

Response
{ "appId": "...", "folders": [], "memories": [], "missing": [], "held": [{ "folderId": "...", "memoryIds": ["..."], "requestId": "...", "state": "pending" }] }

The request waits in the owner's inbox for 30 minutes. A yes lasts 10 minutes and is used up by the next read that it covers, logged as protected. GET /index leaves protected folders out; GET /index?protected=<folder id> asks to look through one, with the same flow.

GET/api/connector/v1/sync

The live sync sources the owner lets this app sync while the vault is closed: each wrapped for this app's sync key, with its folder and whether it is paused.

Response
{ "appId": "...", "sources": [{ "id": "...", "folderId": "...", "box": "v1...", "rev": 4, "ownerRev": 3, "paused": false }] }

PUT /sync/:id with { box, rev } saves a newer copy (409 stale for an older one). POST /sync/:id/memories with { memories } writes encrypted memories, only into the source's folder; POST /sync/:id/delete with { ids } removes them. Each is logged as sync.

GET/api/connector/v1/public

The public AI self, when the owner picked this app to answer it: its key and rules wrapped for this app, and the public copy it answers from.

Response
{ "appId": "...", "self": { "id": "...", "handle": "sam", "publicKey": "...", "box": "v1...", "enabled": true, "items": [] } }

GET /public/pending marks it online and gives waiting questions; POST /public/questions/:id/answer with { sealed, note, cited, wall } answers. 403 public_off for any other app. A question in a booked session comes with its booking (topic, the sealed intake, house rules, which turn); its note is the turn sealed for the owner's transcript, and it never goes on the page.

GET/api/connector/v1/backup

For a connector the owner lets back the vault up: the storage targets wrapped for this app's key (HKDF(secret, sigil:wrap:backup)), and when the vault was last backed up.

Response
{ "appId": "...", "box": "v1...", "lastAt": "2026-11-19T10:00:00.000Z" }

GET /backup/bundle gives the vault's bundle body as ciphertext; POST /backup/done with { id, hash, size, record, places } logs a backup, record sealed to the vault public key. 403 backup_off for any other app.

Errors and limits

StatusCodeMeaning
400invalidThe request is malformed. The message names the field.
401signed_outA vault request without a session.
401app_revokedThe app key was revoked or never existed.
403originA change to a vault that did not come from the site itself.
403propose_offThis app may not suggest memories; the owner turns it on under Apps.
403self_offThis app may not answer as the owner's AI self; the owner turns it on under AI self.
410expiredThe ask link has expired. Also revoked and used_up.
503offlineThe owner's AI self is offline: their vault is not open and their connector is not answering.
404not_foundNo such endpoint. Also no_seal and not_in_seal on the seal endpoints.
405methodThe endpoint exists, the method does not.
409not_sealedA proof was asked for an entry whose hour has not been sealed yet.
410movedThe vault moved to another node; to names it. Sign-ins, app keys and its public addresses answer this until the old node deletes it.
401capture_revokedThe capture key was revoked or never existed.
403plain_offThis capture key seals on the device; the owner has not allowed plain text for it.
409session_closedA question outside its session's time or number of questions, or in an ended session.
409vault_existsA restore of a vault, or of a sign-in method, that is already on this node.
409staleA folder changed while its new key was being made. Reload and try again.
429rate_limitedToo many requests. Wait a little and try again.
429propose_limitThe app sent 30 suggestions in the last hour.
429link_busyThe ask link had as many questions as it takes in an hour.
403not_releasableA legacy plan was asked for a share or a bundle while its owner is still active.
403not_agentAn agent route was called with an ordinary app key.
403remember_offThe owner turned this agent's tool off. Also recall_off, forget_off and handoff_off.
403read_onlyAn agent tried to write a folder it may only read.
403roleA space member tried something their role does not allow.
404no_pairingNo device is waiting with that code, or it expired or was used.
404unknown_deviceA device that was revoked tried to sign in.
400bad_signatureA signature (presence, an identity statement, an agreement) does not check out against the key the server holds.
409decidedA draft of the AI self was already approved or discarded.
409draftedThere is already a draft for this question or turn.
409closedThe agreement is no longer open for signing.
404no_cardNo emergency card at this address. Also no_proof, no_pack and no_identity.

Limits per minute: 240 requests per app key, 600 connector requests per address, 240 public requests per address, 40 sign-in attempts per address.

The vault session API

The vault page itself talks to a session API: /api/vault, /api/memories, /api/folders (with /rotate for a new folder key), /api/apps (with /inbox for suggestions), /api/proposals, /api/shares, /api/settings (encrypted settings: the AI self's rules, the model key, how the vault thinks), /api/self (ask links, and the open vault answering them), /api/log, /api/keyslots, /api/access (requests to read a protected folder, and the owner's yes or no), /api/sync (live sync sources), /api/public/self (the public AI self and its public copy), /api/meets (selves meet), /api/self/identity (the self key's address and its signed statement), /api/drafts (the AI self's approval queue), /api/disclosures (proofs of a fact), /api/emergency (the emergency card and its openings), /api/agreements (sealed agreements), /api/packs (knowledge packs), /api/bundle and /api/backups (the vault's bundle and the record of each backup), /api/nodes (where the vault lives, and moves), /api/capture-keys, /api/sessions and /api/public/self/sessions (bookings and the offer), /api/spaces/:id/heirs and /leave (shared memory) and the sign-in routes under /api/auth. It accepts only encrypted payloads, only with a session cookie, and changes only from the site itself. It is not meant for other programs; the whole router is one readable file, web/src/server/api.ts.