@gamaze/hicortex 0.23.1 → 0.24.0

package/dist/eval/planted-harness.js

@@ -1,651 +0,0 @@
-"use strict";
-/**
- * The planted-pairs acceptance gate (#393 increment A) — machinery shared by
- * the CLI runner (planted-eval.ts, REAL embedder + real-text corpus) and the
- * vitest suite (tests/planted-pairs.test.ts, controlled synthetic vectors).
- *
- * What it measures, per planted pair, before/after running the REAL
- * production resolution stage (`stageReconsolidation`, which internally runs
- * the deterministic merge zone LAST — guard-C: judgment outranks the sweep):
- *
- *   DETECTED — the pair entered the resolution machinery as a candidate: a
- *     verdict call was made on it (judged band, logged by the ground-truth
- *     judge) OR it co-clustered in the pre-stage `planDedup` discovery at the
- *     zone ceiling. Tagged by source ("judge" = KNN/similarity, "scout" = the
- *     #393 B reference-extraction source — attribution rule: a verdict call
- *     on a below-floor pair can only be scout-sourced, "zone" = the
- *     deterministic ceiling).
- *   BOUND — a resolution structure reflecting the ground truth now connects
- *     the pair: `corrected_by` / `superseded_by` / `conflicts` link, or a
- *     merge (`dedup_log` row). Guard-C added the `conflicts` bind (the judge
- *     flags a genuine conflict instead of leaving it inexpressible).
- *   RESOLVED — the class-specific desired END STATE holds in the store:
- *     corrects  = correction effective (older demoted/absorbed/rewritten) and
- *                 the correction information live;
- *     supersedes= older demoted-or-absorbed and newer live in recall;
- *     merge     = exactly one live row remains, the other absorbed via dedup;
- *     conflict  = both live AND not blended AND the conflicts link exists
- *                 (guard-C's end state — the consumer sees both truths);
- *     none      = both live, not blended, no resolution link between them.
- *
- * The version_chain CLASS end-state is measured on the RECALL surface, not
- * the store (#393 D): a retrieval-only change cannot move a store probe, so
- * post-stage the harness runs the production retrieve() (read-only: limit 3,
- * below the cold-exposure threshold, noStrengthen) with the OLDEST chain
- * member's content as query and requires the belief walk's guarantee — no
- * superseded ancestor surfaces as a competing truth, and the linked chain's
- * terminal surfaces. Store facts (terminal live, non-terminals gone) remain
- * in the class note as corroboration.
- *
- * The judge is a GROUND-TRUTH-STUBBED LlmClient (the refine addendum's Q3
- * recommendation): it answers each planted pair's declared relation and
- * defaults unknown/collider pairs to `none`. This isolates the MACHINERY
- * (detection sources, binding actions, merge guard, walk) from judge quality —
- * the harness answers "would the pipeline resolve a KNOWN correction if the
- * judge were perfect?". Live-LLM verdict quality is the real-corpus soak run.
- *
- * Read/write discipline: the gate NEVER touches ~/.hicortex — the fixture DB
- * and the stage's stateDir are caller-supplied (temp) paths. A real snapshot
- * is only ever PLANTED INTO A COPY (planted-eval.ts --snapshot).
- */
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.plantCorpus = plantCorpus;
-exports.makeGroundTruthJudge = makeGroundTruthJudge;
-exports.runPlantedGate = runPlantedGate;
-exports.renderPlantedReport = renderPlantedReport;
-const node_fs_1 = require("node:fs");
-const retrieval_js_1 = require("../retrieval.js");
-const db_js_1 = require("../db.js");
-const storage = __importStar(require("../storage.js"));
-const consolidate_js_1 = require("../consolidate.js");
-const reconsolidation_js_1 = require("../reconsolidation.js");
-const dedup_js_1 = require("../dedup.js");
-const graph_eval_js_1 = require("./graph-eval.js");
-const planted_fixtures_js_1 = require("./planted-fixtures.js");
-// ---------------------------------------------------------------------------
-// Fixture DB builder
-// ---------------------------------------------------------------------------
-/** Insert the corpus into a writable DB (fresh, or a copy of a snapshot). */
-async function plantCorpus(db, corpus, embedFn) {
-    const idByKey = new Map();
-    for (const row of corpus.rows) {
-        const embedding = await embedFn(row.content);
-        const id = storage.insertMemory(db, row.content, embedding, {
-            sourceAgent: planted_fixtures_js_1.PLANTED_SOURCE_AGENT,
-            project: planted_fixtures_js_1.PLANTED_PROJECT,
-            memoryType: row.memoryType,
-            createdAt: row.createdAt,
-        });
-        idByKey.set(row.key, id);
-    }
-    return idByKey;
-}
-const VERDICT_PROMPT_RE = /OLDER MEMORY:\n([\s\S]*?)\n\nNEWER MEMORY:\n([\s\S]*?)\n\nHow does the NEWER/;
-const REWRITE_PROMPT_RE = /OLDER MEMORY \(currently stored[^)]*\):\n([\s\S]*?)\n\nCORRECTING MEMORIES \(newer[^)]*\):\n([\s\S]*?)\n\nCompose/;
-const SCOUT_PROMPT_RE = /You are scanning a memory that was just added[\s\S]*?MEMORY:\n([\s\S]*?)\n\nDoes this memory correct/;
-/**
- * Deterministic, ground-truth-keyed judge. Parses each prompt back into its
- * (older, newer) contents — the exact texts `buildCorrectionVerdictPrompt` /
- * `buildRewritePrompt` embed — and answers from the corpus's declared
- * relations:
- *   corrects  -> {"action":"corrects","confidence":0.95}   (above the gate)
- *   supersedes-> {"action":"supersedes","confidence":0.9}
- *   merge     -> {"action":"merge","confidence":0.95}      (above the gate)
- *   conflict  -> {"action":"conflicts","confidence":0.9}   (guard-C: flag,
- *                both live, never blended)
- *   none      -> {"action":"none","confidence":0.9}
- * Unknown pairs (colliders, filler cross-pairs) default to none.
- *
- * #393 B: the judge also answers the scout's per-memory shape calls — a
- * memory is correction-shaped iff it is the newer side of a declared
- * corrects/supersedes/conflict pair (declared `references` returned verbatim,
- * throwing if a resolution-shaped pair never declared them; guard-C added
- * `conflict` to the shaped set — two records disagreeing on one quantity
- * share their wording); everything else answers correction=false. Shape calls
- * are logged in scoutCalls.
- */
-function makeGroundTruthJudge(corpus, idByKey) {
-    const keyByContent = new Map();
-    for (const row of corpus.rows)
-        keyByContent.set(row.content, row.key);
-    const pairByKeys = new Map();
-    for (const p of corpus.pairs)
-        pairByKeys.set(`${p.olderKey}|${p.newerKey}`, p);
-    const keyById = new Map([...idByKey.entries()].map(([key, id]) => [id, key]));
-    const verdictCalls = [];
-    const rewriteCalls = [];
-    const scoutCalls = [];
-    const verdictReply = (p) => {
-        switch (p.relation) {
-            case "corrects":
-                return '{"action": "corrects", "confidence": 0.95}';
-            case "supersedes":
-                return '{"action": "supersedes", "confidence": 0.9}';
-            case "merge":
-                return '{"action": "merge", "confidence": 0.95}';
-            case "conflict":
-                return '{"action": "conflicts", "confidence": 0.9}';
-            default:
-                return '{"action": "none", "confidence": 0.9}';
-        }
-    };
-    /**
-     * Ground truth for the scout's shape question: a memory is correction-shaped
-     * iff it is the NEWER side of a declared `corrects`/`supersedes`/`conflict`
-     * pair (guard-C added `conflict` — two records disagreeing on one quantity
-     * share their wording, so the scout's reference extraction finds the old
-     * record exactly like a correction does). `merge`/`none` are
-     * duplicates/additions, not resolutions.
-     */
-    const shapeFor = (key) => {
-        const shaped = corpus.pairs.find((p) => p.newerKey === key &&
-            (p.relation === "corrects" || p.relation === "supersedes" || p.relation === "conflict"));
-        if (!shaped)
-            return { correction: false, references: "" };
-        if (!shaped.references) {
-            throw new Error(`planted-harness: shape call on ${key} (relation ${shaped.relation}) has no declared ` +
-                `references — every corrects/supersedes/conflict pair must declare the old claim's terms`);
-        }
-        return { correction: true, references: shaped.references };
-    };
-    const obj = {
-        verdictCalls,
-        rewriteCalls,
-        scoutCalls,
-        complete: async (prompt) => {
-            const scoutMatch = SCOUT_PROMPT_RE.exec(prompt);
-            if (scoutMatch) {
-                const key = keyByContent.get(scoutMatch[1]) ?? "?";
-                const shape = key === "?" ? { correction: false, references: "" } : shapeFor(key);
-                scoutCalls.push({ key, correction: shape.correction });
-                return {
-                    text: JSON.stringify({
-                        correction: shape.correction,
-                        references: shape.references,
-                        confidence: 0.9,
-                    }),
-                };
-            }
-            const verdictMatch = VERDICT_PROMPT_RE.exec(prompt);
-            if (verdictMatch) {
-                const olderKey = keyByContent.get(verdictMatch[1]);
-                const newerKey = keyByContent.get(verdictMatch[2]);
-                const pair = olderKey !== undefined && newerKey !== undefined
-                    ? pairByKeys.get(`${olderKey}|${newerKey}`)
-                    : undefined;
-                verdictCalls.push({
-                    olderKey: olderKey ?? "?",
-                    newerKey: newerKey ?? "?",
-                    grounded: pair !== undefined,
-                });
-                return { text: pair ? verdictReply(pair) : '{"action": "none", "confidence": 0.9}' };
-            }
-            const rewriteMatch = REWRITE_PROMPT_RE.exec(prompt);
-            if (rewriteMatch) {
-                const targetKey = keyByContent.get(rewriteMatch[1]);
-                const triggerIds = [...rewriteMatch[2].matchAll(/\[([0-9a-f-]{36})\]/g)].map((m) => m[1]);
-                rewriteCalls.push({
-                    targetKey: targetKey ?? "?",
-                    triggerKeys: triggerIds.map((id) => keyById.get(id) ?? "?"),
-                });
-                // The scripted rewrite: the declared `rewritten` of the corrects pair
-                // targeting this row, with every trigger absorbed (the correction
-                // rider is transition-only — the standard disposition).
-                const pair = corpus.pairs.find((p) => p.relation === "corrects" && p.olderKey === targetKey && p.rewritten !== undefined);
-                if (!pair || !pair.rewritten) {
-                    throw new Error(`planted-harness: rewrite prompt for ${targetKey ?? "?"} has no scripted rewritten text — ` +
-                        `every corrects pair must declare one`);
-                }
-                return {
-                    text: JSON.stringify({
-                        rewritten: pair.rewritten,
-                        triggers: triggerIds.map((id) => ({ id, disposition: "absorb" })),
-                    }),
-                };
-            }
-            throw new Error(`planted-harness: unrecognized LLM prompt (neither verdict nor rewrite):\n${prompt.slice(0, 200)}`);
-        },
-    };
-    return { llm: obj, verdictCalls, rewriteCalls, scoutCalls };
-}
-function probe(db, id) {
-    const row = db
-        .prepare("SELECT status, content FROM memories WHERE id = ?")
-        .get(id);
-    if (!row)
-        return null;
-    const hasVector = !!db.prepare("SELECT 1 FROM memory_vectors WHERE id = ?").get(id);
-    return { status: row.status, content: row.content, hasVector };
-}
-/** Absorbed rows are structurally invisible (no vector row). */
-function absorbed(p) {
-    return p === null || p.status === "absorbed" || !p.hasVector;
-}
-/** Live in recall: not absorbed (superseded/retracted rows remain visible, demoted). */
-function liveInRecall(p) {
-    return p !== null && p.status !== "absorbed" && p.hasVector;
-}
-/** Demoted (ranking-penalty status) or fully out of recall. */
-function demotedOrGone(p) {
-    return p === null || p.status === "superseded" || p.status === "retracted" || absorbed(p);
-}
-function linkBetween(db, a, b, relationships) {
-    if (relationships.length === 0)
-        return null;
-    const ph = relationships.map(() => "?").join(",");
-    const row = db
-        .prepare(`SELECT source_id, target_id, relationship FROM memory_links
-       WHERE relationship IN (${ph})
-         AND ((source_id = ? AND target_id = ?) OR (source_id = ? AND target_id = ?))`)
-        .get(...relationships, a, b, b, a);
-    if (!row)
-        return null;
-    return {
-        relationship: row.relationship,
-        direction: row.source_id === a ? "a_to_b" : "b_to_a",
-    };
-}
-function dedupLogBetween(db, a, b) {
-    const row = db
-        .prepare(`SELECT loser_id, canonical_id FROM dedup_log
-       WHERE (loser_id = ? AND canonical_id = ?) OR (loser_id = ? AND canonical_id = ?)`)
-        .get(a, b, b, a);
-    if (!row)
-        return null;
-    return { loserKeyIsA: row.loser_id === a };
-}
-const alwaysAcquire = async () => () => { };
-/** Canonical map key for an unordered row pair. */
-function pairKey(a, b) {
-    return [a, b].sort().join("|");
-}
-/** All rows' measured pairwise cosines (planted corpus only). */
-function measuredCosines(db, corpus, idByKey) {
-    const out = new Map();
-    for (let i = 0; i < corpus.rows.length; i++) {
-        for (let j = i + 1; j < corpus.rows.length; j++) {
-            const a = corpus.rows[i];
-            const b = corpus.rows[j];
-            const va = storage.getStoredEmbedding(db, idByKey.get(a.key) ?? "");
-            const vb = storage.getStoredEmbedding(db, idByKey.get(b.key) ?? "");
-            out.set(pairKey(a.key, b.key), va && vb ? (0, graph_eval_js_1.cosineBetween)(va, vb) : Number.NaN);
-        }
-    }
-    return out;
-}
-/**
- * Build (or plant into) the DB, run the production stage, measure the gate.
- * This is the ONE orchestration shared by the CLI runner and the vitest suite.
- */
-async function runPlantedGate(corpus, opts) {
-    (0, node_fs_1.mkdirSync)(opts.stateDir, { recursive: true });
-    const db = (0, db_js_1.initDb)(opts.dbPath);
-    try {
-        const idByKey = await plantCorpus(db, corpus, opts.embedFn);
-        const keyById = new Map([...idByKey.entries()].map(([k, v]) => [v, k]));
-        // --- pre-stage zone discovery snapshot (detection + blend prediction) ---
-        const threshold = opts.threshold ?? dedup_js_1.DEFAULT_DEDUP_MERGE_THRESHOLD;
-        const zonePlanBefore = (0, dedup_js_1.planDedup)(db, threshold);
-        const zoneClusterKeys = zonePlanBefore.mergePlans.map((p) => {
-            const keys = [...p.membersOldestFirst.map((m) => m.id), ...p.losers.map((l) => l.id)]
-                .map((id) => keyById.get(id))
-                .filter((k) => k !== undefined);
-            return new Set(keys);
-        });
-        const mismatchClusterKeys = zonePlanBefore.mismatchSkipped.map((p) => {
-            const keys = p.memberIds.map((id) => keyById.get(id)).filter((k) => k !== undefined);
-            return new Set(keys);
-        });
-        const blendPredictions = [];
-        for (const p of zonePlanBefore.mergePlans) {
-            const canonicalKey = keyById.get(p.canonical.id);
-            const loserKeys = p.losers.map((l) => keyById.get(l.id)).filter((k) => !!k);
-            if (!canonicalKey)
-                continue;
-            for (const loserKey of loserKeys) {
-                blendPredictions.push({ pair: `${loserKey}+${canonicalKey}`, canonicalKey, loserKey });
-            }
-        }
-        const cosines = measuredCosines(db, corpus, idByKey);
-        const declaredPairs = new Set(corpus.pairs.map((p) => pairKey(p.olderKey, p.newerKey)));
-        // --- run the production stage ---
-        const judge = makeGroundTruthJudge(corpus, idByKey);
-        const budget = new consolidate_js_1.BudgetTracker(1_000_000);
-        const stageReport = await (0, reconsolidation_js_1.stageReconsolidation)(db, judge.llm, budget, opts.embedFn, false, opts.stateDir, { acquireLock: opts.acquireLock ?? alwaysAcquire, autoMergeThreshold: threshold });
-        // --- measure ---
-        const inCluster = (sets, a, b) => sets.some((s) => s.has(a) && s.has(b));
-        const pairResults = corpus.pairs.map((p) => {
-            const olderId = idByKey.get(p.olderKey) ?? "";
-            const newerId = idByKey.get(p.newerKey) ?? "";
-            const cosine = cosines.get(pairKey(p.olderKey, p.newerKey)) ?? Number.NaN;
-            const inBand = Number.isFinite(cosine) && cosine >= p.band[0] && cosine <= p.band[1];
-            const judged = judge.verdictCalls.some((c) => (c.olderKey === p.olderKey && c.newerKey === p.newerKey) ||
-                (c.olderKey === p.newerKey && c.newerKey === p.olderKey));
-            const zoned = inCluster(zoneClusterKeys, p.olderKey, p.newerKey);
-            const mismatched = inCluster(mismatchClusterKeys, p.olderKey, p.newerKey);
-            // #393 B scout attribution: a verdict call on a BELOW-floor pair can
-            // only come from the scout source (the similarity floor structurally
-            // excludes sub-floor pairs before any LLM sees them).
-            const scouted = judged && Number.isFinite(cosine) && cosine < reconsolidation_js_1.DEFAULT_CORRECTION_MIN_SIMILARITY;
-            const detectionSource = scouted && zoned ? "scout+zone"
-                : scouted ? "scout"
-                    : judged && zoned ? "judge+zone"
-                        : judged ? "judge"
-                            : zoned || mismatched ? "zone"
-                                : "";
-            const olderProbe = probe(db, olderId);
-            const newerProbe = probe(db, newerId);
-            const merged = dedupLogBetween(db, olderId, newerId);
-            let bound;
-            let boundHow;
-            switch (p.relation) {
-                case "corrects": {
-                    const link = linkBetween(db, olderId, newerId, ["corrected_by"]);
-                    bound = link !== null;
-                    boundHow = link ? `corrected_by (${link.direction === "a_to_b" ? "older→newer" : "newer→older"})` : "no corrected_by link";
-                    break;
-                }
-                case "supersedes": {
-                    const link = linkBetween(db, olderId, newerId, ["superseded_by"]);
-                    bound = link !== null || merged !== null;
-                    boundHow = link
-                        ? `superseded_by (${link.direction === "a_to_b" ? "older→newer" : "newer→older"})`
-                        : merged
-                            ? "merged via dedup_log (blend, not a chain link)"
-                            : "no superseded_by link";
-                    break;
-                }
-                case "merge": {
-                    bound = merged !== null;
-                    boundHow = merged ? "merged via dedup_log" : "not merged";
-                    break;
-                }
-                case "conflict": {
-                    // Guard-C's bind: the `conflicts` link, either direction.
-                    const link = linkBetween(db, olderId, newerId, ["conflicts"]);
-                    bound = link !== null;
-                    boundHow = link ? "conflicts bind" : "no conflicts link";
-                    break;
-                }
-                default: {
-                    bound = null;
-                    boundHow = "n/a (keep-both relation)";
-                }
-            }
-            let resolved;
-            const notes = [];
-            switch (p.relation) {
-                case "corrects": {
-                    const rewrittenInPlace = olderProbe !== null &&
-                        olderProbe.status === "corrected" &&
-                        olderProbe.content !== (corpus.rows.find((r) => r.key === p.olderKey)?.content ?? "");
-                    const correctionLive = liveInRecall(newerProbe) || rewrittenInPlace;
-                    resolved = (demotedOrGone(olderProbe) || rewrittenInPlace) && correctionLive;
-                    if (!judged && !zoned)
-                        notes.push(`cosine ${cosine.toFixed(3)} below the 0.75 floor — never a candidate`);
-                    if (rewrittenInPlace)
-                        notes.push("older rewritten in place (corrected)");
-                    else if (demotedOrGone(olderProbe))
-                        notes.push("older demoted/absorbed");
-                    else
-                        notes.push("older still active — wrong fact remains recallable");
-                    break;
-                }
-                case "supersedes": {
-                    const olderGone = demotedOrGone(olderProbe);
-                    const newerLive = liveInRecall(newerProbe);
-                    resolved = olderGone && newerLive;
-                    if (merged) {
-                        notes.push(`BLENDED by the deterministic zone (canonical=${merged.loserKeyIsA ? p.newerKey : p.olderKey}) — no supersession chain`);
-                    }
-                    if (!olderGone)
-                        notes.push("older still recallable");
-                    if (!newerLive) {
-                        // Guard-C note: with the zone running last, an absorbed newer side
-                        // was scanned (even judged) before the zone blended it out of
-                        // recall — the parenthetical states the store fact, not the scan.
-                        notes.push(`newer not live in recall${absorbed(newerProbe) ? " (absorbed)" : ""}`);
-                    }
-                    if (resolved && !merged)
-                        notes.push("older demoted, newer live");
-                    break;
-                }
-                case "merge": {
-                    resolved =
-                        merged !== null &&
-                            (liveInRecall(olderProbe) !== liveInRecall(newerProbe)) &&
-                            (absorbed(olderProbe) || absorbed(newerProbe));
-                    notes.push(resolved ? "one live row remains, loser absorbed with audit row" : "pair not merged");
-                    break;
-                }
-                case "conflict": {
-                    const bothLive = liveInRecall(olderProbe) && liveInRecall(newerProbe);
-                    const conflictMarked = bound === true;
-                    resolved = bothLive && !merged && conflictMarked;
-                    if (merged) {
-                        notes.push(`HARM: blended by the deterministic zone (canonical=${merged.loserKeyIsA ? p.newerKey : p.olderKey}) — two live true records destroyed into one`);
-                    }
-                    else if (conflictMarked && bothLive) {
-                        notes.push("both live, conflict-flagged, no blend — the consumer sees both truths");
-                    }
-                    else if (bothLive) {
-                        notes.push("both live but unflagged — silent coexistence, consumer cannot see the conflict");
-                    }
-                    break;
-                }
-                default: {
-                    // none: keep both, untouched
-                    const bothLive = liveInRecall(olderProbe) && liveInRecall(newerProbe);
-                    const linked = linkBetween(db, olderId, newerId, ["corrected_by", "superseded_by", "conflicts"]);
-                    resolved = bothLive && !merged && !linked;
-                    notes.push(resolved ? "both kept live, no link, not merged" : "unexpectedly bound or missing");
-                    break;
-                }
-            }
-            if (mismatched && !zoned)
-                notes.push("zone cluster refused on metadata mismatch (detected, not merged)");
-            if (!inBand)
-                notes.push(`OUT-OF-BAND cosine ${cosine.toFixed(3)} vs declared [${p.band[0]}, ${p.band[1]}]`);
-            return {
-                class: p.class,
-                olderKey: p.olderKey,
-                newerKey: p.newerKey,
-                relation: p.relation,
-                cosine,
-                inBand,
-                detected: detectionSource !== "",
-                detectionSource,
-                bound,
-                boundHow,
-                resolved,
-                notes: notes.join("; "),
-            };
-        });
-        // --- class aggregates ---
-        const byClass = new Map();
-        for (const r of pairResults) {
-            const arr = byClass.get(r.class) ?? [];
-            arr.push(r);
-            byClass.set(r.class, arr);
-        }
-        const classResults = [];
-        for (const [cls, rows] of byClass) {
-            let classResolved;
-            let notes;
-            if (cls === "version_chain") {
-                const members = (0, planted_fixtures_js_1.chainMembers)(corpus);
-                const terminal = members[members.length - 1];
-                const terminalLive = liveInRecall(probe(db, idByKey.get(terminal) ?? ""));
-                const nonTerminalsGone = members
-                    .slice(0, -1)
-                    .every((k) => demotedOrGone(probe(db, idByKey.get(k) ?? "")));
-                // #393 D: the class end-state is measured on the RECALL surface —
-                // the production retrieve(), read-only. limit 3 is deliberately
-                // below the cold-exposure threshold (limit >= 4) and noStrengthen
-                // keeps the probe side-effect-free, so it cannot perturb anything
-                // downstream in this report.
-                const queryContent = corpus.rows.find((r) => r.key === members[0])?.content ?? "";
-                const recall = await (0, retrieval_js_1.retrieve)(db, opts.embedFn, queryContent, {
-                    limit: 3,
-                    noStrengthen: true,
-                    ...(opts.now ? { now: opts.now } : {}), // #458: pinned clock (undefined = live)
-                });
-                // Every surfaced row must be its own walk terminal — no superseded
-                // ancestor competes as a truth — and the linked chain's terminal
-                // (computed with the production helper) must be surfaced.
-                const competing = recall.filter((r) => (0, retrieval_js_1.beliefWalkTerminal)(db, r.id) !== r.id);
-                const walkTerminalId = (0, retrieval_js_1.beliefWalkTerminal)(db, idByKey.get(members[0]) ?? "");
-                const terminalSurfaced = recall.some((r) => r.id === walkTerminalId);
-                classResolved = terminalSurfaced && competing.length === 0;
-                notes =
-                    `terminal ${terminal} live=${terminalLive}; non-terminals demoted/absorbed=${nonTerminalsGone}; ` +
-                        `walk terminal ${keyById.get(walkTerminalId) ?? "?"} surfaced=${terminalSurfaced}; superseded ancestors competing=${competing.length}` +
-                        (terminalLive
-                            ? ""
-                            : `; ground-truth terminal ${terminal} absorbed by the zone blend — the walk terminal is the linked chain's end`);
-            }
-            else {
-                classResolved = rows.every((r) => r.resolved);
-                notes = rows.length === 1 ? (rows[0].resolved ? "pair resolved" : "pair not resolved") : `${rows.filter((r) => r.resolved).length}/${rows.length} pairs resolved`;
-            }
-            classResults.push({
-                class: cls,
-                pairs: rows.length,
-                detected: rows.filter((r) => r.detected).length,
-                bound: rows.filter((r) => r.bound === true).length,
-                resolved: rows.filter((r) => r.resolved).length,
-                classResolved,
-                notes,
-            });
-        }
-        // --- colliders: non-ground-truth pairs at/above 0.70 ---
-        const colliders = [];
-        for (let i = 0; i < corpus.rows.length; i++) {
-            for (let j = i + 1; j < corpus.rows.length; j++) {
-                const a = corpus.rows[i];
-                const b = corpus.rows[j];
-                const sorted = pairKey(a.key, b.key);
-                if (declaredPairs.has(sorted))
-                    continue;
-                const cosine = cosines.get(sorted) ?? Number.NaN;
-                if (!Number.isFinite(cosine) || cosine < 0.7)
-                    continue;
-                const idA = idByKey.get(a.key) ?? "";
-                const idB = idByKey.get(b.key) ?? "";
-                const [olderKey, newerKey] = a.createdAt <= b.createdAt ? [a.key, b.key] : [b.key, a.key];
-                colliders.push({
-                    aKey: a.key,
-                    bKey: b.key,
-                    cosine,
-                    verdictCalled: judge.verdictCalls.some((c) => (c.olderKey === olderKey && c.newerKey === newerKey) ||
-                        (c.olderKey === newerKey && c.newerKey === olderKey)),
-                    merged: dedupLogBetween(db, idA, idB) !== null,
-                    bothLive: liveInRecall(probe(db, idA)) && liveInRecall(probe(db, idB)),
-                });
-            }
-        }
-        return { pairResults, classResults, colliders, stageReport, zonePlanBefore, blendPredictions };
-    }
-    finally {
-        db.close();
-    }
-}
-// ---------------------------------------------------------------------------
-// Report rendering (markdown — issue-comment shaped)
-// ---------------------------------------------------------------------------
-function yn(v) {
-    return v === null ? "n/a" : v ? "YES" : "no";
-}
-function renderPlantedReport(args) {
-    const { result } = args;
-    const L = [];
-    L.push("# Planted-Pairs Resolution Gate (#393 increment A)\n");
-    L.push(`Corpus: ${args.corpusLabel}  \nGenerated: ${args.generatedAt}  \nEmbedder: ${args.embedderLabel}  \n` +
-        `Clock: ${args.clock} (#458)  \n` +
-        `Judge: ground-truth stub (perfect-judge semantics — machinery isolation, per the refine Q3 ruling).  \n` +
-        `Floors: correctionMinSimilarity 0.75 (judged-band floor) · dedupAutoMergeThreshold 0.92 (zone ceiling).\n`);
-    L.push("## Gate — per planted pair\n");
-    L.push("| class | pair | truth | cosine | band | detected | source | bound | resolved | notes |");
-    L.push("|---|---|---|---|---|---|---|---|---|---|");
-    for (const r of result.pairResults) {
-        L.push(`| ${r.class} | ${r.olderKey}→${r.newerKey} | ${r.relation} | ${r.cosine.toFixed(4)} | ` +
-            `${r.inBand ? "in" : "**OUT**"} | ${yn(r.detected)} | ${r.detectionSource || "-"} | ${yn(r.bound)} | ` +
-            `${yn(r.resolved)} | ${r.notes} |`);
-    }
-    L.push("");
-    L.push("## Gate — per class\n");
-    L.push("| class | pairs | detected | bound | resolved | class end-state | notes |");
-    L.push("|---|---|---|---|---|---|---|");
-    for (const c of result.classResults) {
-        L.push(`| ${c.class} | ${c.pairs} | ${c.detected} | ${c.bound} | ${c.resolved} | ${yn(c.classResolved)} | ${c.notes} |`);
-    }
-    L.push("");
-    if (result.colliders.length > 0) {
-        L.push("## Colliders (non-ground-truth pairs >= 0.70 cosine)\n");
-        L.push("| pair | cosine | verdict called | merged | both live |");
-        L.push("|---|---|---|---|---|");
-        for (const c of result.colliders) {
-            L.push(`| ${c.aKey} + ${c.bKey} | ${c.cosine.toFixed(4)} | ${yn(c.verdictCalled)} | ${yn(c.merged)} | ${yn(c.bothLive)} |`);
-        }
-        L.push("");
-    }
-    else {
-        L.push("## Colliders\n\n_(no non-ground-truth pair >= 0.70 cosine)_\n");
-    }
-    if (result.blendPredictions.length > 0) {
-        L.push("## Pre-stage zone-blend predictions (>= 0.92 discovery)\n");
-        for (const b of result.blendPredictions) {
-            L.push(`- ${b.pair} — canonical survives: **${b.canonicalKey}**, loser absorbed: ${b.loserKey}`);
-        }
-        L.push("");
-    }
-    const s = result.stageReport;
-    L.push("## Stage report (production `stageReconsolidation` output)\n");
-    L.push(`- scanned ${s.scanned}, pairs_discovered ${s.pairs_discovered} (unlinked ${s.pairs_discovered_unlinked}), ` +
-        `pairs_evaluated ${s.pairs_evaluated}\n` +
-        `- scout (#393 B): scanned ${s.scout_scanned}, correction_shaped ${s.scout_correction_shaped}, ` +
-        `candidates_found ${s.scout_candidates_found}\n` +
-        `- verdicts applied: rewritten ${s.rewritten} (absorbed ${s.absorbed}, kept ${s.kept_linked}), ` +
-        `marked_superseded ${s.marked_superseded}, marked_retracted ${s.marked_retracted}, ` +
-        `merge_pairs_applied ${s.merge_pairs_applied}\n` +
-        `- conflicts (guard-C): flagged ${s.conflict_flagged}, skipped ${s.conflict_skipped} ` +
-        `(zone clusters + judged merges refused on a conflicts link)\n` +
-        `- zone: clusters_found ${s.merges.clusters_found}, merged ${s.merges.merged_clusters}, ` +
-        `losers_merged ${s.merges.losers_merged}, project_skipped ${s.merges.skipped_project_mismatch}, ` +
-        `conflict_skipped ${s.merges.skipped_conflict}\n` +
-        `- skipped: infra ${s.skipped_infra}, idempotent ${s.skipped_idempotent}, above_ceiling ${s.skipped_above_ceiling}\n`);
-    return L.join("\n");
-}