@tachikomagundam/abathur 0.2.5 → 0.2.6

package/dist/test/score-bank.test.js

@@ -0,0 +1,235 @@
+// Score-bank loader tests (acceptance-semantics redesign, 2026-09-24): the
+// fail-closed activation law, exact shrinkage/quantum-floor arithmetic, row
+// skipping with notices, corrupt-tail/backup exclusion and the gate-time
+// candidate-tree exclusion hook the A9 backtest replays through.
+import assert from "node:assert/strict";
+import { existsSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { describe, it } from "node:test";
+import { BANK_QUANTUM, BANK_THIN_DF, loadScoreBank } from "../core/evolve/score-bank.js";
+const STATE_DIR = path.join(".state", "abathur");
+function generationLine(row) {
+    const data = {
+        source: row.source,
+        ...(row.source === "candidate" ? { candidateId: `c-${row.tree}`, treeSha: row.tree, commitSha: row.tree ?? "c" } : {}),
+        headCommit: row.head,
+        complete: row.complete ?? true,
+        reps: 2,
+        units: row.units.map((u) => ({ ...u, runIds: u.scores.map((_, i) => `r${String(i)}`), failures: [] })),
+        counters: { candidates: row.source === "candidate" ? 1 : 0, modelCalls: 0, tokens: 1, wallS: 1 },
+        manifest: [],
+        benchProvenance: { benchType: "toy", versions: [] },
+    };
+    return `${JSON.stringify({ v: 1, ts: row.ts ?? "2026-09-24T00:00:00.000Z", kind: "generation_complete", genId: "g-1", runId: "a-1", data })}\n`;
+}
+function withRepo(write) {
+    const repo = mkdtempSync(path.join(os.tmpdir(), "abathur-bank-"));
+    try {
+        write(repo);
+    }
+    finally {
+        rmSync(repo, { recursive: true, force: true });
+    }
+}
+function stateDir(repo) {
+    const dir = path.join(repo, STATE_DIR);
+    mkdirSync(dir, { recursive: true });
+    return dir;
+}
+describe("loadScoreBank fail-closed activation", () => {
+    it("no .state dir at all ⇒ null — and the loader never creates one (peekPlanState discipline)", () => {
+        withRepo((repo) => {
+            assert.equal(loadScoreBank(repo), null);
+            assert.equal(existsSync(path.join(repo, STATE_DIR)), false);
+        });
+    });
+    it("live ledger only ⇒ null — rotation is the activation law", () => {
+        withRepo((repo) => {
+            const dir = stateDir(repo);
+            writeFileSync(path.join(dir, "ledger.jsonl"), generationLine({ source: "incumbent", head: "a".repeat(40), units: [{ unitId: "u", split: "train", scores: [0, 2, 1, 3] }] }));
+            assert.equal(loadScoreBank(repo), null);
+        });
+    });
+    it("ledger.corrupt-* is NOT a rotated archive; an empty dir ⇒ null", () => {
+        withRepo((repo) => {
+            const dir = stateDir(repo);
+            writeFileSync(path.join(dir, "ledger.corrupt-20260924-9.jsonl"), generationLine({ source: "incumbent", head: "a".repeat(40), units: [{ unitId: "u", split: "train", scores: [0, 2, 1, 3] }] }));
+            assert.equal(loadScoreBank(repo), null);
+            rmSync(path.join(dir, "ledger.corrupt-20260924-9.jsonl"));
+            writeFileSync(path.join(dir, "notes.txt"), "unrelated");
+            assert.equal(loadScoreBank(repo), null);
+        });
+    });
+    it("archive + live load; totalDf=0 (only single-rep groups ever) ⇒ null", () => {
+        withRepo((repo) => {
+            const dir = stateDir(repo);
+            writeFileSync(path.join(dir, "ledger.campaign1-x.jsonl"), generationLine({ source: "incumbent", head: "a".repeat(40), units: [{ unitId: "u", split: "train", scores: [1] }, { unitId: "v", split: "val", scores: [0.5] }] }));
+            writeFileSync(path.join(dir, "ledger.jsonl"), generationLine({ source: "incumbent", head: "b".repeat(40), units: [{ unitId: "u", split: "train", scores: [2] }] }));
+            assert.equal(loadScoreBank(repo), null);
+        });
+    });
+});
+describe("loadScoreBank arithmetic", () => {
+    const scatterRow = (head, tree, source, scores) => generationLine({ source, head, ...(tree === undefined ? {} : { tree }), units: [{ unitId: "u", split: "train", scores }] });
+    it("pools within-group SS across lineages; thin df floors σ at the quantum; df≥6 keeps the shrunk σ", () => {
+        withRepo((repo) => {
+            const dir = stateDir(repo);
+            // group g1 (campaign1 archive): [0,2] → mean 1, SS 2, df 1 — the ONLY scatter in the bank.
+            writeFileSync(path.join(dir, "ledger.campaign1-x.jsonl"), `${scatterRow("a".repeat(40), undefined, "incumbent", [0, 2])}` +
+                // group g2 (live): same unit, different lineage head, zero scatter
+                scatterRow("b".repeat(40), undefined, "incumbent", [1, 1]));
+            writeFileSync(path.join(dir, "ledger.jsonl"), generationLine({ source: "candidate", head: "b".repeat(40), tree: "t1", units: [{ unitId: "q", split: "train", scores: [1, 1, 1, 1] }] }));
+            const bank = loadScoreBank(repo);
+            assert.ok(bank !== null);
+            // totals: u groups df 1+1 (SS 2+0), q group df 3 (SS 0) ⇒ total df 5, prior σ² = 2/5.
+            assert.equal(bank.totalDf, 5);
+            assert.ok(Math.abs(bank.priorSigma - Math.sqrt(0.4)) < 1e-12);
+            // unit u: σ̂² = 2/2 = 1; shrunk = (2·1 + 2·0.4)/4 = 0.7 ⇒ σ = √0.7 (floor 0.0884 does not bind).
+            const u = bank.units.get("u");
+            assert.ok(u !== undefined);
+            assert.equal(u.df, 2);
+            assert.ok(Math.abs(u.sigma - Math.sqrt(0.7)) < 1e-12, `sigma ${String(u.sigma)}`);
+            // unit q: df 3, zero SS ⇒ shrunk toward the prior: (3·0 + 2·0.4)/5 = 0.16 ⇒ σ = 0.4 > floor.
+            const q = bank.units.get("q");
+            assert.ok(q !== undefined);
+            assert.ok(Math.abs(q.sigma - 0.4) < 1e-12);
+        });
+    });
+    it("zero-scatter bank: thin units sit exactly on BANK_QUANTUM, proven-quiet units (df≥6) on their shrunk σ", () => {
+        withRepo((repo) => {
+            const dir = stateDir(repo);
+            const thin = generationLine({ source: "incumbent", head: "a".repeat(40), units: [{ unitId: "thin", split: "train", scores: [0.5, 0.5] }] });
+            const wide = generationLine({ source: "incumbent", head: "b".repeat(40), units: [{ unitId: "wide", split: "train", scores: [1, 1, 1, 1, 1, 1] }] }) + generationLine({ source: "candidate", head: "b".repeat(40), tree: "x", units: [{ unitId: "wide", split: "train", scores: [1, 1, 1] }] });
+            writeFileSync(path.join(dir, "ledger.campaign1-x.jsonl"), thin + wide);
+            const bank = loadScoreBank(repo);
+            assert.ok(bank !== null);
+            assert.equal(bank.priorSigma, 0);
+            assert.equal(bank.units.get("thin")?.sigma, BANK_QUANTUM); // shrunk 0 → floored
+            assert.equal(bank.units.get("thin")?.df, 1);
+            assert.equal(bank.units.get("wide")?.sigma, 0); // df 4+1+… ≥ BANK_THIN_DF, zero prior ⇒ stays 0
+            assert.ok((bank.units.get("wide")?.df ?? 0) >= BANK_THIN_DF);
+        });
+    });
+});
+describe("loadScoreBank row hygiene", () => {
+    it("corrupt JSON lines and schema-invalid rows are skipped with notices; valid rows still price", () => {
+        withRepo((repo) => {
+            const dir = stateDir(repo);
+            const good = generationLine({ source: "incumbent", head: "a".repeat(40), units: [{ unitId: "u", split: "train", scores: [0, 2, 2, 0] }] });
+            writeFileSync(path.join(dir, "ledger.campaign1-x.jsonl"), `${good}{"v":1,"ts":"x\n${generationLine({ source: "incumbent", head: "a".repeat(40), units: [{ unitId: "bad", split: "nope", scores: [1, 2] }] })}`);
+            const bank = loadScoreBank(repo);
+            assert.ok(bank !== null);
+            assert.ok(bank.units.has("u"));
+            assert.equal(bank.units.has("bad"), false);
+            assert.equal(bank.notices.length, 2);
+            assert.match(bank.notices.join("\n"), /not JSON/);
+            assert.match(bank.notices.join("\n"), /unreadable/);
+        });
+    });
+    it("budget-truncated rows (complete:false) still contribute their real replicate scores", () => {
+        withRepo((repo) => {
+            const dir = stateDir(repo);
+            writeFileSync(path.join(dir, "ledger.campaign1-x.jsonl"), generationLine({ source: "candidate", head: "a".repeat(40), tree: "t", complete: false, units: [{ unitId: "u", split: "train", scores: [0, 2] }] }));
+            const bank = loadScoreBank(repo);
+            assert.equal(bank?.units.get("u")?.df, 1);
+        });
+    });
+    it("excludeCandidateTrees replays the gate-time world (rows written after evaluate)", () => {
+        withRepo((repo) => {
+            const dir = stateDir(repo);
+            writeFileSync(path.join(dir, "ledger.campaign1-x.jsonl"), generationLine({ source: "incumbent", head: "a".repeat(40), units: [{ unitId: "u", split: "train", scores: [0, 2] }] }) +
+                generationLine({ source: "candidate", head: "a".repeat(40), tree: "to-exclude", units: [{ unitId: "u", split: "train", scores: [4, 0] }] }));
+            const withIt = loadScoreBank(repo);
+            const without = loadScoreBank(repo, { excludeCandidateTrees: ["to-exclude"] });
+            assert.equal(withIt?.units.get("u")?.df, 2);
+            assert.equal(without?.units.get("u")?.df, 1);
+            assert.equal(withIt?.totalDf, 2);
+            assert.equal(without?.totalDf, 1);
+        });
+    });
+    it("excludeFiles hides a future campaign's ledger; null once no rotated archive remains", () => {
+        withRepo((repo) => {
+            const dir = stateDir(repo);
+            writeFileSync(path.join(dir, "ledger.campaign1-x.jsonl"), generationLine({ source: "incumbent", head: "a".repeat(40), units: [{ unitId: "u", split: "train", scores: [0, 2, 2, 0] }] }));
+            writeFileSync(path.join(dir, "ledger.campaign2-y.jsonl"), generationLine({ source: "incumbent", head: "b".repeat(40), units: [{ unitId: "u", split: "train", scores: [1, 5] }] }));
+            assert.equal(loadScoreBank(repo)?.units.get("u")?.df, 4);
+            const hidden = loadScoreBank(repo, { excludeFiles: ["ledger.campaign2-y.jsonl"] });
+            assert.equal(hidden?.units.get("u")?.df, 3);
+            assert.equal(hidden?.totalDf, 3);
+            assert.equal(loadScoreBank(repo, { excludeFiles: ["ledger.campaign1-x.jsonl", "ledger.campaign2-y.jsonl"] }), null);
+        });
+    });
+});
+describe("loadScoreBank bank-epoch lineage quarantine", () => {
+    const quietNew = {
+        source: "incumbent",
+        head: "h1",
+        ts: "2026-09-25T00:00:00.000Z",
+        units: [{ unitId: "scenario-9", split: "val", scores: [1, 1] }],
+    };
+    const noisyOld = {
+        source: "incumbent",
+        head: "h1",
+        ts: "2026-09-20T00:00:00.000Z",
+        units: [{ unitId: "scenario-9", split: "val", scores: [0, 1, 0, 1] }],
+    };
+    it("groups with ts before the epoch are quarantined: df drops, notice names the count and why", () => {
+        withRepo((repo) => {
+            const dir = stateDir(repo);
+            writeFileSync(path.join(dir, "ledger.campaign1-2026-09-20.jsonl"), generationLine(noisyOld) + generationLine(quietNew));
+            writeFileSync(path.join(dir, "bank-epoch.json"), JSON.stringify({ "scenario-9": { sinceIso: "2026-09-24T00:00:00Z", why: "pin era voided" } }));
+            const bank = loadScoreBank(repo);
+            assert.ok(bank !== null);
+            const stat = bank.units.get("scenario-9");
+            assert.ok(stat !== undefined);
+            assert.equal(stat.df, 1); // only the quiet new group counts
+            assert.ok(stat.sigma >= BANK_QUANTUM - 1e-12); // thin history floor holds the prior
+            assert.ok(bank.notices.some((n) => n.includes("bank-epoch 'scenario-9' since") && n.includes("1 group(s) quarantined") && n.includes("pin era voided")));
+            assert.ok(bank.notices.some((n) => n.includes("since 2026-09-24T00:00:00Z") && !n.includes("undefined")), "notice must print the ISO epoch, never undefined");
+        });
+    });
+    it("quarantined-only units leave zero pooled df ⇒ bank null ⇒ caller runs the legacy gate", () => {
+        withRepo((repo) => {
+            const dir = stateDir(repo);
+            writeFileSync(path.join(dir, "ledger.campaign1-2026-09-20.jsonl"), generationLine(noisyOld));
+            writeFileSync(path.join(dir, "bank-epoch.json"), JSON.stringify({ "scenario-9": { sinceIso: "2026-09-24T00:00:00Z" } }));
+            assert.equal(loadScoreBank(repo), null);
+        });
+    });
+    it("unreadable row ts fails closed for quarantined units but leaves unruled units untouched", () => {
+        withRepo((repo) => {
+            const dir = stateDir(repo);
+            const ruled = { ...noisyOld, ts: "not-a-date", units: [
+                    { unitId: "scenario-9", split: "val", scores: [0, 1] },
+                    { unitId: "scenario-8", split: "val", scores: [1, 0] },
+                ] };
+            writeFileSync(path.join(dir, "ledger.campaign1-2026-09-20.jsonl"), generationLine(ruled));
+            writeFileSync(path.join(dir, "bank-epoch.json"), JSON.stringify({ "scenario-9": { sinceIso: "2026-09-24T00:00:00Z" } }));
+            const bank = loadScoreBank(repo);
+            assert.ok(bank !== null);
+            assert.equal(bank.units.has("scenario-9"), false); // provably-at-or-after failed ⇒ quarantined
+            assert.ok(bank.units.has("scenario-8")); // no rule ⇒ untouched
+        });
+    });
+    it("malformed quarantine sidecars disable the WHOLE bank (never a silently ignored quarantine)", () => {
+        const bad = ["{not json", JSON.stringify({ "scenario-9": { sinceIso: "not-a-date" } }), JSON.stringify({ "scenario-9": { sinceIso: "2026-09-24T00:00:00Z", extra: 1 } }), JSON.stringify(["scenario-9"])];
+        for (const body of bad) {
+            withRepo((repo) => {
+                const dir = stateDir(repo);
+                writeFileSync(path.join(dir, "ledger.campaign1-2026-09-20.jsonl"), generationLine(noisyOld) + generationLine(quietNew));
+                writeFileSync(path.join(dir, "bank-epoch.json"), body);
+                assert.equal(loadScoreBank(repo), null, `sidecar must disable bank: ${body.slice(0, 24)}`);
+            });
+        }
+    });
+    it("absent sidecar = no quarantine, byte-identical legacy behavior", () => {
+        withRepo((repo) => {
+            const dir = stateDir(repo);
+            writeFileSync(path.join(dir, "ledger.campaign1-2026-09-20.jsonl"), generationLine(noisyOld) + generationLine(quietNew));
+            const bank = loadScoreBank(repo);
+            assert.ok(bank !== null);
+            assert.equal(bank.units.get("scenario-9")?.df, 4); // 3 df old + 1 df new — nothing skipped
+        });
+    });
+});

package/dist/test/seam-gates.test.js

@@ -0,0 +1,78 @@
+// Seam test (postmortem 863e6c2): the human-gate commands `promote` and
+// `tombstone` must resolve an env-literal repoPath exactly like status/run
+// (4997618 pattern). Pre-fix, promote.ts opened the ledger under the STORED
+// UNRESOLVED `${VAR}` literal, read an empty ledger, and reported the
+// misleading "no generation_complete ledger row" with the literal still in
+// the hint — the same fail-open seam class as the status spawn-ENOENT.
+// Pins, for both gates:
+//  (1) env exported ⇒ gate reads the REAL ledger at the resolved path:
+//      the refusal names the resolved repo, never the `${VAR}` literal;
+//  (2) env unset ⇒ clean exit 2 NAMING the variable;
+//  (3) stderr never contains the unresolved literal or a spawn-ENOENT.
+import assert from "node:assert/strict";
+import { spawnSync } from "node:child_process";
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { mkdtempSync, rmSync } from "node:fs";
+import * as os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { test } from "node:test";
+import { registerGenome } from "../core/genome.js";
+import { prepareToyGenome } from "../bench/toy.js";
+const CLI = fileURLToPath(new URL("../../dist/cli.js", import.meta.url));
+const LIT_VAR = "ABATHUR_SEAM_GATES_REPO";
+async function fixture(t, label) {
+    const root = mkdtempSync(path.join(os.tmpdir(), "seam-gates-"));
+    t.after(() => rmSync(root, { recursive: true, force: true }));
+    const configDir = path.join(root, "config");
+    mkdirSync(configDir, { recursive: true });
+    writeFileSync(path.join(configDir, "config.jsonc"), '{ "opencodeBin": null }\n', "utf8");
+    const repo = await prepareToyGenome(path.join(root, "genome"));
+    const doc = JSON.parse(readFileSync(path.join(repo, "genome.jsonc"), "utf8"));
+    doc["label"] = label;
+    doc["repoPath"] = `\${${LIT_VAR}}`;
+    const specFile = path.join(root, "private.jsonc");
+    writeFileSync(specFile, `${JSON.stringify(doc, null, 2)}\n`, "utf8");
+    process.env[LIT_VAR] = repo;
+    try {
+        registerGenome(configDir, specFile);
+    }
+    finally {
+        delete process.env[LIT_VAR];
+    }
+    return { root, configDir, repo, label };
+}
+function cli(f, args, env) {
+    return spawnSync(process.execPath, [CLI, ...args], {
+        env: { ...process.env, ABATHUR_CONFIG: path.join(f.configDir, "config.jsonc"), ...env },
+        encoding: "utf8",
+        timeout: 60_000,
+    });
+}
+function assertNoLiteralOrEnoent(r) {
+    const blob = `${r.stdout}\n${r.stderr}`;
+    assert.ok(!blob.includes(`\${${LIT_VAR}}`), `unresolved literal leaked into output:\n${blob}`);
+    assert.ok(!blob.includes("ENOENT"), `misleading ENOENT leaked into output:\n${blob}`);
+}
+test("promote with env-literal repoPath: exported ⇒ blocked naming the RESOLVED repo path", async (t) => {
+    const f = await fixture(t, "seam-gate-promote");
+    const r = cli(f, ["promote", f.label, "g-nonexistent"], { [LIT_VAR]: f.repo });
+    assert.equal(r.status, 1, `stdout: ${r.stdout}\nstderr: ${r.stderr}`);
+    assertNoLiteralOrEnoent(r);
+    assert.ok(r.stderr.includes(f.repo), `refusal must name the resolved repo path so the operator can debug:\n${r.stderr}`);
+});
+test("tombstone with env-literal repoPath: exported ⇒ blocked, no literal leak", async (t) => {
+    const f = await fixture(t, "seam-gate-tombstone");
+    const r = cli(f, ["tombstone", f.label, "g-nonexistent", "--reason", "seam test"], { [LIT_VAR]: f.repo });
+    assert.equal(r.status, 1, `stdout: ${r.stdout}\nstderr: ${r.stderr}`);
+    assertNoLiteralOrEnoent(r);
+});
+test("promote with env-literal repoPath: unset ⇒ clean exit 2 naming the variable", async (t) => {
+    const f = await fixture(t, "seam-gate-promote-unset");
+    const env = {};
+    env[LIT_VAR] = undefined;
+    const r = cli(f, ["promote", f.label, "g-nonexistent"], env);
+    assert.equal(r.status, 2, `stdout: ${r.stdout}\nstderr: ${r.stderr}`);
+    assert.ok(r.stderr.includes(LIT_VAR), `exit-2 message must name the env var:\n${r.stderr}`);
+    assert.ok(!r.stderr.includes("ENOENT"), `misleading ENOENT leaked into output:\n${r.stderr}`);
+});

package/dist/test/stats-acceptance.test.js

@@ -0,0 +1,329 @@
+// Acceptance-semantics evaluate() tests (2026-09-24 redesign). Thresholds
+// mirror the LIVE historian genome: halfWidth 0.15, minEffect 0.1. Bank σ
+// values are the real campaign-10 gate-time bank (§2.3 of
+// .omo/evidence/ACCEPTANCE-SEMANTICS-DESIGN.md); expected probabilities are
+// from the independent python design-time replication (math.erf), asserted to
+// 2e-5 — well above the A&S normalCdf error (< 1.5e-7) and far below any
+// decision-relevant margin.
+//
+// Coverage law: every new branch (acceptance band, regression veto, point-mass
+// se=0 branches, per-unit legacy fallback, aggregate P-gate, pool-incomplete
+// legacy point-gain, q_pair tightening) plus the fail-closed law RE-PROVEN
+// WITH A BANK PRESENT (budget/one-sided/exclusion cannot be bypassed).
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import { ACCEPT_Q, aggregateScore, bonferroniQ, evaluate, normalCdf, studentTQuantile, } from "../core/stats.js";
+import { BANK_QUANTUM } from "../core/evolve/score-bank.js";
+const HIST_STATS = { halfWidth: 0.15, minEffect: 0.1, nReps: { initial: 2, max: 3 } };
+const CAPS = { maxCandidates: 1, maxModelCalls: 96, maxTokens: 25_000_000, maxWallS: 16_200 };
+const IDLE = { candidates: 0, modelCalls: 0, tokens: 1_000_000, wallS: 11_154 };
+/** Gate-time c10 bank: σ values from the real archive pool (python replication). */
+const HIST_BANK = new Map([
+    ["scenario-13", { sigma: 0.0170, df: 12 }],
+    ["scenario-14", { sigma: 0.0176, df: 11 }],
+    ["scenario-15", { sigma: 0.0884, df: 4 }],
+    ["scenario-16", { sigma: 0.1053, df: 4 }],
+    ["scenario-18", { sigma: 0.1113, df: 4 }],
+    ["scenario-19", { sigma: 0.0884, df: 2 }],
+]);
+function units(specs) {
+    return specs.map(([unitId, split, scores]) => ({ unitId, split, scores }));
+}
+const C10_INCUMBENT = units([
+    ["scenario-19", "train", [0.5, 0.5]],
+    ["scenario-13", "val", [1, 1]],
+    ["scenario-14", "val", [1, 1]],
+    ["scenario-15", "val", [1, 1]],
+    ["scenario-16", "val", [1, 1]],
+    ["scenario-18", "val", [0.75, 1]],
+]);
+function c10Candidate(s19, s16 = [0.75, 1], s18 = [1, 0.75]) {
+    return {
+        runId: "backtest",
+        counters: IDLE,
+        units: units([
+            ["scenario-19", "train", s19],
+            ["scenario-13", "val", [1, 1]],
+            ["scenario-14", "val", [1, 1]],
+            ["scenario-15", "val", [1, 1]],
+            ["scenario-16", "val", s16],
+            ["scenario-18", "val", s18],
+        ]),
+    };
+}
+function inc(unitsList) {
+    return { units: unitsList };
+}
+function runAccept(candidate, incumbentUnits = C10_INCUMBENT, bank = HIST_BANK, nPairs = 1) {
+    return evaluate({ candidate, incumbent: inc(incumbentUnits), stats: HIST_STATS, budgetCaps: CAPS, nPairs, ...(bank === undefined ? {} : { bank }) });
+}
+const close = (actual, expected, msg) => {
+    assert.ok(Math.abs(actual - expected) < 2e-5, `${msg ?? ""} actual=${String(actual)} expected=${String(expected)}`);
+};
+// ---------------------------------------------------------------------------
+// The four mandated backtests, as unit-pinned replicas of the real replays.
+// ---------------------------------------------------------------------------
+describe("acceptance gate — campaign replays", () => {
+    it("C10 REAL stays CULLED: gain floor AND P=0.5000; the s16 noise dip is TOLERATED, not CI-fatal", () => {
+        const v = runAccept(c10Candidate([0.5, 0.5]));
+        assert.equal(v.verdict, "culled");
+        assert.equal(v.exitCode, 1);
+        assert.equal(v.gain, 0);
+        assert.ok(v.acceptance !== undefined);
+        close(v.acceptance.pShift ?? Number.NaN, 0.5, "pShift");
+        assert.ok(v.failures.some((f) => f === "gain 0.0000 < minEffect 0.1000"));
+        assert.ok(v.failures.some((f) => f.includes("P(gain shift > 0) = 0.5000 < q 0.9000")));
+        assert.ok(!v.failures.some((f) => f.includes("CI half-width") || f.includes("acceptance band")), v.failures.join("\n"));
+        const s16 = v.unitComparisons.find((u) => u.unitId === "scenario-16");
+        assert.ok(s16 !== undefined);
+        assert.equal(s16.passes, true, "one 0.125 step inside the 0.15 guard tolerance is noise, not regression");
+        assert.equal(s16.ciPasses, true);
+        const report16 = v.acceptance.units.find((u) => u.unitId === "scenario-16");
+        assert.ok(report16 !== undefined);
+        close(report16.pRegression, 0.40617, "P(regress) for the dip");
+    });
+    it("C9 REAL stays CULLED: negative point gain and P(Δ>0)≈0.046", () => {
+        const c9Inc = units([
+            ["scenario-18", "train", [0.875, 1]],
+            ["scenario-13", "val", [1, 1]],
+            ["scenario-14", "val", [1, 1]],
+            ["scenario-15", "val", [1, 1]],
+            ["scenario-16", "val", [1, 1]],
+        ]);
+        const c9Cand = units([
+            ["scenario-18", "train", [0.75, 0.75]],
+            ["scenario-13", "val", [1, 1]],
+            ["scenario-14", "val", [1, 1]],
+            ["scenario-15", "val", [1, 1]],
+            ["scenario-16", "val", [1, 0.75]],
+        ]);
+        const v = runAccept({ runId: "c9", counters: IDLE, units: c9Cand }, c9Inc);
+        assert.equal(v.verdict, "culled");
+        close(v.gain ?? Number.NaN, -0.1875);
+        const se = 0.1113;
+        close(v.acceptance?.pShift ?? Number.NaN, normalCdf(-0.1875 / se), "pShift");
+        assert.ok((v.acceptance?.pShift ?? 1) < 0.05);
+    });
+    it("SYNTH A (+0.25 true shift): NOMINATED at P≈0.9977 with the same guards (incl. the s16 dip)", () => {
+        const v = runAccept(c10Candidate([0.75, 0.75]));
+        assert.equal(v.verdict, "nominated");
+        assert.equal(v.exitCode, 0);
+        close(v.gain ?? Number.NaN, 0.25);
+        close(v.acceptance?.pShift ?? Number.NaN, 0.99766, "pShift");
+        assert.equal(v.acceptance?.q, ACCEPT_Q);
+        assert.ok(v.failures.length === 0, v.failures.join("\n"));
+    });
+    it("SYNTH B (+0.05 band-mean draw): CULLED twice — gain 0.0625 < 0.1 and P≈0.7602", () => {
+        const v = runAccept(c10Candidate([0.625, 0.5]));
+        assert.equal(v.verdict, "culled");
+        assert.ok(v.failures.some((f) => f.includes("gain 0.0625 < minEffect 0.1000")));
+        assert.ok(v.failures.some((f) => f.includes("P(gain shift > 0) = 0.7602")));
+    });
+    it("documented leak SYNTH B′ (+0.05 lucky [0.625,0.625]): nominates at P≈0.9214 alone, culled at nPairs=2 (q=0.95)", () => {
+        const solo = runAccept(c10Candidate([0.625, 0.625]));
+        assert.equal(solo.verdict, "nominated");
+        close(solo.acceptance?.pShift ?? Number.NaN, 0.92132, "pShift");
+        const pair = runAccept(c10Candidate([0.625, 0.625]), C10_INCUMBENT, HIST_BANK, 2);
+        assert.equal(pair.verdict, "culled");
+        assert.equal(pair.acceptance?.q, 0.95);
+        assert.ok(pair.failures.some((f) => f.includes("= 0.9213 < q 0.9500")), pair.failures.join("\n"));
+    });
+});
+// ---------------------------------------------------------------------------
+// Branch pins: each failure line and fallback edge of the new code.
+// ---------------------------------------------------------------------------
+describe("acceptance gate — branches", () => {
+    it("gain ≥ minEffect with a loud point but weak P (σ=0.1113): P=0.8694 line fires, gain line absent", () => {
+        const bank = new Map([["t", { sigma: 0.1113, df: 4 }]]);
+        const v = evaluate({
+            candidate: { runId: "c", counters: IDLE, units: units([["t", "train", [0.625, 0.625]]]) },
+            incumbent: inc(units([["t", "train", [0.5, 0.5]]])),
+            stats: { ...HIST_STATS, halfWidth: 1 },
+            budgetCaps: CAPS,
+            nPairs: 1,
+            bank,
+        });
+        assert.equal(v.verdict, "culled");
+        assert.equal(v.failures.length, 1, v.failures.join("\n"));
+        assert.ok(v.failures[0]?.includes("0.8693 < q 0.9000"), v.failures[0]);
+    });
+    it("point gain under floor with a confident P: only the legacy gain line fires", () => {
+        const bank = new Map([["t", { sigma: 0.017, df: 12 }]]);
+        const v = evaluate({
+            candidate: { runId: "c", counters: IDLE, units: units([["t", "train", [0.55, 0.6]]]) },
+            incumbent: inc(units([["t", "train", [0.5, 0.5]]])),
+            stats: { ...HIST_STATS, halfWidth: 1 },
+            budgetCaps: CAPS,
+            nPairs: 1,
+            bank,
+        });
+        assert.equal(v.verdict, "culled");
+        assert.deepEqual(v.failures, ["gain 0.0750 < minEffect 0.1000"]);
+        assert.ok((v.acceptance?.pShift ?? 0) > 0.99);
+    });
+    it("hard guard regression vetoes: P(Δ ≤ −0.15)≈1 on a quiet bank unit", () => {
+        const bank = new Map([
+            ["v", { sigma: 0.02, df: 8 }],
+            ["t", { sigma: 0.017, df: 12 }],
+        ]);
+        const v = evaluate({
+            candidate: { runId: "c", counters: IDLE, units: units([["v", "val", [0.75, 0.75]], ["t", "train", [1, 1]]]) },
+            incumbent: inc(units([["v", "val", [1, 1]], ["t", "train", [1, 1]]])),
+            stats: HIST_STATS,
+            budgetCaps: CAPS,
+            nPairs: 1,
+            bank,
+        });
+        assert.equal(v.verdict, "culled");
+        assert.ok(v.failures.some((f) => f.startsWith("regression on unit 'v'") && f.includes("≥ q 0.9000")), v.failures.join("\n"));
+        assert.equal(v.unitComparisons.find((u) => u.unitId === "v")?.passes, false);
+    });
+    it("acceptance band breach: big bank σ ⇒ band 0.2718 > halfWidth culls even with zero delta", () => {
+        const bank = new Map([["v", { sigma: 0.3, df: 10 }], ["t", { sigma: 0.017, df: 12 }]]);
+        const v = evaluate({
+            candidate: { runId: "c", counters: IDLE, units: units([["v", "val", [1, 1]], ["t", "train", [1, 1]]]) },
+            incumbent: inc(units([["v", "val", [1, 1]], ["t", "train", [1, 1]]])),
+            stats: HIST_STATS,
+            budgetCaps: CAPS,
+            nPairs: 1,
+            bank,
+        });
+        assert.equal(v.verdict, "culled");
+        assert.ok(v.failures.some((f) => f.includes("acceptance band 0.2719 > halfWidth 0.1500 on unit 'v'")), v.failures.join("\n"));
+    });
+    it("banked val unit with NO history for the bank runs the exact legacy t-CI line — the 1.5883 absurdity survives only on this fallback path", () => {
+        const bank = new Map([["scenario-13", { sigma: 0.017, df: 12 }]]);
+        const v = runAccept(c10Candidate([0.5, 0.5], [0.75, 1]), C10_INCUMBENT, bank);
+        const expectedHalfWidth = studentTQuantile(0.05, 1) * 0.125;
+        assert.ok(Math.abs(expectedHalfWidth - 1.5883) < 1e-4, "design-time arithmetic");
+        assert.ok(v.failures.some((f) => f === `CI half-width ${expectedHalfWidth.toFixed(4)} > halfWidth 0.1500 on unit 'scenario-16'`), v.failures.join("\n"));
+        assert.ok(v.acceptance !== undefined);
+        assert.equal(v.acceptance.units.find((u) => u.unitId === "scenario-16"), undefined);
+    });
+    it("partial bank: train pool unpriced ⇒ aggregate falls back to the legacy point-gain gate; nomination still requires gain ≥ minEffect", () => {
+        const partial = new Map([...HIST_BANK].filter(([id]) => id !== "scenario-19"));
+        const weak = runAccept(c10Candidate([0.625, 0.5]), C10_INCUMBENT, partial);
+        assert.equal(weak.verdict, "culled");
+        assert.ok(weak.failures.some((f) => f.includes("gain 0.0625 < minEffect 0.1000")));
+        assert.equal(weak.acceptance?.pShift, null);
+        assert.equal(weak.acceptance?.gainSe, null);
+        const strong = runAccept(c10Candidate([0.75, 0.75]), C10_INCUMBENT, partial);
+        assert.equal(strong.verdict, "nominated", "cold-start gate-time bank (no s19 rows yet) still accepts the +0.25 class via the legacy point gate");
+        assert.equal(strong.acceptance?.pShift, null);
+    });
+});
+// ---------------------------------------------------------------------------
+// Fail-closed law RE-PROVEN with a bank present — the bank never bypasses it.
+// ---------------------------------------------------------------------------
+describe("fail-closed law under an acceptance bank", () => {
+    it("budget exhaustion ⇒ inconclusive (gain null, no comparisons, no acceptance math)", () => {
+        const v = runAccept({ ...c10Candidate([0.75, 0.75]), counters: { ...IDLE, wallS: 16_200 } });
+        assert.equal(v.verdict, "inconclusive");
+        assert.equal(v.exitCode, 2);
+        assert.equal(v.gain, null);
+        assert.deepEqual(v.unitComparisons, []);
+        assert.ok(v.failures.some((f) => f.includes("budget exhausted: wallS")));
+    });
+    it("one-sided n<2 ⇒ indeterminate even when the bank knows the unit", () => {
+        const oneSided = units([
+            ["scenario-19", "train", [0.75, 0.75]],
+            ["scenario-13", "val", [1, 1]],
+            ["scenario-14", "val", [1, 1]],
+            ["scenario-15", "val", [1, 1]],
+            ["scenario-16", "val", [1, 1]],
+            ["scenario-18", "val", [1]],
+        ]);
+        const v = runAccept({ runId: "c", counters: IDLE, units: oneSided });
+        assert.equal(v.verdict, "indeterminate");
+        assert.equal(v.exitCode, 1);
+        assert.equal(v.gain, null);
+        assert.ok(v.failures.some((f) => f.includes("scenario-18") && f.includes("variance undefined")));
+    });
+    it("both-unmeasured ⇒ symmetric exclusion: dropped from comparisons, acceptance reports and the gain pool alike", () => {
+        const withGhost = units([["ghost", "val", []], ...C10_INCUMBENT.map((u) => [u.unitId, u.split, [...u.scores]])]);
+        const cand = c10Candidate([0.75, 0.75]);
+        const v = runAccept({ ...cand, units: [{ unitId: "ghost", split: "val", scores: [] }, ...cand.units] }, withGhost);
+        assert.equal(v.verdict, "nominated");
+        assert.ok(v.unitComparisons.every((u) => u.unitId !== "ghost"));
+        assert.ok(v.acceptance !== undefined && v.acceptance.units.every((u) => u.unitId !== "ghost"));
+        close(aggregateScore(withGhost.filter((u) => u.unitId !== "ghost")), aggregateScore(C10_INCUMBENT));
+    });
+    it("no reroll: evaluate is deterministic — identical inputs produce identical verdicts and acceptance numbers", () => {
+        const a = runAccept(c10Candidate([0.75, 0.75]));
+        const b = runAccept(c10Candidate([0.75, 0.75]));
+        assert.deepEqual(a, b);
+    });
+    it("absent/null bank reproduces the legacy gate verbatim; the whole verdict object is unchanged", () => {
+        const legacy = evaluate({ candidate: c10Candidate([0.5, 0.5]), incumbent: inc(C10_INCUMBENT), stats: HIST_STATS, budgetCaps: CAPS, nPairs: 1 });
+        const nulled = runAccept(c10Candidate([0.5, 0.5]), C10_INCUMBENT, null);
+        assert.deepEqual(nulled, legacy);
+        assert.equal(legacy.acceptance, undefined);
+        assert.equal(legacy.verdict, "culled");
+        assert.ok(legacy.failures.some((f) => f.includes("CI half-width 1.5883")), "the campaign-10 legacy cull carried the absurd half-width line");
+        const banked = runAccept(c10Candidate([0.5, 0.5]));
+        assert.equal(banked.verdict, "culled");
+        assert.ok(!banked.failures.some((f) => f.includes("CI half-width")), "acceptance path prices the dip instead of tripping on df=1 t");
+    });
+    it("point mass σ=0: se=0 branch — exact tie gives P=0 (no nomination on demonstrated-identical arms), a 0.25 guard drop vetoes at P=1, a 0.125 dip inside tolerance passes", () => {
+        const bank = new Map([
+            ["v", { sigma: 0, df: 10 }],
+            ["t", { sigma: 0, df: 10 }],
+        ]);
+        const tie = evaluate({
+            candidate: { runId: "c", counters: IDLE, units: units([["v", "val", [1, 1]], ["t", "train", [1, 1]]]) },
+            incumbent: inc(units([["v", "val", [1, 1]], ["t", "train", [1, 1]]])),
+            stats: HIST_STATS,
+            budgetCaps: CAPS,
+            nPairs: 1,
+            bank,
+        });
+        assert.equal(tie.verdict, "culled");
+        assert.equal(tie.acceptance?.pShift, 0);
+        assert.equal(tie.acceptance?.gainSe, 0);
+        const hard = evaluate({
+            candidate: { runId: "c", counters: IDLE, units: units([["v", "val", [0.75, 0.75]], ["t", "train", [1.3, 1.3]]]) },
+            incumbent: inc(units([["v", "val", [1, 1]], ["t", "train", [1, 1]]])),
+            stats: HIST_STATS,
+            budgetCaps: CAPS,
+            nPairs: 1,
+            bank,
+        });
+        assert.equal(hard.verdict, "culled");
+        assert.ok(hard.failures.some((f) => f.startsWith("regression on unit 'v'") && f.includes("= 1.0000")));
+        const dip = evaluate({
+            candidate: { runId: "c", counters: IDLE, units: units([["v", "val", [0.875, 0.875]], ["t", "train", [1.3, 1.3]]]) },
+            incumbent: inc(units([["v", "val", [1, 1]], ["t", "train", [1, 1]]])),
+            stats: HIST_STATS,
+            budgetCaps: CAPS,
+            nPairs: 1,
+            bank,
+        });
+        assert.equal(dip.verdict, "nominated", "−0.125 sits inside the 0.15 guard tolerance — the anchor semantics");
+    });
+});
+describe("acceptance constants + normal math", () => {
+    it("ACCEPT_Q is 0.9 and bonferroniQ tightens it per pair, capped", () => {
+        assert.equal(ACCEPT_Q, 0.9);
+        assert.equal(bonferroniQ(1), 0.9);
+        close(bonferroniQ(2), 0.95);
+        close(bonferroniQ(10), 0.99);
+        assert.equal(bonferroniQ(10_000), 0.9999);
+        assert.throws(() => bonferroniQ(0), RangeError);
+        assert.throws(() => bonferroniQ(1.5), RangeError);
+    });
+    it("normalCdf matches the tables and the quantile inverts it", () => {
+        close(normalCdf(0), 0.5);
+        close(normalCdf(1.2815515655446004), 0.9);
+        close(normalCdf(-1.6448536269514722), 0.05);
+        assert.equal(normalCdf(Number.POSITIVE_INFINITY), 1);
+        assert.equal(normalCdf(Number.NEGATIVE_INFINITY), 0);
+        assert.ok(Number.isNaN(normalCdf(Number.NaN)));
+        for (const x of [-3, -1.28, 0, 0.7, 2.83]) {
+            assert.ok(Math.abs(normalCdf(x) - (x < 0 ? 1 - normalCdf(-x) : normalCdf(x))) < 1e-12, "symmetry sanity");
+        }
+    });
+    it("the bank quantum is 0.0884 — one flipped 1/8-grid item between two reps", () => {
+        close(BANK_QUANTUM, 0.0884);
+        assert.ok(Math.abs(BANK_QUANTUM - 0.125 / Math.SQRT2) < 1e-12);
+    });
+});