@ceccec/millennium-solutions 9.8.2 → 9.8.3

package/dist/src/mcp/index.js

@@ -1,3 +1,4 @@
+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.',
@@ -5,9 +6,9 @@ export const TOOLS = [
     { 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: { limit: { type: 'number' } }, required: [] } },
+        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: { wing: { type: 'string' }, file: { type: 'string' }, contains: { type: 'string' }, limit: { type: 'number' } }, required: [] } },
+        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.',
@@ -34,6 +35,30 @@ export const TOOLS = [
         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.',
@@ -48,8 +73,59 @@ export const TOOLS = [
         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.',
@@ -79,15 +155,76 @@ export const NEEDS = {
     novelty: ['net'],
     entanglements: ['tree'],
     leads: ['tree'],
+    gates_fire: ['net', 'tree'],
     readers: ['net', 'tree'],
     live: ['net', 'tree'],
-    connect: ['net'],
+    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'],
@@ -106,7 +243,7 @@ export const NEEDS = {
     recompute: ['ledger'],
     rosetta: ['core'],
     forensics: ['ledger'],
-    audit: ['core'],
+    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

@@ -35,12 +35,12 @@ export declare const forensicsOf: (rows: Row[], seed?: string) => {
     note: string;
 };
 export declare const verifyIn: (rows: Row[], uuid: string) => {
+    index?: undefined;
+    name?: undefined;
     uuid: string;
     found: boolean;
     note: string;
-    index?: undefined;
     key?: undefined;
-    name?: undefined;
     live?: undefined;
     supersededBy?: undefined;
     reason?: undefined;
@@ -58,6 +58,16 @@ export declare const verifyIn: (rows: Row[], uuid: string) => {
     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[];

package/dist/src/mcp/serve.js

@@ -1,4 +1,8 @@
 import { toUuid, merkleFold, merge } from '../0/index.js';
+import { factorWitnessed } from '../factor/index.js';
+import { verifyFactors } from '../factor/verify.js';
+import { mirror as digitMirror } from '../mirror/index.js';
+import { decide as policyDecide } from '../policy/index.js';
 import { handle, resolve, HANDLE_HEX } from '../handle/index.js';
 import { checkFace } from '../face/index.js';
 import { CORE as ROSETTA_CORE, DOMAINS as ROSETTA_DOMAINS } from '../the/rosetta/index.js';
@@ -50,6 +54,7 @@ export const verifyIn = (rows, uuid) => {
         note: 'The address was found and its chain link recomputed. Integrity and position, never truth of the statement.' };
 };
 export const CANNOT_SHIP = {
+    secure_split: 'its shares are drawn from node:crypto randomBytes, and this entry opens no node module — clone the repository for it',
     discover: 'its candidate set is scripts/discover.ts — repository logic, not a module',
     recompute: 'it re-runs every candidate\'s formula, and the formulas are in scripts/discover.ts — the same repository logic. Reading the ledger is not enough: this tool recomputes what the ledger RECORDS, which needs the code that computed it',
 };
@@ -60,12 +65,37 @@ const LEDGER_TOOLS = Object.entries(NEEDS)
     .filter(([k, n]) => n.length === 1 && n[0] === 'ledger' && !CANNOT_SHIP[k])
     .map(([k]) => k);
 const DATA_TOOLS = ['formulas'];
+const OUTSIDE_ANY_PACKAGE = new Set(['lean', 'net', 'git', 'shared']);
+export const BAKEABLE = TOOLS.map((t) => t.name).filter((n) => !CORE_TOOLS.includes(n) && !LEDGER_TOOLS.includes(n) && !DATA_TOOLS.includes(n)
+    && (NEEDS[n] ?? ['tree']).every((x) => !OUTSIDE_ANY_PACKAGE.has(x))
+    && !WRITES.has(n)
+    && (TOOLS.find((t) => t.name === n)?.inputSchema?.required ?? []).length === 0).sort();
+let BAKE = null;
+export const withBake = (b) => { BAKE = b; };
+export const hasBake = () => BAKE !== null;
+const bakedNames = () => (BAKE ? Object.keys(BAKE.answers).filter((n) => BAKEABLE.includes(n)) : []);
+export const FROM_BAKE = { family: 'qpu_families' };
+const fromBakeNames = () => Object.entries(FROM_BAKE).filter(([, src]) => BAKE?.answers[src] !== undefined).map(([n]) => n);
+export const whyNot = (name) => {
+    if (CANNOT_SHIP[name])
+        return CANNOT_SHIP[name];
+    if (BAKE?.notBaked[name])
+        return BAKE.notBaked[name];
+    if (WRITES.has(name))
+        return 'it writes to the tree, and a package has no tree to write to';
+    const req = TOOLS.find((t) => t.name === name)?.inputSchema?.required ?? [];
+    if (req.length && BAKEABLE.every((n) => n !== name) && (NEEDS[name] ?? []).every((x) => !OUTSIDE_ANY_PACKAGE.has(x)))
+        return `it takes \`${req.join(', ')}\`, and no bare answer stands in for an argument the caller chooses — clone the repository for it`;
+    return `it needs ${(NEEDS[name] ?? ['the repository']).join('+')}: clone the repository and run \`npm run mcp\``;
+};
 export const SERVED_CORE = [...CORE_TOOLS].sort();
 export const SERVED_WITH_LEDGER = [...CORE_TOOLS, ...LEDGER_TOOLS, ...DATA_TOOLS].sort();
 export const served = () => [
     ...SERVED_CORE,
     ...(hasLedger() ? LEDGER_TOOLS : []),
     ...(hasFormulas() ? DATA_TOOLS : []),
+    ...bakedNames(),
+    ...fromBakeNames(),
 ].sort();
 export const formulasFrom = (rows, a = {}) => {
     let out = rows;
@@ -102,6 +132,16 @@ const rowsOrRefuse = (tool) => {
     return ROWS;
 };
 const H = {
+    factor: (a) => JSON.stringify(factorWitnessed(String(a?.n ?? ''))),
+    factor_verify: (a) => JSON.stringify(verifyFactors(String(a?.n ?? ''), Array.isArray(a?.factors) ? a.factors.map(String) : [])),
+    digit_mirror: (a) => JSON.stringify(digitMirror(String(a?.n ?? ''))),
+    policy: (a) => JSON.stringify(policyDecide(String(a?.request ?? ''))),
+    api_lattice: () => {
+        const rows = TOOLS.filter((t) => (NEEDS[t.name] ?? []).includes('net')).map((t) => ({
+            handle: toUuid(t.name).replace(/-/g, '').slice(0, 8), tool: t.name, needs: NEEDS[t.name] ?? [],
+        })).sort((a, b) => a.handle.localeCompare(b.handle));
+        return JSON.stringify({ tools: rows.length, lattice: rows });
+    },
     formulas: (a) => {
         if (!FORMS)
             throw new Error('formulas: the formula catalogue is not loaded. The published package carries it '
@@ -145,6 +185,17 @@ const H = {
         return JSON.stringify({ handle: handle(text), hex: HANDLE_HEX, address: toUuid(text),
             note: 'The first four hex of the address. Nothing but the message ever travels — the handle plus the message determine the whole address.' });
     },
+    family: (a) => {
+        const src = BAKE?.answers[FROM_BAKE.family];
+        if (src === undefined)
+            throw new Error('family filters the lines of qpu_families, and that answer is not loaded here — the published package carries it at dist/data/baked/qpu_families.json');
+        const name = String(a?.name ?? '').trim().toLowerCase();
+        if (!/^[a-z][a-z0-9]*$/.test(name))
+            return JSON.stringify({ status: 'REFUSED', why: 'a family name is one lowercase word, such as analytics' });
+        const lines = src.split('\n').filter((l) => l.toLowerCase().includes(name));
+        return JSON.stringify({ family: name, lines: lines.length, status: lines.length ? 'FOUND' : 'NOT_FOUND', tests: lines.slice(0, 12),
+            baked: true, ...(BAKE?.stamp ?? {}), note: 'filtered from the qpu_families answer baked at build — the same filter the full server applies, over the same lines' });
+    },
     honesty_gate: (a) => {
         const text = String(a?.text ?? '');
         if (!text)
@@ -172,7 +223,7 @@ const H = {
         const missing = here.filter((n) => !H[n]);
         const extra = Object.keys(H).filter((n) => !here.includes(n));
         return JSON.stringify({
-            entry: 'self-sufficient', ledgerLoaded: hasLedger(), served: here.length, of: TOOLS.length,
+            entry: 'self-sufficient', ledgerLoaded: hasLedger(), bakeLoaded: hasBake(), served: here.length, of: TOOLS.length,
             declaredWithoutHandler: missing, handlerWithoutDeclaration: extra,
             writes: [...WRITES].filter((w) => here.includes(w)),
             root: merkleFold(here.map((n) => toUuid(n + ':' + (TOOLS.find((t) => t.name === n)?.description ?? '')))),
@@ -189,14 +240,16 @@ export const listTools = (name) => {
             throw new Error(`unknown tool: ${String(name)} — call list_tools with no name for the list`);
         const avail = served().includes(t.name);
         return JSON.stringify({ name: t.name, description: t.description, inputSchema: t.inputSchema, available: avail,
-            ...(avail ? {} : { needs: NEEDS[t.name], why: CANNOT_SHIP[t.name] ?? 'needs the repository: clone it and run `npm run mcp` for the full surface' }) });
+            ...(bakedNames().includes(t.name) ? { baked: true, ...(BAKE?.stamp ?? {}) } : {}),
+            ...(avail ? {} : { needs: NEEDS[t.name], why: whyNot(t.name) }) });
     }
     return JSON.stringify({
         entry: 'self-sufficient — runs from the published package with no account, key, model, network or clone',
         serves: `${served().length} of ${TOOLS.length} tools`,
-        ledgerLoaded: hasLedger(),
+        ledgerLoaded: hasLedger(), bakeLoaded: hasBake(),
         tools: served().map((n) => ({ name: n, description: first(TOOLS.find((t) => t.name === n)?.description ?? '') })),
-        elsewhere: TOOLS.filter((t) => !served().includes(t.name)).map((t) => ({ name: t.name, needs: NEEDS[t.name], why: CANNOT_SHIP[t.name] ?? 'needs the repository' })),
+        baked: bakedNames().length ? { tools: bakedNames().length, ...(BAKE?.stamp ?? {}) } : null,
+        elsewhere: TOOLS.filter((t) => !served().includes(t.name)).map((t) => ({ name: t.name, needs: NEEDS[t.name], why: whyNot(t.name) })),
         note: 'The other tools are not hidden and not broken: each names what it needs. Clone the repository for the full surface.',
     });
 };
@@ -206,11 +259,23 @@ export const run = (name, a) => {
     if (name === 'call_tool')
         return run(String(a?.name ?? ''), a?.arguments ?? {});
     const h = H[name];
+    if (!h && BAKE && BAKE.answers[name] !== undefined && BAKEABLE.includes(name)) {
+        const args = a && typeof a === 'object' ? Object.keys(a) : [];
+        if (args.length)
+            throw new Error(`${name} is served BAKED — its bare answer, computed at build from the repository — and a call with `
+                + `arguments (${args.join(', ')}) asks for an answer the package cannot recompute. Call it without arguments, or clone the repository and run \`npm run mcp\`.`);
+        let answer = BAKE.answers[name];
+        try {
+            answer = JSON.parse(BAKE.answers[name]);
+        }
+        catch { }
+        return JSON.stringify({ baked: true, ...BAKE.stamp, tool: name, answer,
+            note: 'The bare answer this tool gave at build, from the tree the stamp names — not a recomputation here. Integrity of the stamp, not truth of the answer.' });
+    }
     if (!h) {
         const declared = TOOLS.find((t) => t.name === name);
         if (declared)
-            throw new Error(`${name} is a tool of this deposit but is not served by the self-sufficient entry: `
-                + (CANNOT_SHIP[name] ?? `it needs ${(NEEDS[name] ?? []).join('+')}`) + '. Clone the repository and run `npm run mcp`.');
+            throw new Error(`${name} is a tool of this deposit but is not served by the self-sufficient entry: ${whyNot(name)}`);
         throw new Error(`unknown tool: ${name} — call list_tools for what this entry serves`);
     }
     return h(a);

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

@@ -0,0 +1 @@
+export declare const SUITES: Record<string, string[]>;

package/dist/src/mcp/suites.js

@@ -0,0 +1,14 @@
+export const SUITES = {
+    'mcp-gate': ['node', 'scripts/mcp-gate.ts'],
+    'hardcode-gate': ['node', 'scripts/hardcode-gate.ts'],
+    'mcp-check': ['node', 'scripts/mcp-check.ts'],
+    'mcp-calls': ['node', 'scripts/mcp-calls.ts'],
+    'net-tools-test': ['node', 'scripts/net-tools-test.ts'],
+    'clay-conditions-self-test': ['node', 'scripts/clay-conditions-test.ts', '--self-test'],
+    'clay-conditions': ['node', 'scripts/clay-conditions-test.ts'],
+    'environment': ['node', 'scripts/environment.ts'],
+    'doi-precedence': ['node', 'scripts/doi-precedence-test.ts'],
+    'answer-doi': ['node', 'scripts/answer-doi-test.ts'],
+    'answer-tool': ['node', 'scripts/answer-tool-test.ts'],
+    'fallbacks': ['node', 'scripts/fallbacks-test.ts'],
+};

package/dist/src/mirror/index.d.ts

@@ -0,0 +1,18 @@
+export declare const mirror: (n: string) => {
+    status: 'MIRRORED';
+    mirror: string;
+    involution: boolean;
+} | {
+    status: 'REFUSED';
+    why: string;
+};
+export interface Semiprime {
+    n: string;
+    p: number;
+    q: number;
+    mirror: string | null;
+}
+export declare const semiprimes: (lo: number, hi: number, opts?: {
+    noZero?: boolean;
+    limit?: number;
+}) => Semiprime[];

package/dist/src/mirror/index.js

@@ -0,0 +1,37 @@
+export const mirror = (n) => {
+    if (!/^\d+$/.test(n))
+        return { status: 'REFUSED', why: 'not a non-negative decimal integer' };
+    if (n.includes('0'))
+        return { status: 'REFUSED', why: 'a zero digit has no mirror: 10 − 0 is not a digit' };
+    const m = [...n].map((c) => String(10 - Number(c))).join('');
+    const back = [...m].map((c) => String(10 - Number(c))).join('');
+    return { status: 'MIRRORED', mirror: m, involution: back === n };
+};
+const smallestFactor = (n) => {
+    if (n < 2)
+        return null;
+    if (n % 2 === 0)
+        return 2;
+    for (let d = 3; d * d <= n; d += 2)
+        if (n % d === 0)
+            return d;
+    return null;
+};
+export const semiprimes = (lo, hi, opts = {}) => {
+    const out = [];
+    const limit = opts.limit ?? 20;
+    const start = lo % 2 === 0 ? lo + 1 : lo;
+    for (let n = start; n <= hi && out.length < limit; n += 2) {
+        const s = String(n);
+        if (opts.noZero && s.includes('0'))
+            continue;
+        const p = smallestFactor(n);
+        if (p === null)
+            continue;
+        const q = n / p;
+        if (q === p || smallestFactor(q) !== null)
+            continue;
+        out.push({ n: s, p, q, mirror: s.includes('0') ? null : mirror(s).status === 'MIRRORED' ? mirror(s).mirror : null });
+    }
+    return out;
+};

package/dist/src/policy/index.d.ts

@@ -0,0 +1,8 @@
+export type Verdict = 'ALLOWED' | 'GATED' | 'NEEDS_OWNER';
+export interface Decision {
+    verdict: Verdict;
+    request: string;
+    reason: string;
+    rule: string;
+}
+export declare const decide: (request: string) => Decision;

package/dist/src/policy/index.js

@@ -0,0 +1,23 @@
+const RULES = [
+    { rule: 'access-grant', verdict: 'NEEDS_OWNER', pattern: /\b(tokens?|credentials?|grant|authori[sz]ed access|access keys?|accounts?|logins?|sign-?ups?|invitations?|invite links?|register|registration|computational access|real users?|registers? as|user accounts?|client (?:browser|os|sessions?)|online sessions?|browser sessions?)\b/i,
+        reason: 'grants access to people or issues credentials: only the owner decides who gets access, and with what' },
+    { rule: 'agent-payload-path', verdict: 'GATED', pattern: /\b(payload\s+mcp\s+plugin|rbac)\b/i,
+        reason: 'agents act on Payload only through the Payload MCP plugin under RBAC: that is the one path, and the roles behind it are set by the owner' },
+    { rule: 'billing', verdict: 'NEEDS_OWNER', pattern: /\b(billing|billable|payment|charge|subscription|price|pricing|meter)\b/i,
+        reason: 'takes money or sets prices: needs a payment account, a price and terms that only the owner can set' },
+    { rule: 'public-write', verdict: 'GATED', pattern: /\b(write|publish|commit|seal|push|deploy|create|(?:create|write|edit|change|update|set)\s+(?:\w+\s+){0,2}configs?|payload\s+write|cms\s+write)\b/i,
+        reason: 'changes state: stays behind the write gate and is enabled only by the owner, per credential' },
+    { rule: 'read-only', verdict: 'ALLOWED', pattern: /\b(read[- ]?only|reads?|readers?|lattice|apis?|guru|look ?ups?|query)\b/i,
+        reason: 'reads public sources and changes nothing: allowed, with a timeout and a result limit' },
+];
+export const decide = (request) => {
+    const text = request.trim();
+    if (!text)
+        return { verdict: 'NEEDS_OWNER', request, reason: 'the request is empty', rule: 'empty' };
+    const order = ['NEEDS_OWNER', 'GATED', 'ALLOWED'];
+    const hits = RULES.filter((r) => r.pattern.test(text));
+    if (!hits.length)
+        return { verdict: 'NEEDS_OWNER', request: text, reason: 'no rule of this repository names the request, so the owner decides', rule: 'unmatched' };
+    const strictest = hits.sort((a, b) => order.indexOf(a.verdict) - order.indexOf(b.verdict))[0];
+    return { verdict: strictest.verdict, request: text, reason: strictest.reason, rule: strictest.rule };
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ceccec/millennium-solutions",
-  "version": "9.8.2",
+  "version": "9.8.3",
   "description": "Verifiable, recomputable ℤ/9 vortex framework in ONE package — content-addressing, audit ledger, exact arithmetic, and the honesty toolkit. Facts only.",
   "author": {
     "name": "Tsvetan Rouschev",
@@ -103,7 +103,7 @@
     "latex-gate": "node scripts/latex-gate.ts",
     "contradictions": "node scripts/contradictions.ts",
     "prior-art": "node scripts/priorart.ts",
-    "gates": "node scripts/prose-trial.ts && node scripts/crypto-kat.ts && node scripts/attribution-gate.ts && node scripts/hardcode-gate.ts && node scripts/import-gate.ts && node scripts/one-author-gate.ts && node scripts/orphan-gate.ts && node scripts/security-gate.ts && node scripts/translate-gate.ts && node scripts/lean-agree.ts && node scripts/trial-all.ts && node scripts/readme.ts && node scripts/gaps.ts && node scripts/constants-gate.ts && node scripts/fixture-addresses.ts && node scripts/forensic-audit.ts && node scripts/notice.ts && node scripts/recover.ts && node scripts/independent.ts && node scripts/supersede.ts && node scripts/covered-gate.ts && node scripts/group.ts --emit && node scripts/bridge.ts --emit && node scripts/vacuity.ts && node scripts/citations-gate.ts && node scripts/cite-audit.ts && node scripts/lanes-check.ts && node scripts/runnable-gate.ts && node scripts/formulas.ts && node scripts/coils.ts && node scripts/settled.ts && node scripts/derived-gate.ts && node scripts/mcp-gate.ts",
+    "gates": "node scripts/apis-theorems.ts && node scripts/prose-trial.ts && node scripts/crypto-kat.ts && node scripts/attribution-gate.ts && node scripts/hardcode-gate.ts && node scripts/import-gate.ts && node scripts/one-author-gate.ts && node scripts/orphan-gate.ts && node scripts/security-gate.ts && node scripts/translate-gate.ts && node scripts/lean-agree.ts && node scripts/trial-all.ts && node scripts/readme.ts && node scripts/gaps.ts && node scripts/constants-gate.ts && node scripts/fixture-addresses.ts && node scripts/forensic-audit.ts && node scripts/notice.ts && node scripts/recover.ts && node scripts/independent.ts && node scripts/supersede.ts && node scripts/covered-gate.ts && node scripts/group.ts --emit && node scripts/bridge.ts --emit && node scripts/vacuity.ts && node scripts/citations-gate.ts && node scripts/cite-audit.ts && node scripts/lanes-check.ts && node scripts/runnable-gate.ts && node scripts/formulas.ts && node scripts/coils.ts && node scripts/settled.ts && node scripts/derived-gate.ts && node scripts/mcp-gate.ts && npm run --silent gate:thousand:control && node scripts/qpu-gate.ts && node scripts/discoveries.ts",
     "gates:fire": "node scripts/gates-fire.ts",
     "ci:local": "node scripts/ci-local.ts",
     "metrics": "node scripts/metrics.ts",
@@ -119,6 +119,7 @@
     "docs-gate": "node scripts/docs-gate.ts",
     "priorart:gen": "node scripts/priorart-gen.ts",
     "priorart-check": "node scripts/priorart-gen.ts --check",
+    "priorart:arxiv": "node scripts/arxiv-search.ts",
     "apply": "node scripts/apply.ts",
     "ci-drift": "node scripts/ci-drift.ts",
     "carry": "node scripts/carry.ts",
@@ -195,9 +196,20 @@
     "ci:watch": "node scripts/ci-watch.ts",
     "ci:watch-wait": "node scripts/ci-watch.ts --wait",
     "cycle": "npm run gates && npm run docs:build",
-    "cycle:ship": "git fetch -q --force --tags origin && npm run cycle && git add -A && { git diff --cached --quiet || git commit -m 'regenerate the derived artefacts the chain rewrote'; } && git push origin main && node scripts/ci-watch.ts --wait --for 5400",
+    "cycle:ship": "git fetch -q --force --tags origin && npm update --no-audit --no-fund @uuidna/qpu @uuidna/uuidna && npm run cycle && git add -A && { git diff --cached --quiet || git commit -m 'regenerate the derived artefacts the chain rewrote'; } && git push origin main && node scripts/ci-watch.ts --wait --for 5400 && node scripts/thousand-bit-gate.ts --decode",
     "bridge": "node scripts/bridge.ts",
-    "qpu": "node scripts/qpu-gate.ts"
+    "qpu": "node scripts/qpu-gate.ts",
+    "mcp:call": "node scripts/mcp-call.ts",
+    "gate:thousand": "node scripts/thousand-bit-gate.ts",
+    "gate:thousand:control": "node scripts/thousand-bit-gate.ts --control",
+    "gate:leads": "node scripts/leads-closed.ts",
+    "gate:api": "node scripts/api-gates.ts",
+    "gate:packages": "node scripts/package-gates.ts",
+    "test:online-verify": "node scripts/online-verify-e2e-test.ts",
+    "test:run-suite-security": "node scripts/run-suite-security-test.ts",
+    "cern:lean": "node scripts/cern-lean.ts",
+    "push:green": "node scripts/push-when-green.ts",
+    "dataset:court": "node scripts/dataset-court.ts"
   },
   "devDependencies": {
     "@types/node": "^26.2.0",
@@ -238,5 +250,8 @@
   "dependencies": {
     "@uuidna/qpu": "^1.0.0",
     "@uuidna/uuidna": "^0.2.6"
+  },
+  "overrides": {
+    "postcss-selector-parser": "^7.1.6"
   }
 }