@ceccec/millennium-solutions 9.7.6 → 9.8.3

package/dist/src/mcp/serve.js

@@ -0,0 +1,282 @@
+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';
+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 = {
+    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',
+};
+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'];
+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;
+    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 = {
+    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 '
+                + '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.' });
+    },
+    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)
+            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(), 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 ?? '')))),
+            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,
+            ...(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(), bakeLoaded: hasBake(),
+        tools: served().map((n) => ({ name: n, description: first(TOOLS.find((t) => t.name === n)?.description ?? '') })),
+        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.',
+    });
+};
+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 && 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: ${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/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.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",
@@ -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/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",
@@ -115,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",
@@ -171,12 +176,44 @@
     "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 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",
+    "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",
     "@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 +243,15 @@
     "verifiable",
     "recomputable",
     "lean4"
-  ]
+  ],
+  "bin": {
+    "millennium-mcp": "./dist/mcp.bin.js"
+  },
+  "dependencies": {
+    "@uuidna/qpu": "^1.0.0",
+    "@uuidna/uuidna": "^0.2.6"
+  },
+  "overrides": {
+    "postcss-selector-parser": "^7.1.6"
+  }
 }