Every tool the brain offers, in its own words.

THE BRAINS YOU HOLD. Each with its name, id, kind (private or shared), whether it is encrypted, and your role on its root. With more than one, pass a name or id as `brain` to every other tool; search_brain without it looks in all of them. An encrypted brain is read only on its people's computers: no tool here reads or writes it.

takes nothing
returns {brains}, each with name, id, kind, encrypted, role

START HERE to find anything. Search for words; each must start a word of a page's path or text (quit finds quitting), any order, any case. Returns matching paths, each with the brain it is in, the paragraph where the words land, and updated_at. Without `brain` it searches every brain you hold. path_prefix narrows to one folder (e.g. operations/quit-smoking/). Then call read_node on a path, with the hit's brain.

takes query (up to 500 characters), limit (1 to 50, default 10), path_prefix, brain
returns {hits}: each path with its brain, the paragraph, and updated_at

READ THE BRAIN. Returns one node as plain markdown, addressed by its path (e.g. operations/quit-smoking/brief.md), followed by one JSON line of metadata: version (what write_node's expected_version wants), updated_at, content_hash (compare against your copy to check staleness). Pass section (a heading, e.g. "## Day log") to get just that block instead of the whole page. Pass version to read an older version — only versions node_history lists exist; recording began 2026-09-07.

takes path, section, version, brain
returns the body as markdown in one block, then {path, brain, version, updated_at, content_hash} in a second, so a copy back into a write cannot carry a stale line
refuses a miss is an answer in words: no open-area node at that path, or the headings when a section is not there

BROWSE a brain. Lists open-area pages under a path prefix (e.g. operations/) with version, updated_at, content_hash and size — no content. Also the cheap staleness check: compare content_hash against your copy and re-read only the pages that changed. Empty prefix lists everything.

takes path_prefix, limit (1 to 500, default 200), brain
returns {brain, nodes}

THE UNDO MAP. Lists recorded versions of one page, newest first: version, writer (the client), person (the user behind it, or null), written_at, content_hash, size. Read an old body with read_node(path, version). Recording began 2026-09-07 and nothing is backfilled, so a page at version 14 may list only 14 — the missing versions predate history and are gone, not broken.

takes path, limit (1 to 100, default 20), brain
returns {path, versions}

THE FOLDER MAP. One call shows a brain's folders with how many pages each holds, each folder's index file and the one sentence it states as the folder's purpose, and the skeleton files marked ★. Call it before you add a page or a folder, so the page lands where its kind already lives; it replaces walking the tree with list_nodes, and it is how you find the folder that already exists before you make a second one under another name. path narrows to one folder; depth (default 2) is how many folder levels it shows. It lists folders, not pages: list_nodes lists the pages of one folder.

takes path (a folder), depth (1 to 6, default 2), brain
returns text: the map, at most 300 folder lines and 60 root pages
refuses in an encrypted brain, a note that no map can be made there

THE BRAIN'S OWN RULES, ALL AT ONCE. Returns every skeleton file of a brain in one response, each with its role: CLAUDE.md, the index, and each top folder's index file. Read it before you change how the brain is organised, or when the owner asks how it works. It is large: to work on one task, read CLAUDE.md and the one index file of the folder you work in with read_node instead. Lists the skeleton files the brain lacks.

takes brain
returns text: the count and the missing files, then each file with its role and version, at most 300,000 characters
refuses in an encrypted brain, the same note

AUDIT THE STRUCTURE; it changes nothing. Compares a brain with its template and its own index files: skeleton files that are missing, folders without an index file, index files without a purpose sentence, pages outside any known folder, links in the skeleton and index files that point nowhere, and pages no page links to. Each finding says how to fix it. Report the findings to the owner. Fix one only when your task calls for it or the owner agrees: new structure needs a go.

takes brain
returns {brain, template, checked, counts, findings, note}, at most 100 findings, each with a fix
refuses in an encrypted brain, the same note

ASK YOUR PERSON FOR A GO. Leave a proposal: a change you want their yes on before you make it, such as a new folder, a change to a skeleton file (★ in brain_map) you may not edit, or a large reorganisation. It shows in the cockpit's Waiting for you until your person marks it done. Give a short title, the change and why in the body, and the page it concerns, if one. The brain keeps it as plain text, readable by your person alone.

takes title (1 to 120 characters), body (up to 2,000), path, brain
returns {id, brain, waiting: true}
refuses not_found for a path it cannot read; encrypted_brain; quota past 50 proposals waiting in the brain; forbidden for a connection no person approved

SYNC PLUMBING, not for reading. Whether any node changed since a timestamp. Only a sync client needs this. To read the brain use search_brain and read_node.

takes since (an ISO-8601 date and time with its zone), brain
returns {changed, latest}: how many nodes changed after since in the folders you read, and the newest stamp

SYNC PLUMBING, not for reading. Returns encrypted blobs and version vectors for a sync client to merge: content is base64 and may be ciphertext you cannot decrypt. To read the brain use search_brain and read_node instead. (max 200)

takes since, after (the id the last page had at that stamp), brain
returns {nodes}, ascending, at most 200

SYNC PLUMBING, not for writing prose. Pushes pre-encoded nodes from a sync client; a conflict returns the server vclock to merge and retry.

takes nodes[], brain
returns {results}, one per node: ok, or concurrent with the server's vector, path_taken, or invalid naming the field
refuses rate_limited, with the seconds to wait, when the account pushed more than its rate allows