onto-mcp 0.4.12 → 0.4.13

package/dist/core-runtime/discovery/synthesize-cert-mutation.js

@@ -0,0 +1,117 @@
+/**
+ * S3 — the `input_corruption/v1` negative-control transform for the B4
+ * `synthesize-cert/v1` bench (design 20260706-b4-r8-harness-design v3 §6/§15.3).
+ *
+ * The negative arm is defined by INPUT mutation only (every arm runs the same
+ * prompt), realized as this ONE deterministic named transform: the record cites
+ * `mutation_kind` + `mutation_params`, this implementation owns boundedness.
+ * Both judged metrics are targeted (§6.2-3) through two content-changing levers:
+ *
+ *  - grounding lever = `relabel/v1`: every format_cluster string and every
+ *    child_summary is deterministically rewritten (seed-based), so the sorted
+ *    cluster list / child prose CONTENT changes — the sha moves and the arm
+ *    authors from wrong facts, which the judge (against the ORIGINAL packet)
+ *    can flag. Child summaries rotate between siblings when that changes bytes
+ *    (plausible-but-wrong prose); otherwise a seed suffix guarantees the change.
+ *  - boundary lever = `seam_offset/v1`: every value_shape seam row moves by a
+ *    seed-picked offset ≥2 where the node range permits (|Δ|=1 only as the
+ *    tight-range fallback) — ≥2 escapes the production ±1 anchor tolerance, so
+ *    a mutated-seam-following output cannot silently re-anchor to the original.
+ *
+ * Per-metric provenance (§6 G/I): the result reports which levers ACTUALLY
+ * changed the packet — on a no-seam input the boundary lever is inert and the
+ * row targets grounding only ("no spurious boundary" is what boundary then
+ * judges). An input with NO applicable lever (no clusters, no children, no
+ * seams) is REJECTED fail-closed: it cannot host a negative row, and the
+ * sampler/loop must exclude it (§6 레버 보장).
+ *
+ * Whether the corruption REALLY degrades the metrics is a semantic question —
+ * R7 human curation (§13.3), never re-enforced deterministically here.
+ */
+import { createHash } from "node:crypto";
+import { SYNTHESIZE_CERT_METRICS, } from "./synthesize-cert-record.js";
+import { synthesizeCertInputSha256 } from "./synthesize-cert-sampler.js";
+export const SYNTHESIZE_CERT_MUTATION_KIND = "input_corruption/v1";
+export const INPUT_CORRUPTION_GROUNDING_LEVER = "relabel/v1";
+export const INPUT_CORRUPTION_BOUNDARY_LEVER = "seam_offset/v1";
+const sha8 = (text) => createHash("sha256").update(text).digest("hex").slice(0, 8);
+/**
+ * Applies `input_corruption/v1` to a frozen packet. Throws on an input with no
+ * applicable lever (the §6 negative-sample exclusion), so "a negative row that
+ * silently ran the original packet" is structurally impossible.
+ */
+export function applyInputCorruptionV1(packet, params) {
+    if (typeof params.seed !== "string" || params.seed.length === 0) {
+        throw new Error("input_corruption/v1: seed must be a non-empty string");
+    }
+    const originalSha = synthesizeCertInputSha256(packet); // envelope-asserts the input too
+    const hasClusters = packet.format_clusters.length > 0;
+    const hasChildren = packet.child_summaries.length > 0;
+    const hasSeams = packet.value_shape_seams.length > 0;
+    if (!hasClusters && !hasChildren && !hasSeams) {
+        throw new Error("input_corruption/v1: input has no applicable lever (no format_clusters, no child_summaries, no seams) — it cannot host a negative row and must be excluded from the negative sample (§6)");
+    }
+    // ── grounding lever: relabel/v1 ─────────────────────────────────────────────
+    const mutatedClusters = packet.format_clusters.map((s) => `${s}~${sha8(`${params.seed}|cluster|${s}`)}`);
+    let mutatedChildren = packet.child_summaries.map((c) => ({ key: c.key, summary: c.summary }));
+    if (hasChildren) {
+        const n = mutatedChildren.length;
+        const rotated = mutatedChildren.map((c, i) => ({
+            key: c.key,
+            summary: mutatedChildren[(i + 1) % n].summary,
+        }));
+        const rotationChanged = rotated.some((c, i) => c.summary !== mutatedChildren[i].summary);
+        mutatedChildren = rotationChanged
+            ? rotated // plausible-but-wrong: each subtree now carries a SIBLING's prose
+            : mutatedChildren.map((c) => ({
+                key: c.key,
+                summary: `${c.summary} ~${sha8(`${params.seed}|child|${c.key}`)}`,
+            }));
+    }
+    const groundingApplied = hasClusters || hasChildren;
+    // ── boundary lever: seam_offset/v1 ─────────────────────────────────────────
+    const r = packet.node_ref;
+    const preferred = 2 + (parseInt(sha8(`${params.seed}|seam`), 16) % 3); // 2..4
+    const offsetRow = (row) => {
+        for (const delta of [preferred, -preferred, 1, -1]) {
+            const moved = row + delta;
+            if (moved !== row && moved > r.row_start && moved <= r.row_end)
+                return moved;
+        }
+        return row - 1; // degenerate 1-row range: still a guaranteed change
+    };
+    const mutatedSeams = packet.value_shape_seams.map((s) => ({
+        row: offsetRow(s.row),
+        prev_shape: s.prev_shape,
+        new_shape: s.new_shape,
+    }));
+    const mutated = {
+        node_ref: { sheet: r.sheet, column_index: r.column_index, row_start: r.row_start, row_end: r.row_end },
+        format_clusters: mutatedClusters,
+        value_shape_seams: mutatedSeams,
+        child_summaries: mutatedChildren,
+    };
+    const mutatedSha = synthesizeCertInputSha256(mutated);
+    if (mutatedSha === originalSha) {
+        throw new Error("input_corruption/v1: mutation left the packet sha unchanged (impossible state — transform guarantee broken)");
+    }
+    return {
+        mutated,
+        mutated_input_sha256: mutatedSha,
+        levers_applied: { grounding: groundingApplied, boundary: hasSeams },
+    };
+}
+/** The record's `negative_arm` block for this transform — single source so the
+ * harness cannot cite the kind while running something else (§6.3). */
+export function buildInputCorruptionV1NegativeArm(seed) {
+    return {
+        arm: "negative_control",
+        mutation_kind: SYNTHESIZE_CERT_MUTATION_KIND,
+        mutation_params: {
+            grounding_lever: INPUT_CORRUPTION_GROUNDING_LEVER,
+            boundary_lever: INPUT_CORRUPTION_BOUNDARY_LEVER,
+            seed,
+        },
+        targeted_metrics: [...SYNTHESIZE_CERT_METRICS],
+    };
+}

