@ceccec/millennium-solutions 9.7.6 → 9.8.2

package/dist/src/mcp/index.js

@@ -0,0 +1,112 @@
+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: { 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: [] } },
+    { 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_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: '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: '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'],
+    readers: ['net', 'tree'],
+    live: ['net', 'tree'],
+    connect: ['net'],
+    api_joins: ['net', 'tree'],
+    coils: ['tree'],
+    discoveries: ['tree'],
+    formulas: ['tree'],
+    handle: ['core'],
+    lean_verify: ['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: ['core'],
+};
+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,90 @@
+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) => {
+    uuid: string;
+    found: boolean;
+    note: string;
+    index?: undefined;
+    key?: undefined;
+    name?: 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 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;

package/dist/src/mcp/serve.js

@@ -0,0 +1,217 @@
+import { toUuid, merkleFold, merge } from '../0/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';
+import { TOOLS, NEEDS, WRITES } from './index.js';
+import { computes } from '@uuidna/uuidna';
+export const ledgerStatus = (rows) => {
+    const live = rows.filter((r) => !r.revoked);
+    const carried = rows.filter((r) => r.revoked && r.supersededBy);
+    const keys = new Map(), receipts = new Map();
+    for (const r of rows) {
+        keys.set(r.key, (keys.get(r.key) ?? 0) + 1);
+        receipts.set(r.receipt, (receipts.get(r.receipt) ?? 0) + 1);
+    }
+    return {
+        total: rows.length, live: live.length, revoked: rows.length - live.length, carried: carried.length,
+        duplicateKeys: [...keys].filter(([, n]) => n > 1).map(([k]) => k),
+        duplicateReceipts: [...receipts].filter(([, n]) => n > 1).map(([k]) => k),
+        octave: { size: rows.length, remainder: rows.length % 8, exact: rows.length % 8 === 0 },
+        note: 'Measurement of the ledger as given. It says nothing about whether any entry is TRUE — only what the record contains and whether its keys and receipts are unique.',
+    };
+};
+export const forensicsOf = (rows, seed = 'axiom:TRINITY') => {
+    const breaks = [];
+    let prev = toUuid(seed);
+    rows.forEach((r, i) => {
+        const expected = toUuid(prev + '→' + r.key);
+        if (expected !== r.receipt)
+            breaks.push({ index: i, key: r.key, expected, found: r.receipt });
+        prev = r.receipt;
+    });
+    const genesis = breaks.filter((b) => b.index < 2);
+    return {
+        entries: rows.length, breaks: breaks.length, genesisDiscontinuities: genesis.length,
+        newBreaks: breaks.filter((b) => b.index >= 2).slice(0, 8),
+        intactFromIndex: breaks.length === genesis.length ? 2 : null,
+        seal: merkleFold(rows.map((r) => r.receipt)),
+        note: 'Chain-of-custody and tamper-evidence, not truth. Indices 0 and 1 are a documented baseline in this deposit; a break at index 2 or later is tampering.',
+    };
+};
+export const verifyIn = (rows, uuid) => {
+    const at = rows.findIndex((r) => r.receipt === uuid.toLowerCase());
+    if (at < 0)
+        return { uuid, found: false,
+            note: 'Not a receipt in this ledger. That is not the same as opaque or invalid: this entry carries only the ledger it was handed, and the address may belong to the agent-statement receipts, which the full server reads.' };
+    const r = rows[at];
+    return { uuid, found: true, index: at, key: r.key, name: r.name ?? null, live: !r.revoked,
+        supersededBy: r.supersededBy ?? null, reason: r.reason ?? null,
+        chainIntactHere: at === 0 || toUuid(rows[at - 1].receipt + '→' + r.key) === r.receipt,
+        note: 'The address was found and its chain link recomputed. Integrity and position, never truth of the statement.' };
+};
+export const CANNOT_SHIP = {
+    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',
+};
+const CORE_TOOLS = Object.entries(NEEDS)
+    .filter(([k, n]) => n.length === 1 && n[0] === 'core' && !CANNOT_SHIP[k])
+    .map(([k]) => k);
+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'];
+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 : []),
+].sort();
+export const formulasFrom = (rows, a = {}) => {
+    let out = rows;
+    const total = out.length;
+    if (a.wing)
+        out = out.filter((r) => r.wing === a.wing);
+    if (a.file)
+        out = out.filter((r) => r.source === a.file);
+    if (a.contains) {
+        const q = a.contains.toLowerCase();
+        out = out.filter((r) => (r.name + ' ' + r.statement).toLowerCase().includes(q));
+    }
+    const limit = Math.max(1, Math.min(Number(a.limit ?? 40), 500));
+    return {
+        total, matched: out.length, showing: Math.min(limit, out.length),
+        wings: [...new Set(rows.map((r) => r.wing))].sort(),
+        formulas: out.slice(0, limit),
+        note: 'The proposition the Lean kernel accepted, character for character, with the file and tactic that '
+            + 'discharged it. Nothing here is summarised and nothing is authored. A formula being listed says the '
+            + 'kernel accepted it, not that it is significant.',
+    };
+};
+let ROWS = null;
+export const withLedger = (rows) => { ROWS = rows; };
+export const hasLedger = () => ROWS !== null;
+let FORMS = null;
+export const withFormulas = (rows) => { FORMS = rows; };
+export const hasFormulas = () => FORMS !== null;
+const rowsOrRefuse = (tool) => {
+    if (!ROWS)
+        throw new Error(`${tool} measures the discovery ledger and no ledger was loaded. `
+            + 'That is NOT a ledger of zero entries — it is an absent one. The published package carries the ledger at '
+            + 'dist/data/discovered.json; if it is missing, pass one, or clone the repository for the full server.');
+    return ROWS;
+};
+const H = {
+    formulas: (a) => {
+        if (!FORMS)
+            throw new Error('formulas: the formula catalogue is not loaded. The published package carries it '
+                + 'at dist/data/formulas.jsonld; if it is missing, pass rows, or clone the repository for the full server. '
+                + 'An absent catalogue is NOT a catalogue of zero formulas.');
+        return JSON.stringify(formulasFrom(FORMS, a ?? {}));
+    },
+    ledger_status: () => JSON.stringify(ledgerStatus(rowsOrRefuse('ledger_status'))),
+    forensics: () => JSON.stringify(forensicsOf(rowsOrRefuse('forensics'))),
+    verify: (a) => {
+        const u = String(a?.uuid ?? '');
+        if (!u)
+            throw new Error('verify: uuid is required. This entry looks an address up in the ledger; for prose auditing, the honesty gate lives in the full server.');
+        return JSON.stringify(verifyIn(rowsOrRefuse('verify'), u));
+    },
+    content_address: (a) => {
+        const text = String(a?.text ?? '');
+        if (!text)
+            throw new Error('content_address: text is required');
+        return JSON.stringify({ uuid: toUuid(text), of: text.length + ' character(s)',
+            note: 'INTEGRITY and provenance, not encryption and not proof. The same text always gives this address; the address never gives the text back.' });
+    },
+    merkle_fold: (a) => {
+        const items = (a?.items ?? []);
+        if (!Array.isArray(items) || !items.length)
+            throw new Error('merkle_fold: items must be a non-empty array of strings');
+        const xs = items.map(String);
+        return JSON.stringify({ root: merkleFold(xs), count: xs.length, pairwise: xs.length > 1 ? merge(xs[0], xs[1]) : null,
+            note: 'Order-independent: the same set of items folds to the same root in any order. Leaves and nodes are domain-separated and length-prefixed, so no regrouping of the inputs produces this root.' });
+    },
+    handle: (a) => {
+        const text = String(a?.text ?? '');
+        if (!text)
+            throw new Error('handle: text is required');
+        const given = a?.handle ? String(a.handle) : null;
+        if (given) {
+            const r = resolve(given, text);
+            return JSON.stringify({ handle: given, address: r.uuid, carries: r.carries, hex: HANDLE_HEX,
+                note: 'A handle ROUTES and REJECTS; it never identifies. `carries` false is a definite no; `carries` true means NOT EXCLUDED — sixteen bits collide, so it is never "the same".' });
+        }
+        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.' });
+    },
+    honesty_gate: (a) => {
+        const text = String(a?.text ?? '');
+        if (!text)
+            throw new Error('honesty_gate: text is required — the gate reads prose the caller passes in; it reads no file here');
+        const r = computes(text);
+        return JSON.stringify({ binary: r.binary, hit: r.hit,
+            note: r.binary ? 'no overclaim shape (a lexical FLOOR, not truth — passing is not being right)' : 'drains: ' + r.hit });
+    },
+    verify_face: (a) => {
+        const raw = a?.json;
+        if (!raw)
+            throw new Error('verify_face: json is required — pass the face object or its JSON text. This entry reads no files.');
+        const face = (typeof raw === 'string' ? JSON.parse(raw) : raw);
+        const r = checkFace(face);
+        return JSON.stringify({ ...r,
+            note: 'INTEGRITY ONLY. A passing verdict establishes that the rows are unaltered since sealing, NOT that any figure in them is correct. Reading it as evidence a number is right is the error this tool exists to prevent.' });
+    },
+    rosetta: () => JSON.stringify({ core: ROSETTA_CORE, domains: ROSETTA_DOMAINS.length,
+        addresses: ROSETTA_DOMAINS.map((d) => ({ domain: d, uuid: toUuid(d) })),
+        distinct: new Set(ROSETTA_DOMAINS.map((d) => toUuid(d))).size === ROSETTA_DOMAINS.length,
+        root: merkleFold(ROSETTA_DOMAINS.map((d) => toUuid(d))),
+        note: 'Integrity of the cross-domain map, not truth of anything in it.' }),
+    audit: () => {
+        const here = served();
+        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,
+            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 ?? '')))),
+            cannotShip: CANNOT_SHIP,
+            note: 'Integrity of THIS entry\'s tool surface. `writes` is empty by construction: nothing reachable from here can write, because nothing reachable from here has a tree to write to.',
+        });
+    },
+};
+const first = (d) => (d.split(/(?<=[.—])\s/)[0] ?? d).slice(0, 140);
+export const listTools = (name) => {
+    if (name) {
+        const t = TOOLS.find((x) => x.name === String(name));
+        if (!t)
+            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' }) });
+    }
+    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(),
+        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' })),
+        note: 'The other tools are not hidden and not broken: each names what it needs. Clone the repository for the full surface.',
+    });
+};
+export const run = (name, a) => {
+    if (name === 'list_tools')
+        return listTools(a?.name);
+    if (name === 'call_tool')
+        return run(String(a?.name ?? ''), a?.arguments ?? {});
+    const h = H[name];
+    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(`unknown tool: ${name} — call list_tools for what this entry serves`);
+    }
+    return h(a);
+};

