@ceccec/millennium-solutions 9.7.6 → 9.8.3

package/dist/src/mcp/index.js

@@ -0,0 +1,249 @@
+import { SUITES } from './suites.js';
+export const WRITES = new Set(['lean_seal', 'lean_generate', 'pages', 'ledger_trial']);
+export const TOOLS = [
+    { name: 'novelty', description: 'Run this deposit\'s own prior-art search against any statement: zbMATH, OpenAlex, Crossref, arXiv, and the OEIS for any integer sequence in it. Returns the verdict vocabulary the record uses — CANDIDATES | NONE_FOUND | NONE_FOUND_PARTIAL | NOT_MEASURED | TOO_FEW_TERMS — with the queries sent, the hits, and THE FLOORS APPLIED (relevance ≥ 0.6 over the first 5 results per source), because a verdict cannot be read apart from the domain that made it. NONE_FOUND means "these searches, on this date, returned nothing" and never "nothing earlier exists": a keyword search misses what it does not name. Writes nothing.',
+        inputSchema: { type: 'object', properties: { statement: { type: 'string' }, anchors: { type: 'array', items: { type: 'string' } } }, required: ['statement'] } },
+    { name: 'coils', description: 'The cross formulas, clustered: every expression in the deposit\'s vocabulary evaluated at every point of a grid and grouped by the resulting vector. Two expressions in one coil prove each other — compute either and the other is computed. Returns the coils, the pair count, and the expressions that coil with NOTHING, which are the ones prose must never interchange.',
+        inputSchema: { type: 'object', properties: {}, required: [] } },
+    { name: 'discoveries', description: 'Where the next prior-art search should go, consolidating the generators: which theorems sit in files declaring their own work, which have no search recorded, which families are at octave scale. A RANK IS NOT A NOVELTY CLAIM — this orders a queue, and only a performed search can say whether a statement has an earlier author. Reports the coverage, which is the finding: novelty in this tree is measured for a few per cent of it.',
+        inputSchema: { type: 'object', properties: { cursor: { type: 'number', description: 'the next cursor from the previous page; omit for the first page' }, limit: { type: 'number' } }, required: [] } },
+    { name: 'formulas', description: 'Every formula this deposit decides, as data: the proposition the Lean kernel accepted, character for character, with its file, namespace, wing, tactic and ledger key. Filter by any of them. Nothing summarised and nothing authored.',
+        inputSchema: { type: 'object', properties: { cursor: { type: 'number', description: 'the next cursor from the previous page; omit for the first page' }, wing: { type: 'string' }, file: { type: 'string' }, contains: { type: 'string' }, limit: { type: 'number' } }, required: [] } },
+    { name: 'handle', description: 'The SHORT FORM: the first four hex of an address, plus the message, determine the whole address — so nothing but the message ever travels. Pass text to mint a handle; pass handle AND text to resolve one. ROUTES and REJECTS, never identifies: 16 bits over 2912 sealed receipts collide 71 times (birthday expectation 64.7), and the collision-free minimum today is 7 hex. The window is the FRONT four hex because hex 12..16 and 16..20 overlap the forced version/variant bits and carry less — and hex 12..16 is the third dash-group of the display form, the one an eye would reach for.',
+        inputSchema: { type: 'object', properties: { text: { type: 'string' }, handle: { type: 'string' } }, required: ['text'] } },
+    { name: 'content_address', description: 'Content-address (uuid) any text — INTEGRITY/provenance, NOT encryption or proof.',
+        inputSchema: { type: 'object', properties: { text: { type: 'string' } }, required: ['text'] } },
+    { name: 'honesty_gate', description: 'Run the honesty gate: binary 1 (no named overclaim) or 0 (drains) + the hit. A lexical FLOOR, not a truth oracle; passing != true.',
+        inputSchema: { type: 'object', properties: { text: { type: 'string' } }, required: ['text'] } },
+    { name: 'merkle_fold', description: 'Order-independent merkle fold of a list of strings into one address.',
+        inputSchema: { type: 'object', properties: { items: { type: 'array', items: { type: 'string' } } }, required: ['items'] } },
+    { name: 'probe', description: 'Read-only reachability probe of a public URL: REACHED | INCONCLUSIVE | DRAINS + HTTP failure-mode (429/403/404/5xx classified, rate-respecting). A timeout is INCONCLUSIVE, never "blocked" — HTTP status indexed honestly.',
+        inputSchema: { type: 'object', properties: { url: { type: 'string' } }, required: ['url'] } },
+    { name: 'lineage', description: 'Delivery vs churn across release tags, by git tree hash (git\'s own faithful content-address). Identical trees = a tag minted over no delta (churn); distinct = a delivery. Integrity-level: measures WHAT was delivered, not whether it is true. Heroes and traitors by deeds, not statements.',
+        inputSchema: { type: 'object', properties: {}, required: [] } },
+    { name: 'verify', description: 'Audit any prose/message, or decode-and-verify a uuid across BOTH evidence sets. Prose → honesty-gate verdict + content-address. A uuid is a ONE-WAY address (never reversed); "decode" looks it up in (1) the agent-statement receipts (src/receipts/, verifies toUuid(message)===uuid + observer/role) then (2) the discovery ledger (reports the fact, chain position, and whether the chain-of-custody link is intact). In neither ⇒ opaque, honestly.',
+        inputSchema: { type: 'object', properties: { text: { type: 'string' } }, required: ['text'] } },
+    { name: 'discover', description: 'The discovery engine: computationally-generated + curated candidate facts over ℤ/9, each tested by exhaustion. Returns discovered (provable) vs refuted + a discovery root. Decidable facts only.',
+        inputSchema: { type: 'object', properties: {}, required: [] } },
+    { name: 'recompute', description: 'Recompute ALL theorems: re-run every candidate\'s formula (its test) by exhaustion, report how many hold vs refuted, verify every RECORDED ledger theorem still recomputes true, and fold the recompute root — the whole deposit recomputes from its theorems, not from stored answers. A theorem without a formula that recomputes true is refused (hallucination). Decidable.',
+        inputSchema: { type: 'object', properties: {}, required: [] } },
+    { name: 'rosetta', description: 'The completed cross-domain rosetta as a reusable endpoint: every domain family one hop from the shared core, content-addressed and folded to one rosetta root, all addresses distinct (no collision unless consolidated or redistributed). Returns the core address, the domain list and count, the collision check, and the rosetta root. Integrity of the cross-domain map, not truth.',
+        inputSchema: { type: 'object', properties: {}, required: [] } },
+    { name: 'audit', description: 'Self-audit of THIS MCP server: content-address every tool (name+description+schema), verify each declared tool has a handler and each handler is declared (coverage), fold to one self-audit root. Integrity of the tool surface, not truth.',
+        inputSchema: { type: 'object', properties: {}, required: [] } },
+    { name: 'forensics', description: 'Chain-of-custody for the discovery ledger: recompute the receipt chain link-by-link (receipt[i]=toUuid(receipt[i-1]→key[i]), seed axiom:TRINITY), pinpoint any break, check for duplicate keys/receipts, and fold a tamper-evident seal. Genesis discontinuities are a documented baseline; a NEW break is tampering. Integrity/provenance of evidence, not truth.',
+        inputSchema: { type: 'object', properties: {}, required: [] } },
+    { name: 'lean_verify', description: 'Compile every Lean file and audit it per theorem: #print axioms on each, hygiene (no sorry / native_decide outside comments), theorem counts. Fails if any file carries an axiom or does not compile. This is the gate every seal depends on.',
+        inputSchema: { type: 'object', properties: { file: { type: 'string', description: 'optional single file to verify' } }, required: [] } },
+    { name: 'lean_audit_library', description: 'Audit every theorem a Lean library declares, not only the ones a tool serves: build the library, then for each module check that it compiles, carries no sorry, and that each theorem is axiom-free or uses only the standard axioms (propext, Quot.sound). Reports any custom axiom or failure by name.',
+        inputSchema: { type: 'object', properties: { project: { type: 'string', description: 'the Lake project directory' }, src: { type: 'string', description: 'the library source root, relative to the project' }, prefix: { type: 'string', description: 'the module prefix, e.g. Qpu' } }, required: ['project', 'src', 'prefix'] } },
+    { name: 'web_search', description: 'Search a free public index — wikipedia, openalex or arxiv — and return its hits: title, address, and the snippet it returned. A NONE result means the index returned nothing for that query on this date, never that nothing exists. Use it for online answers through the MCP.',
+        inputSchema: { type: 'object', properties: { source: { type: 'string', enum: ['wikipedia', 'openalex', 'arxiv'] }, query: { type: 'string' }, limit: { type: 'number', description: '1 to 10, default 5' } }, required: ['source', 'query'] } },
+    { name: 'clay_conditions', description: 'Test the three conditions CMI sets before it considers a proposed solution (publication in a Qualifying Outlet under §6, two years since publication, general acceptance), one verdict each, MET or NOT MET with the reason. The §6(e) and §6(f) text is read from the live rules PDF through web_fetch first. With no evidence record every condition is NOT MET.',
+        inputSchema: { type: 'object', properties: {}, required: [] } },
+    { name: 'web_fetch', description: 'Read one public http(s) page and return only the passages that match a case-insensitive pattern, each with context, and the content address of the fetched body. Use it for online answers through the MCP. The passages are the page as fetched now; nothing is checked against another source.',
+        inputSchema: { type: 'object', properties: { url: { type: 'string' }, pattern: { type: 'string', description: 'regular expression, case-insensitive' }, window: { type: 'number', description: 'characters of context on each side, 20 to 600, default 160' }, raw: { type: 'boolean', description: 'match the HTML itself, so href links can be found' } }, required: ['url', 'pattern'] } },
+    { name: 'lean_split', description: 'Break one large Lean statement into smaller questions and answer each yes or no. The statement must be a conjunction A ∧ B ∧ ...; it is split at its top level, each conjunct becomes its own theorem, and lean_ask answers each one. The whole holds only when every part does. The answer names which part failed and why.',
+        inputSchema: { type: 'object', properties: { source: { type: 'string', description: 'Lean source whose last theorem has a conjunction as its statement' } }, required: ['source'] } },
+    { name: 'task_route', description: 'Paste anything. An integer is classified and checked: trial division, then a Miller–Rabin test. Composite answers come with a proof (a witness or an exact product check); probable primes are labelled probable, not proved. Factors are returned only when the product check passes; large factorisation is not attempted. Text is returned unrouted, with the tools that can take it.',
+        inputSchema: { type: 'object', properties: { input: { type: 'string', description: 'the pasted number or text' } }, required: ['input'] } },
+    { name: 'run_suite', description: 'Run one named test suite through the server and return its verdict: PASS, FAIL, or SKIPPED (skipped by the environment, never a pass). Suites are an allowlist: mcp-gate, hardcode-gate, mcp-check, net-tools-test, clay-conditions, clay-conditions-self-test, environment.',
+        inputSchema: { type: 'object', properties: { suite: { type: 'string', enum: Object.keys(SUITES) } }, required: ['suite'] } },
+    { name: 'stall_check', description: 'Flag submitted text that says the next step is unknown, by phrase match on each line. It reads only the text it is given. It cannot see reasoning that was not written down, and no match does not mean the author is not stalled.',
+        inputSchema: { type: 'object', properties: { text: { type: 'string', description: 'the text to check' } }, required: ['text'] } },
+    { name: 'session_report', description: 'Report the calls this server served in its log: how many, by tool and by status, first and last, and total time. It counts only this server\'s calls. A client reports its own token spend; the server cannot see it.',
+        inputSchema: { type: 'object', properties: {}, required: [] } },
+    { name: 'git_commit_paths', description: 'Commit only the named files of an allowlisted repository (millennium or qpu) through its own hooks. The hooks run and are never bypassed: a hook that refuses refuses the commit, and the named paths are unstaged again. Pathspec only: nothing else staged enters the commit. Never pushes, amends, or rewrites history.',
+        inputSchema: { type: 'object', properties: { repo: { type: 'string', enum: ['millennium', 'qpu'] }, message: { type: 'string', description: 'the commit message; its first line is the subject' }, paths: { type: 'array', items: { type: 'string' }, description: 'the files to commit, relative to the repository' } }, required: ['repo', 'message', 'paths'] } },
+    { name: 'answer', description: 'Answer one question with TRUE, FALSE, SOURCED, or UNKNOWN. The question is routed by kind: an integer goes to the arithmetic verifier (TRUE or FALSE from an exact witness), a Lean theorem to the kernel (TRUE only when it compiles with no sorry and no axiom), a DOI to the record resolver (SOURCED only for the canonical record), a Clay problem or other text to UNKNOWN with its reason. Every TRUE or FALSE carries its certificate.',
+        inputSchema: { type: 'object', properties: { question: { type: 'string', description: 'an integer, a Lean theorem, a DOI, or a question' } }, required: ['question'] } },
+    { name: 'lean_ask', description: 'Answer one Lean question from its source: does it compile, does it use sorry, and which axioms each theorem in it depends on. Compiles in a temporary directory, never in the tree, with the toolchain pinned in lean-toolchain. Answers ABSENT when the Lean toolchain is not on PATH.',
+        inputSchema: { type: 'object', properties: { source: { type: 'string', description: 'the Lean source to answer about' } }, required: ['source'] } },
+    { name: 'lean_seal', description: 'Seal every compiled, axiom-free Lean theorem into the ledger with a chained receipt. ONLY by-decide theorems are sealed — rfl on a declared constant proves the declaration, not a fact. Gated on lean_verify; seals nothing if the layer does not verify. Pass dry=true to report without writing.',
+        inputSchema: { type: 'object', properties: { dry: { type: 'boolean' } }, required: [] } },
+    { name: 'lean_generate', description: 'Generate quantified Lean for ledger families — one theorem subsuming a whole family of per-parameter rows. Five gates: compiles, axiom-free, agrees with the ledger test at every parameter, carries a boundary case, and flags a zero divisor in range. Pass emit=true to write.',
+        inputSchema: { type: 'object', properties: { emit: { type: 'boolean' } }, required: [] } },
+    { name: 'metrics_face', description: 'This repository\'s build face: one row per measurement, each carrying the claim, the value, THE COMMAND THAT RECOMPUTES IT, and a receipt over the row\'s own fields. Gate results are run, not remembered, and a failing gate is reported as FAIL rather than suppressed. A sibling session calls this instead of being sent a prose summary.',
+        inputSchema: { type: 'object', properties: {}, required: [] } },
+    { name: 'verify_face', description: 'Verify a face emitted by ANY repository — pass its JSON or a path. Recomputes every receipt and the merkle root from the rows themselves, needing nothing from the emitting tree. INTEGRITY ONLY: this establishes that the rows are unaltered since sealing, NOT that any figure is correct. Reading a passing verify as evidence a number is right is the error this exists to prevent.',
+        inputSchema: { type: 'object', properties: { json: { type: 'string' }, path: { type: 'string' } }, required: [] } },
+    { name: 'peer_faces', description: 'List and verify every face present in the shared fusion directory, so this session can check what siblings published rather than trust their reports. Reports each repo, its root, whether it is intact, and any gate it published as FAIL.',
+        inputSchema: { type: 'object', properties: { dir: { type: 'string' } }, required: [] } },
+    { name: 'entanglements', description: 'The cross-domain identity map: 80 expressions from 24 subjects — music, biology, sport, juggling, botany, law, textiles, cryptography and the rest — evaluated on ONE shared grid n = 1..20 and clustered by agreeing at every point. Returns the identities (a knockout bracket and an n-bit register are the same integer; phyllotaxis, breeding pairs and Zeckendorf are one recursion), the domains each joins, the expressions that join NOTHING, and whether the entanglement graph is connected. Decided in src/proof/coils.lean, so the identities hold whether or not this tool answers. An identity is not an explanation: neither subject explains the other, they are one object approached from two sides.',
+        inputSchema: { type: 'object', properties: { domain: { type: 'string' }, spanningOnly: { type: 'boolean' } } } },
+    { name: 'api_joins', description: 'Ask several independent public services for the SAME entity and report which values two or more of them return — the join DISCOVERED from the data rather than declared. PubChem, ChEMBL and ChEBI all return the InChIKey BSYNRYMUTXBXSQ-UHFFFAOYSA-N for aspirin, at three different paths, from two institutions on two continents. Negative results are reported and are the interesting ones: two plant-naming authorities share no joinable value, which is the problem Kew\'s credential-gated MPNS exists to solve. A JOIN IS NOT A TRUTH — it establishes that two databases mean the same entity, never that either is correct; two services can agree and both be wrong. Reaches the network; writes nothing.',
+        inputSchema: { type: 'object', properties: { probe: { type: 'string', enum: ['drug', 'protein', 'plant', 'paper'] } } } },
+    { name: 'leaks', description: 'Measure where runtime temperature (random draws) and time (clock reads, timers) enter the deposit: every site in src/ and scripts/, classified by kind and role, with the cracks that are to be replaced by theorems. Read from the source on each call; nothing is typed.',
+        inputSchema: { type: 'object', properties: { json: { type: 'boolean', description: 'true for the inventory as JSON, false or absent for markdown' } }, required: [] } },
+    { name: 'cern', description: 'Enumerate the public CERN Open Data corpus through the sitemap that its robots.txt advertises (never the disallowed /api/), address every record, and run the involution check with its control: a non-involution must go red. Writes .cern/ and checks docs/CERN-ENUMERATION.md against the figures measured. Needs the network; takes minutes.',
+        inputSchema: { type: 'object', properties: {}, required: [] } },
+    { name: 'apis_guru_cross', description: 'Cross-check the APIs.guru catalogue, offline: for each catalogued API, its spec verdict (is the OpenAPI document served and a spec?) read against its live verdict (does its own server answer?). Reports agreements and disagreements. Reads the committed runs; makes no request.', inputSchema: { type: 'object', properties: {}, required: [] } },
+    { name: 'api_adapters', description: 'Ask every API adapter in the registry live, one verdict each: PROVEN when the reply contains the fact the adapter states, WRONG when it does not, REFUSED when robots.txt disallows the path, GATED when a key or licence is needed, NOT MEASURED when the host did not answer. Makes network requests, paced one per second per host.', inputSchema: { type: 'object', properties: {}, required: [] } },
+    { name: 'apis_guru_gaps', description: 'The APIs.guru catalogue set against the hosts this tree names: gaps are catalogued APIs whose server the code names but no adapter covers; unused are the rest. Offline; reads the committed live run.', inputSchema: { type: 'object', properties: {}, required: [] } },
+    { name: 'understand', description: 'Say which route a request belongs to, and say when none does. Returns UNDERSTOOD with the tool and its arguments, or UNDERSTOOD false with the options the server has. Never answers a request with a route it does not match.', inputSchema: { type: 'object', properties: { request: { type: 'string', description: 'the request as written' } }, required: ['request'] } },
+    { name: 'contradictions', description: 'The prose of this deposit set against its own Lean proofs: every place a document says what src/proof does not establish. Reads the tree; makes no request. Each finding names the file and line.', inputSchema: { type: 'object', properties: {}, required: [] } },
+    { name: 'answer_gate', description: "Refuse stored or emitted answers that break the certificate rules. The rules are kernel-checked Lean; this reads a JSON array of answers and asks the kernel whether each holds.", inputSchema: { "type": "object", "properties": { "answers": { "type": "array" } }, "required": [] } },
+    { name: 'answer_verify_arith', description: "The C2 verifier: proposes a factor or a primality proof and asks the Lean kernel whether it holds. TRUE or FALSE only when the kernel accepts it; otherwise UNKNOWN.", inputSchema: { "type": "object", "properties": { "input": { "type": "string", "description": "the integer to decide" } }, "required": [] } },
+    { name: 'answer_verify_arxiv', description: "The C3 verifier for arXiv: SOURCED only when the abstract page of the preprint resolves to the stated title. Fetched robots-respecting and keyless.", inputSchema: { "type": "object", "properties": { "id": { "type": "string" }, "title": { "type": "string" } }, "required": [] } },
+    { name: 'answer_verify_doi', description: "The C3 verifier for a DOI: resolves it through the MCP and returns SOURCED or UNKNOWN.", inputSchema: { "type": "object", "properties": { "doi": { "type": "string" } }, "required": [] } },
+    { name: 'answer_verify_lean', description: "The C1 verifier: runs the Lean kernel on a source and returns TRUE or UNKNOWN for one theorem.", inputSchema: { "type": "object", "properties": { "theorem": { "type": "string" }, "source": { "type": "string", "description": "the Lean source" } }, "required": [] } },
+    { name: 'anti_fake', description: "Flag Lean code that claims a proof it does not have. By default checks the Lean files staged for a commit.", inputSchema: { "type": "object", "properties": { "staged": { "type": "boolean" } }, "required": [] } },
+    { name: 'apis_guru', description: "The APIs.guru catalogue. mode catalogue snapshots the directory (fast). mode probe starts the full probe of every catalogued specification in the background; its result is written to the evidence folder.", inputSchema: { "type": "object", "properties": { "mode": { "type": "string", "enum": ["catalogue", "probe"] } }, "required": [] } },
+    { name: 'apis_guru_live', description: "Starts, in the background, the live reachability pass over every catalogued API server that its specification allows without a key. The result is written to the evidence folder.", inputSchema: { "type": "object", "properties": {}, "required": [] } },
+    { name: 'apis_theorems', description: "Writes src/proof/apis.lean from the committed APIs.guru run, so the kernel decides statements about the verdict counts. The counts are read from the run, not typed.", inputSchema: { "type": "object", "properties": {}, "required": [] } },
+    { name: 'pre_commit_court', description: "The pre-commit court: manual work is sent to the court before it is committed. Runs the court over the staged work.", inputSchema: { "type": "object", "properties": {}, "required": [] } },
+    { name: 'prefix_check', description: "A name that repeats the repository it lives in carries no information. Flags served names that carry a repository prefix.", inputSchema: { "type": "object", "properties": { "repo": { "type": "string" }, "prefixes": { "type": "array" } }, "required": [] } },
+    { name: 'secure_split', description: 'Split a secret below 2^256 into shares locally, so that no single share reveals it (additive sharing over Z/2^256, randomness from the operating system). action split takes secret and parts; action join takes shares and recovers the secret. Computed on this machine; nothing is sent anywhere.', inputSchema: { type: 'object', properties: { action: { type: 'string', enum: ['split', 'join'] }, secret: { type: 'string' }, parts: { type: 'number' }, shares: { type: 'array' } }, required: ['action'] } },
+    { name: 'factor_verify', description: 'Check a claimed factorisation of an integer without trusting the claim: the factors must multiply to the integer exactly, each at least 2, and each is tested for primality. VERIFIED when every factor is proved prime; PROBABLE when a factor above 3.3e24 only passes a probabilistic test; REFUSED on a wrong product, a factor below 2, or a composite factor.', inputSchema: { type: 'object', properties: { n: { type: 'string', description: 'the integer, decimal digits' }, factors: { type: 'array', items: { type: 'string' }, description: 'the claimed factors, decimal digits' } }, required: ['n', 'factors'] } },
+    { name: 'digit_mirror', description: 'The digit mirror: each digit d becomes 10 − d, so 369 mirrors to 741. Defined only when no digit is 0. Checks that mirroring twice gives back the number (the involution).', inputSchema: { type: 'object', properties: { n: { type: 'string' } }, required: ['n'] } },
+    { name: 'semiprime_search', description: 'Semiprimes n = p × q (p ≠ q, both prime) for n in [lo, hi], exact by trial division. noZero excludes numbers with a zero digit, so each has a digit mirror. The limit caps the number of results.', inputSchema: { type: 'object', properties: { lo: { type: 'number' }, hi: { type: 'number' }, noZero: { type: 'boolean' }, limit: { type: 'number' } }, required: ['lo', 'hi'] } },
+    { name: 'shor_wave', description: 'Send a wave of integers to the QPU Shor tool and check every factorisation it returns with the verifier, not with a product alone. Reports per input: what the QPU returned, and VERIFIED, PROBABLE, REFUSED or NOT_FACTORED.', inputSchema: { type: 'object', properties: { inputs: { type: 'array', items: { type: 'string' } } }, required: ['inputs'] } },
+    { name: 'qpu_wave', description: 'A whole wave in one call: search the range [lo, hi] for semiprimes with no zero digit, mirror each one, send every input and its mirror to the QPU Shor tool in parallel, and verify each factorisation with the verifier. Returns the counts and every row.', inputSchema: { type: 'object', properties: { lo: { type: 'number' }, hi: { type: 'number' }, count: { type: 'number', description: 'semiprimes to take from the range' } }, required: ['lo', 'hi'] } },
+    { name: 'trinity', description: 'The trinity in one call: the four gates of the scheduled trinity workflow (gaps, seal, wholeness, lean-claims), run in order, each with its exit status and last lines, so a failure names the gate and the reason.', inputSchema: { type: 'object', properties: {}, required: [] } },
+    { name: 'family', description: 'One QPU family by name (one lowercase word, such as analytics): runs the family tests through qpu_families and returns only that family\'s lines.', inputSchema: { type: 'object', properties: { name: { type: 'string' } }, required: ['name'] } },
+    { name: 'api_gates', description: 'Every API in the registry as a gate: filesystem gates are checked now (a missing file or a file that no longer states the expected fact refuses); online and gated ones are named, never requested. Offline; reaches no network.', inputSchema: { type: 'object', properties: {} } },
+    { name: 'package_gates', description: 'Every lockfile package as a gate at its deepest path: a pinned version and an integrity hash each, refused and named when either is missing. With dockerfiles, each apk add package is a gate too. Offline; reads files only.', inputSchema: { type: 'object', properties: { dockerfiles: { type: 'array', items: { type: 'string' } } } } },
+    { name: 'memory_check', description: 'Check the memory directory: every index line links a file, every memory has its frontmatter (name, description, metadata.type), and every [[link]] resolves to a memory. Reads files only; never writes.', inputSchema: { type: 'object', properties: {} } },
+    { name: 'memory_derive', description: 'Print the measured block the memory directory is derived from: counts and verdicts read from the ledger, the Lean files and package.json at this moment. Prints only; it never writes the memory files.', inputSchema: { type: 'object', properties: {} } },
+    { name: 'api_lattice', description: 'The API lattice: every tool that reaches the network, keyed by its handle (first eight hex digits of its name\'s content address) and set against its declared needs. The catalogue as a grid.', inputSchema: { type: 'object', properties: {}, required: [] } },
+    { name: 'policy', description: 'Classify a request to build a capability against the repository rules: ALLOWED (read-only public sources), GATED (changes state, enabled by the owner per credential), or NEEDS_OWNER (money or prices, or no rule names it). A rule-based classification, not a legal ruling; it grants nothing.', inputSchema: { type: 'object', properties: { request: { type: 'string' } }, required: ['request'] } },
+    { name: 'factor', description: 'The production factor: the factors of an integer of any width in any binary variant — decimal, 0b binary or 0x hex. FACTORED when every factor is proved (trial division, or a deterministic primality test below 3.3e24). PARTIAL when a cofactor has no factor below 10^6 and is not proved prime: the factors found and the blocking step are returned, nothing is guessed. REFUSED for a non-integer or a value below 2. Every answer carries its witness: the served register qpu.lean pins (faces = coins × rays = 2 × 7) rotated over the fact — the integer and its digit mirror, each rendered in radix 2^k for k = 1..7 and parsed back, each state checked; agree is true only when all fourteen hold and every factorisation multiplies back. Served from every install.', inputSchema: { type: 'object', properties: { n: { type: 'string', description: 'the integer in decimal digits, any length' } }, required: ['n'] } },
+    { name: 'hexbit_route', description: 'Route a bit string to its hexbit folder: the content address of the input gives its handle (the first 8 hex digits, per the handle family), and the folder is that handle. Returns the files of the repository that share the handle, each rechecked from its own bytes. Nothing is created. With index true, returns the whole index of the repository\'s Lean sources by folder.', inputSchema: { type: 'object', properties: { input: { type: 'string', description: 'the bit string to route' }, index: { type: 'boolean', description: 'true for the whole index instead of one route' } }, required: [] } },
+    { name: 'qpu_crosscheck', description: 'Cross-check the GHZ cancellation claim against the qpu connector: qpu\'s X-basis amplitudes, if it returns them, compared with the values computed from the Lean definitions. Corroboration only, never proof; reports NOT MEASURED until qpu returns the amplitudes. Token free: the comparison is a script.', inputSchema: { type: 'object', properties: {}, required: [] } },
+    { name: 'prose_check', description: "Check the staged prose of the commit against the Lean ledger, through the same precommit script the hook runs. Judges citations; reports the verdict and the count of staged prose files.", inputSchema: { type: 'object', properties: {}, required: [] } },
+    { name: 'theorem_only', description: "Run the theorem-only check over this repository: every runtime test is a violation, and each one names its candidate Lean proofs. Exits non-zero while any runtime test remains.", inputSchema: { type: 'object', properties: {}, required: [] } },
+    { name: 'constants_check', description: "Check that README.md and index.md agree with the numbers scripts/pages.ts derives. Reports each disagreement; regenerate with the pages tool.", inputSchema: { type: 'object', properties: {}, required: [] } },
+    { name: 'pre_commit_e2e', description: "Run the whole pre-commit hook end to end without committing: prose, forensics, Lean claims, the parallel gates, the court. Returns the hook output and its exit code. The commit tool runs the same hook and is the way to commit.", inputSchema: { type: 'object', properties: {}, required: [] } },
+    { name: 'qpu_court_local', description: "Run qpu's own gate-court test from its build, offline. Reports pass and fail counts. The public court is a separate check, through the qpu connector.", inputSchema: { type: 'object', properties: {}, required: [] } },
+    { name: 'qpu_families', description: "Run every qpu family test file from its build, in one invocation, and return the pass and fail counts. Each family's own test decides its verdict.", inputSchema: { type: 'object', properties: {}, required: [] } },
+    { name: 'clay_online', description: 'The online evidence for each Clay problem, gathered the same way every time: OpenAlex and Crossref literature hits, and the Clay Institute page, each source read through its robots.txt first (a disallowed path is skipped and named). Reports what the sources return. A literature hit is not a proof, and the Clay page status is not determined from its text; the verdicts stay with the answer tool.', inputSchema: { type: 'object', properties: {}, required: [] } },
+    { name: 'links_check', description: 'Check every external link in README.md and index.md, once, the same way every time: each host\'s robots.txt is read first, a disallowed path is skipped and named, one request is in flight per host, a HEAD is retried as GET where refused, and a 429 is backed off. Each link is LIVE, DEAD (with its status), or UNREACHABLE (with the reason).', inputSchema: { type: 'object', properties: {}, required: [] } },
+    { name: 'explain', description: 'What a named theorem or Lean file is, from its Lean documentation by default: the doc comment or the file header, as the Lean source carries it. Writes no prose of its own; a name with no doc in the Lean source is reported as having none.', inputSchema: { type: 'object', properties: { name: { type: 'string', description: 'a theorem name, or a Lean file name' } }, required: ['name'] } },
+    { name: 'novelty_batch', description: 'Run the deposit\'s prior-art search over the theorems that are unknown or stale: the incremental runner of scripts/novelty.ts. Takes at most limit theorems and at most minutes of work per call; a source that refuses is cooled down and reported as NOT_MEASURED, never as absence. Resumes where the previous call stopped.', inputSchema: { type: 'object', properties: { limit: { type: 'number', description: 'at most this many theorems in this call' }, minutes: { type: 'number', description: 'the time budget of this call, in minutes' } }, required: [] } },
+    { name: 'connect_status', description: 'The state of a background connector call started with connect async true: RUNNING, DONE with the connector\'s reply, or FAILED with its reason.', inputSchema: { type: 'object', properties: { job: { type: 'string', description: 'the job id that connect returned' } }, required: ['job'] } },
+    { name: 'evidence', description: 'The deposit\'s evidence, as data: each evidence folder under evidence/ with its files and each file\'s content address. Read from the repository on each call; nothing is typed. Takes an optional folder to list only that folder.', inputSchema: { type: 'object', properties: { folder: { type: 'string', description: 'an evidence folder to list, such as constants; omit for all' } }, required: [] } },
+    { name: 'court_trial', description: 'A claim tried by both sides, decided by the Lean kernel: the defence compiles the claim as a theorem, the prosecution compiles its negation. SEALED when only the defence proves; REFUSED when only the prosecution proves; UNKNOWN when neither does; NOT TRIABLE when the claim is not a Lean proposition. Takes the claim as a Lean proposition in the claim field.', inputSchema: { type: 'object', properties: { claim: { type: 'string', description: 'a Lean proposition, such as 2 + 2 = 4' } }, required: ['claim'] } },
+    { name: 'leads', description: 'The deposit\'s own open questions, derived from the tree rather than listed: uncontrolled refusing gates, unminted depositions, theorems that read back a hand-set value, MCP tools an install cannot reach. Also CROSSES them by cause — publication, authority, instrument, derivation, environment — because two leads sharing a cause are one problem with two faces and only one of them may be closable. Reports and does not gate: an open question is work not done, which is not work that is wrong.',
+        inputSchema: { type: 'object', properties: { area: { type: 'string' } } } },
+    { name: 'gates_fire', description: 'Run every refusing gate\'s negative control: each gate must reject its own mutation. It writes into tracked files to do that, so it refuses while the tree has uncommitted changes, while a commit or gate is running, or while a restore marker from a killed run is still present. Controls that fail on a clean tree or match nothing are reported as untrusted.', inputSchema: { type: 'object', properties: {} } },
+    { name: 'readers', description: 'Ask the scientific and medical sources this deposit investigates through — Europe PMC, PubMed, PubChem, ChEMBL, UniProt, Ensembl, KEGG, Reactome, GBIF, RxNorm, openFDA, MeSH, ClinicalTrials.gov and more — whether each still answers with a fact known BEFORE it was asked. Three verdicts kept apart: PROVEN, WRONG (the reader is broken OR the expectation was), and NOT MEASURED (it did not answer — silence is not absence). 8 further sources are named as credential- or licence-gated rather than omitted, because an unrecorded gap becomes an implicit claim of completeness. CITATION INSTRUMENTS, NOT MEDICAL ADVICE: a documented traditional use is an anthropological fact, never evidence a use works, and never a dose.',
+        inputSchema: { type: 'object', properties: { domain: { type: 'string' }, list: { type: 'boolean' } } } },
+    { name: 'live', description: 'What this deposit has actually SHIPPED, asked of the registries rather than the tree: the npm version against package.json, the newest provenance tag, and the site against the ledger this tree holds. A green publish workflow says npm was called, not that the version on the registry is the one here — that gap has been real for three releases. Reports, never gates: network state must not decide whether a local build is allowed.',
+        inputSchema: { type: 'object', properties: {} } },
+    { name: 'connect', description: 'Call a declared live MCP server and return ITS answer, attributed. With no arguments, lists the connectors and what each one\'s answers do and do not establish. Currently one: qpu.uuidna.com, sixteen tools over the same JSON-RPC this server speaks — its state-vector circuit, its Lean rows, and the Shor run factoring 91 = 7 x 13 by period-finding. FORWARDS, NEVER MIRRORS: copying a remote answer into this tree would make a second source of one truth that drifts from the first and then disagrees silently. A connected answer is a third party\'s report of ITSELF on a date, carrying no more authority than that — and two services agreeing is a join key, never a truth.',
+        inputSchema: { type: 'object', properties: { connector: { type: 'string' }, tool: { type: 'string' }, arguments: { type: 'object' } } } },
+    { name: 'ledger_status', description: 'Composition of the ledger: total, live, lean-backed, revoked, portable-to-Lean, chain breaks, duplicate keys/receipts, octave remainder. Measurement only — writes nothing.',
+        inputSchema: { type: 'object', properties: {}, required: [] } },
+    { name: 'ledger_trial', description: 'Put every ledger entry in the dock and record a verdict with its ground — no bare verdicts. Writes src/proof/trial-all.json. Adjudicates, never removes: what follows from a refusal is the captain\'s to order.',
+        inputSchema: { type: 'object', properties: {}, required: [] } },
+    { name: 'pages', description: 'Regenerate README.md and the homepage from one generator. Every claim derives its sentence from the artefact it reads and must declare the values it read; a claim that measures nothing is refused and nothing is written.',
+        inputSchema: { type: 'object', properties: {}, required: [] } },
+];
+export const LISTED = [
+    {
+        name: 'list_tools',
+        description: "List this server's tools, or give one tool's description and inputSchema.",
+        inputSchema: { type: 'object', properties: { name: { type: 'string' } } },
+    },
+    {
+        name: 'call_tool',
+        description: "Call one of this server's tools by name with its arguments. `list_tools` lists them.",
+        inputSchema: { type: 'object', properties: { name: { type: 'string', enum: TOOLS.map((t) => t.name) }, arguments: { type: 'object' } }, required: ['name'] },
+    },
+];
+export const NEEDS = {
+    novelty: ['net'],
+    entanglements: ['tree'],
+    leads: ['tree'],
+    gates_fire: ['net', 'tree'],
+    readers: ['net', 'tree'],
+    live: ['net', 'tree'],
+    connect: ['net', 'tree', 'git'],
+    api_joins: ['net', 'tree'],
+    coils: ['tree'],
+    discoveries: ['tree'],
+    formulas: ['tree'],
+    handle: ['core'],
+    lean_verify: ['lean', 'tree'],
+    lean_ask: ['lean', 'tree'],
+    answer: ['net', 'lean', 'tree'],
+    git_commit_paths: ['git', 'tree'],
+    session_report: ['tree'],
+    stall_check: ['tree'],
+    run_suite: ['net', 'tree'],
+    task_route: ['tree'],
+    lean_split: ['lean', 'tree'],
+    web_fetch: ['net', 'tree'],
+    clay_conditions: ['net', 'tree'],
+    leaks: ['tree'],
+    hexbit_route: ['tree'],
+    apis_guru_cross: ['tree'],
+    apis_guru_gaps: ['tree'],
+    factor: ['core'],
+    trinity: ['tree'],
+    family: ['tree'],
+    memory_check: ['tree'],
+    memory_derive: ['tree'],
+    api_gates: ['tree'],
+    package_gates: ['tree'],
+    api_lattice: ['core'],
+    policy: ['core'],
+    digit_mirror: ['core'],
+    semiprime_search: ['tree'],
+    shor_wave: ['net', 'tree'],
+    qpu_wave: ['net'],
+    factor_verify: ['core'],
+    secure_split: ['core'],
+    contradictions: ['tree'],
+    answer_gate: ['tree'],
+    answer_verify_arith: ['tree'],
+    answer_verify_arxiv: ['tree'],
+    answer_verify_doi: ['net', 'tree'],
+    answer_verify_lean: ['lean', 'tree'],
+    anti_fake: ['tree'],
+    apis_guru: ['net', 'tree'],
+    apis_guru_live: ['net', 'tree'],
+    apis_theorems: ['tree'],
+    pre_commit_court: ['net', 'tree'],
+    prefix_check: ['tree'],
+    understand: ['tree'],
+    api_adapters: ['net', 'tree'],
+    prose_check: ['tree'],
+    theorem_only: ['tree'],
+    constants_check: ['tree'],
+    pre_commit_e2e: ['tree', 'git', 'lean', 'ledger', 'net'],
+    qpu_court_local: ['tree'],
+    qpu_families: ['tree'],
+    qpu_crosscheck: ['net', 'tree'],
+    clay_online: ['net', 'tree'],
+    links_check: ['net', 'tree'],
+    explain: ['tree'],
+    court_trial: ['lean', 'tree'],
+    evidence: ['tree'],
+    novelty_batch: ['net', 'tree'],
+    connect_status: ['tree'],
+    cern: ['net', 'tree'],
+    web_search: ['net', 'tree'],
+    lean_audit_library: ['lean', 'tree'],
+    lean_seal: ['lean', 'tree'],
+    lean_generate: ['lean', 'tree'],
+    ledger_trial: ['tree'],
+    pages: ['shared', 'tree'],
+    metrics_face: ['tree'],
+    verify_face: ['core'],
+    peer_faces: ['shared'],
+    ledger_status: ['ledger'],
+    content_address: ['core'],
+    honesty_gate: ['core'],
+    merkle_fold: ['core'],
+    probe: ['net'],
+    verify: ['ledger'],
+    lineage: ['git'],
+    discover: ['core'],
+    recompute: ['ledger'],
+    rosetta: ['core'],
+    forensics: ['ledger'],
+    audit: ['lean', 'tree'],
+};
+export const SELF_SUFFICIENT = Object.entries(NEEDS)
+    .filter(([, n]) => n.length === 1 && n[0] === 'core').map(([k]) => k).sort();