package/dist/core-runtime/discovery/synthesize-cert-packet.js

@@ -0,0 +1,182 @@
+import { assertSynthesisInputBounded, assertSynthesisOutputBounded, buildSynthesisInputForNode, } from "../reconstruct/comprehension-semantic-map.js";
+import { synthesizeCertDeterministicFactsSha256, synthesizeCertInputSha256, } from "./synthesize-cert-sampler.js";
+/**
+ * Freezes one packet per sampled manifest entry. For each entry the pipeline's
+ * deterministic facts are re-derived and bound to the manifest's
+ * `deterministic_facts_sha256` (fail-closed: a wrong workbook, a changed
+ * reduce config, or a stale manifest cannot silently freeze). Merge entries
+ * get reference-authored child summaries (memoized per pipeline); leaf entries
+ * freeze with `child_summaries: []` and spend nothing.
+ */
+export async function freezeSynthesizeCertPackets(args) {
+    const summaryCaches = new Map();
+    let referenceCalls = 0;
+    /** Post-order reference authoring of `key`'s summary (and its non-subsumed
+     * descendants'), memoized — mirrors the production bridge walk. */
+    const authorSummary = async (pipeline, cache, key) => {
+        if (cache.has(key))
+            return;
+        const tnode = pipeline.trace.nodes.get(key);
+        if (!tnode)
+            throw new Error(`synthesize-cert-packet: trace node missing for ${key} (reference walk).`);
+        const consumed = tnode.child_keys.filter((k) => pipeline.modes.get(k) !== "subsumed");
+        for (const child of consumed)
+            await authorSummary(pipeline, cache, child);
+        const input = buildSynthesisInputForNode(pipeline.trace, pipeline.nodesByKey, pipeline.modes, key, cache);
+        assertSynthesisInputBounded(input);
+        referenceCalls += 1; // attempt-counted at dispatch (W2-X7-001 discipline).
+        const out = await args.referenceSynthesize(input);
+        assertSynthesisOutputBounded(out);
+        cache.set(key, out.semantic_summary);
+    };
+    const packets = [];
+    for (const entry of args.entries) {
+        const pipeline = args.resolvePipeline(entry);
+        if (!pipeline.trace.nodes.has(entry.node_key)) {
+            throw new Error(`synthesize-cert-packet: manifest entry ${entry.input_id} names node ${entry.node_key}, absent from its resolved pipeline`);
+        }
+        let cache = summaryCaches.get(pipeline);
+        if (!cache) {
+            cache = new Map();
+            summaryCaches.set(pipeline, cache);
+        }
+        // The manifest's merge flag must be TRUE about the resolved pipeline — a
+        // flipped flag would either skip authoring (caught below) or silently
+        // misfile the row's stratum in the record.
+        const mode = pipeline.modes.get(entry.node_key);
+        if ((mode === "accumulating") !== entry.stratum.merge) {
+            throw new Error(`synthesize-cert-packet: ${entry.input_id} declares merge=${entry.stratum.merge} but the pipeline classifies ${entry.node_key} as '${mode}' (fail-closed)`);
+        }
+        // Manifest ↔ pipeline binding (§4): the deterministic facts the pipeline
+        // yields NOW must hash to what the manifest froze at sampling time.
+        const tnode = pipeline.trace.nodes.get(entry.node_key);
+        const consumed = tnode.child_keys.filter((k) => pipeline.modes.get(k) !== "subsumed");
+        const factsProbe = buildSynthesisInputForNode(pipeline.trace, pipeline.nodesByKey, pipeline.modes, entry.node_key, new Map(consumed.map((k) => [k, ""])));
+        const facts = {
+            node_ref: factsProbe.node_ref,
+            format_clusters: factsProbe.format_clusters,
+            value_shape_seams: factsProbe.value_shape_seams,
+        };
+        const factsSha = synthesizeCertDeterministicFactsSha256(facts);
+        if (factsSha !== entry.deterministic_facts_sha256) {
+            throw new Error(`synthesize-cert-packet: ${entry.input_id} deterministic facts recompute to ${factsSha} but the manifest froze ${entry.deterministic_facts_sha256} — wrong workbook, changed reduce config, or stale manifest (fail-closed)`);
+        }
+        // Reference child authoring (merge only; a frontier node consumes no
+        // children and the builder returns child_summaries: []).
+        for (const child of consumed) {
+            if (entry.stratum.merge)
+                await authorSummary(pipeline, cache, child);
+        }
+        const packet = buildSynthesisInputForNode(pipeline.trace, pipeline.nodesByKey, pipeline.modes, entry.node_key, cache);
+        assertSynthesisInputBounded(packet);
+        packets.push({
+            fixture_id: entry.fixture_id,
+            input_id: entry.input_id,
+            node_key: entry.node_key,
+            stratum: entry.stratum,
+            deterministic_facts_sha256: entry.deterministic_facts_sha256,
+            input_sha256: synthesizeCertInputSha256(packet),
+            packet,
+        });
+    }
+    return { packets, reference_synthesize_calls: referenceCalls };
+}
+// ── --resume checkpoint (live-wiring cut, owner decision D1) ─────────────────
+//
+// Freeze is the ONE paid phase a resumed run must never repeat: this contract
+// durably serializes exactly what `freezeSynthesizeCertPackets` produced, so a
+// crashed/interrupted --go run can reload the identical frozen packets instead
+// of re-spending the reference-authoring calls. The orchestrator script owns
+// the file I/O (write right after freeze completes, read at --resume start);
+// this module owns the contract shape and its fail-closed verification.
+export const SYNTHESIZE_CERT_FREEZE_CHECKPOINT_CONTRACT = "synthesize-cert-freeze-checkpoint/v1";
+/** Pure projection of a freeze result into the durable checkpoint shape — no
+ * I/O; the caller JSON.stringifies and writes it. */
+export function serializeSynthesizeCertFreezeCheckpoint(frozen, manifestIdentitySha256) {
+    return {
+        checkpoint_contract: SYNTHESIZE_CERT_FREEZE_CHECKPOINT_CONTRACT,
+        manifest_identity_sha256: manifestIdentitySha256,
+        reference_synthesize_calls: frozen.reference_synthesize_calls,
+        packets: frozen.packets,
+    };
+}
+/**
+ * Fail-closed parse + re-verification of a persisted checkpoint. Every check
+ * throws (never silently coerces or drops): contract tag mismatch, manifest
+ * identity mismatch, a malformed packet shape, a duplicate input_id, the
+ * checkpoint's input_id SET disagreeing with the expected manifest (extra OR
+ * missing — no silent scope-shrink/grow), and — the tamper/corruption guard —
+ * each packet's `input_sha256` failing to recompute via the SAME canonical
+ * hash (`synthesizeCertInputSha256`) `freezeSynthesizeCertPackets` used to
+ * produce it. Reuses `assertSynthesisInputBounded` (the shipped source-safe
+ * envelope guard) rather than re-implementing packet shape checks.
+ */
+export function parseSynthesizeCertFreezeCheckpoint(raw, args) {
+    if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+        throw new Error("synthesize-cert-packet: freeze checkpoint must be a JSON object (fail-closed)");
+    }
+    const obj = raw;
+    if (obj.checkpoint_contract !== SYNTHESIZE_CERT_FREEZE_CHECKPOINT_CONTRACT) {
+        throw new Error(`synthesize-cert-packet: freeze checkpoint carries contract ${JSON.stringify(obj.checkpoint_contract)}, expected ${SYNTHESIZE_CERT_FREEZE_CHECKPOINT_CONTRACT} (fail-closed)`);
+    }
+    if (obj.manifest_identity_sha256 !== args.expectedManifestIdentitySha256) {
+        throw new Error(`synthesize-cert-packet: freeze checkpoint manifest identity ${JSON.stringify(obj.manifest_identity_sha256)} disagrees with the expected manifest ${args.expectedManifestIdentitySha256} (fail-closed — same --fixture args in same order?)`);
+    }
+    if (typeof obj.reference_synthesize_calls !== "number" ||
+        !Number.isSafeInteger(obj.reference_synthesize_calls) ||
+        obj.reference_synthesize_calls < 0) {
+        throw new Error("synthesize-cert-packet: freeze checkpoint reference_synthesize_calls must be a nonnegative safe integer (fail-closed)");
+    }
+    if (!Array.isArray(obj.packets)) {
+        throw new Error("synthesize-cert-packet: freeze checkpoint packets must be an array (fail-closed)");
+    }
+    const seenInputIds = new Set();
+    const packets = obj.packets.map((rawPacket, index) => {
+        if (typeof rawPacket !== "object" || rawPacket === null || Array.isArray(rawPacket)) {
+            throw new Error(`synthesize-cert-packet: freeze checkpoint packets[${index}] must be an object (fail-closed)`);
+        }
+        const p = rawPacket;
+        const { fixture_id, input_id, node_key, stratum, deterministic_facts_sha256, input_sha256, packet } = p;
+        if (typeof fixture_id !== "string" ||
+            typeof input_id !== "string" ||
+            typeof node_key !== "string" ||
+            typeof deterministic_facts_sha256 !== "string" ||
+            typeof input_sha256 !== "string" ||
+            typeof stratum !== "object" || stratum === null || Array.isArray(stratum) ||
+            typeof stratum.seam !== "boolean" ||
+            typeof stratum.merge !== "boolean" ||
+            typeof packet !== "object" || packet === null || Array.isArray(packet)) {
+            throw new Error(`synthesize-cert-packet: freeze checkpoint packets[${index}] has a malformed shape (fail-closed)`);
+        }
+        if (seenInputIds.has(input_id)) {
+            throw new Error(`synthesize-cert-packet: freeze checkpoint lists input_id ${input_id} more than once (fail-closed)`);
+        }
+        seenInputIds.add(input_id);
+        // Reuse the shipped source-safe envelope guard (§13.6) instead of a second
+        // hand-rolled shape check — a malformed/enriched packet fails here.
+        assertSynthesisInputBounded(packet);
+        const recomputedSha = synthesizeCertInputSha256(packet);
+        if (recomputedSha !== input_sha256) {
+            throw new Error(`synthesize-cert-packet: freeze checkpoint packet ${input_id} recomputes input_sha256 ${recomputedSha}, checkpoint declares ${input_sha256} (fail-closed — tampered or corrupted checkpoint)`);
+        }
+        return {
+            fixture_id,
+            input_id,
+            node_key: node_key,
+            stratum: {
+                seam: stratum.seam,
+                merge: stratum.merge,
+            },
+            deterministic_facts_sha256,
+            input_sha256,
+            packet: packet,
+        };
+    });
+    const expectedIds = new Set(args.expectedInputIds);
+    const extra = [...seenInputIds].filter((id) => !expectedIds.has(id));
+    const missing = [...expectedIds].filter((id) => !seenInputIds.has(id));
+    if (extra.length > 0 || missing.length > 0) {
+        throw new Error(`synthesize-cert-packet: freeze checkpoint input_id set disagrees with the expected manifest (extra=[${extra.join(", ")}] missing=[${missing.join(", ")}]) — fail-closed, scope-shrink/grow forbidden`);
+    }
+    return { packets, reference_synthesize_calls: obj.reference_synthesize_calls };
+}