package/dist/src/the/rosetta/index.d.ts

@@ -0,0 +1,3 @@
+export declare const CORE = "rosetta-core";
+export declare const DOMAINS: string[];
+export declare function report(): string;

package/dist/src/the/rosetta/index.js

@@ -0,0 +1,25 @@
+import { toUuid, merkleFold } from '../../0/index.js';
+export const CORE = 'rosetta-core';
+export const DOMAINS = [
+    'z9-arithmetic', 'units-triad', 'doubling-orbit', 'inverses', 'powers', 'primes', 'cyclic-groups',
+    'boolean-algebra', 'entanglement', 'dialectic', 'games', 'arts', 'gematria', 'language-lens',
+    'merkle-ledger', 'harmonic-ledger', 'no-payload-security', 'involutions', 'fibonacci-cassini',
+    'lucas-pell', 'finite-fields', 'perfect-amicable', 'collatz', 'stirling', 'graph-coloring',
+    'rule90-sierpinski', 'continued-fractions', 'quaternions', 'motzkin', 'bernoulli', 'catalan',
+    'divisor-sums', 'platonic-solids', 'crystal-diamond', 'genus-topology', 'surfaces', 'wilson-fermat',
+    'figurate', 'rock-paper-scissors', 'self-similarity', 'fair-division', 'honeycomb', 'waves',
+    'forensics', 'ramsey', 'inequalities', 'partitions', 'lucas-theorem', 'pigeonhole', 'pick',
+    'cantor-pairing', 'chinese-remainder', 'quadratic-residues', 'path', 'abundance', 'cancer',
+    'superposition', 'creation-week', 'relations',
+];
+export function report() {
+    const addrs = DOMAINS.map((d) => toUuid(CORE + '→' + d));
+    const distinct = new Set(addrs).size;
+    const root = merkleFold(addrs);
+    let o = 'the rosetta — completed (the star: every domain one hop from the core):\n\n';
+    o += '  core: ' + toUuid(CORE).slice(0, 13) + '…\n';
+    o += '  domains (' + DOMAINS.length + '): ' + DOMAINS.join(' · ') + '\n';
+    o += '  each reachable in one hop; ' + distinct + ' distinct addresses (' + (distinct === DOMAINS.length ? 'no collision — complete' : 'COLLISION') + ')\n';
+    o += '  folded rosetta root ' + root.slice(0, 13) + '… — the cross-domain translation is complete.';
+    return o;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ceccec/millennium-solutions",
-  "version": "9.7.6",
+  "version": "9.8.2",
   "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",
@@ -14,7 +14,11 @@
       "types": "./dist/mod.core.d.ts",
       "default": "./dist/mod.core.js"
     },