package/dist/src/mcp/serve.d.ts

@@ -0,0 +1,100 @@
+export type Row = {
+    key: string;
+    name?: string;
+    receipt: string;
+    revoked?: boolean;
+    reason?: string;
+    supersededBy?: string;
+};
+export declare const ledgerStatus: (rows: Row[]) => {
+    total: number;
+    live: number;
+    revoked: number;
+    carried: number;
+    duplicateKeys: string[];
+    duplicateReceipts: string[];
+    octave: {
+        size: number;
+        remainder: number;
+        exact: boolean;
+    };
+    note: string;
+};
+export declare const forensicsOf: (rows: Row[], seed?: string) => {
+    entries: number;
+    breaks: number;
+    genesisDiscontinuities: number;
+    newBreaks: {
+        index: number;
+        key: string;
+        expected: string;
+        found: string;
+    }[];
+    intactFromIndex: number;
+    seal: string;
+    note: string;
+};
+export declare const verifyIn: (rows: Row[], uuid: string) => {
+    index?: undefined;
+    name?: undefined;
+    uuid: string;
+    found: boolean;
+    note: string;
+    key?: undefined;
+    live?: undefined;
+    supersededBy?: undefined;
+    reason?: undefined;
+    chainIntactHere?: undefined;
+} | {
+    uuid: string;
+    found: boolean;
+    index: number;
+    key: string;
+    name: string;
+    live: boolean;
+    supersededBy: string;
+    reason: string;
+    chainIntactHere: boolean;
+    note: string;
+};
+export declare const CANNOT_SHIP: Record<string, string>;
+export declare const BAKEABLE: string[];
+export type Bake = {
+    stamp: Record<string, unknown>;
+    answers: Record<string, string>;
+    notBaked: Record<string, string>;
+};
+export declare const withBake: (b: Bake) => void;
+export declare const hasBake: () => boolean;
+export declare const FROM_BAKE: Record<string, string>;
+export declare const whyNot: (name: string) => string;
+export declare const SERVED_CORE: string[];
+export declare const SERVED_WITH_LEDGER: string[];
+export declare const served: () => string[];
+export type Formula = {
+    name: string;
+    statement: string;
+    key: string;
+    source: string;
+    wing: string;
+    proof: string;
+};
+export declare const formulasFrom: (rows: Formula[], a?: {
+    wing?: string;
+    file?: string;
+    contains?: string;
+    limit?: number;
+}) => {
+    total: number;
+    matched: number;
+    showing: number;
+    wings: string[];
+    formulas: Formula[];
+    note: string;
+};
+export declare const withLedger: (rows: Row[]) => void;
+export declare const hasLedger: () => boolean;
+export declare const withFormulas: (rows: Formula[]) => void;
+export declare const hasFormulas: () => boolean;
+export declare const listTools: (name?: unknown) => string;
+export declare const run: (name: string, a: any) => string;