-    "./package.json": "./package.json"
+    "./package.json": "./package.json",
+    "./mcp": {
+      "types": "./dist/src/mcp/serve.d.ts",
+      "default": "./dist/src/mcp/serve.js"
+    }
   },
   "types": "./dist/mod.core.d.ts",
   "files": [
@@ -29,8 +33,8 @@
   },
   "scripts": {
     "docs:dev": "vitepress dev",
-    "predocs:build": "node scripts/analytics.ts && node scripts/pages.ts && node scripts/dashboard.ts && node scripts/boundaries.ts && node scripts/rights.ts && node scripts/priorart.ts && node scripts/challenges.ts && node scripts/heart.ts && node scripts/accounting.ts && node scripts/speedup.ts && node scripts/greeting.ts && node scripts/solutions.ts && node scripts/contradictions.ts && node scripts/latex-gate.ts && node scripts/paper.ts",
-    "docs:build": "vitepress build && node scripts/e2e.ts",
+    "predocs:build": "node scripts/analytics.ts && node scripts/pages.ts && node scripts/dashboard.ts && node scripts/boundaries.ts && node scripts/rights.ts && node scripts/priorart-gen.ts && node scripts/priorart.ts && node scripts/challenges.ts && node scripts/heart.ts && node scripts/accounting.ts && node scripts/speedup.ts && node scripts/greeting.ts && node scripts/solutions.ts && node scripts/contradictions.ts && node scripts/latex-gate.ts && node scripts/paper.ts",
+    "docs:build": "NODE_OPTIONS=--max-old-space-size=7168 vitepress build && node scripts/e2e.ts",
     "docs:preview": "vitepress preview",
     "crypto-kat": "node scripts/crypto-kat.ts",
     "prose-trial": "node scripts/prose-trial.ts",
@@ -99,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/covered-gate.ts && 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",
+    "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:fire": "node scripts/gates-fire.ts",
     "ci:local": "node scripts/ci-local.ts",
     "metrics": "node scripts/metrics.ts",
@@ -171,12 +175,33 @@
     "formulas": "node scripts/formulas.ts",
     "discoveries": "node scripts/discoveries.ts",
     "e2e": "node scripts/e2e.ts",
-    "release:live": "node scripts/release-live.ts"
+    "release:live": "node scripts/release-live.ts",
+    "settled": "node scripts/settled.ts",
+    "settled:emit": "node scripts/settled.ts --emit",
+    "derived-gate": "node scripts/derived-gate.ts",
+    "mcp:self": "node mcp.bin.ts",
+    "mcp-gate": "node scripts/mcp-gate.ts",
+    "entanglements": "node scripts/entanglements.ts",
+    "entanglements:control": "node scripts/entanglements.ts --control",
+    "readers": "node scripts/readers.ts",
+    "readers:list": "node scripts/readers.ts --list",
+    "entangle-oeis": "node scripts/entangle-oeis.ts",
+    "api-discover": "node scripts/api-discover.ts",
+    "api-discover:schemas": "node scripts/api-discover.ts --schemas",
+    "waves": "node scripts/waves.ts",
+    "waves:quick": "node scripts/waves.ts --quick",
+    "group": "node scripts/group.ts",
+    "supersede": "node scripts/supersede.ts",
+    "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",
+    "bridge": "node scripts/bridge.ts",
+    "qpu": "node scripts/qpu-gate.ts"
   },
   "devDependencies": {
     "@types/node": "^26.2.0",
     "@types/three": "^0.185.4",
-    "@uuidna/uuidna": "^0.2.6",
     "three": "^0.185.1",
     "typescript": "7.0.2",
     "vitepress": "^2.0.0-alpha.19",
@@ -206,5 +231,12 @@
     "verifiable",
     "recomputable",
     "lean4"
-  ]
+  ],
+  "bin": {
+    "millennium-mcp": "./dist/mcp.bin.js"
+  },
+  "dependencies": {
+    "@uuidna/qpu": "^1.0.0",
+    "@uuidna/uuidna": "^0.2.6"
+  }
 }