@tachikomagundam/abathur 0.2.4 → 0.2.6

package/dist/test/historian-grader-io.test.js

@@ -215,6 +215,7 @@ function integrityFixturesReady() {
     return (existsSync(path.join(FIXDIR, "scenario-10", "state-donothing.json")) &&
         existsSync(path.join(FIXDIR, "scenario-11", "state-fabricate.json")) &&
         existsSync(path.join(FIXDIR, "scenario-12", "seed-state.json")) &&
+        existsSync(path.join(FIXDIR, "scenario-13", "seed-state.json")) &&
         existsSync(path.join(HISTORIAN_REPO, "scenarios", "10-status-contradiction-audit.md")));
 }
 const integritySkip = integrityFixturesReady()
@@ -232,6 +233,9 @@ const INTEGRITY_CASES = [
     { unit: "scenario-12", scenarioRel: "scenarios/12-desc-junk-detection.md", shape: "pass", score: 1, pass: true, total: 6, weight: 6, dims: { G: 1, H: 1, I: 1, J: 1 } },
     { unit: "scenario-12", scenarioRel: "scenarios/12-desc-junk-detection.md", shape: "fail", score: 2 / 6, pass: false, total: 2, weight: 6, dims: { G: 1, H: 1, I: 0, J: 0 } },
     { unit: "scenario-12", scenarioRel: "scenarios/12-desc-junk-detection.md", shape: "donothing", score: 2 / 6, pass: false, total: 2, weight: 6, dims: { G: 1, H: 1, I: 0, J: 0 } },
+    { unit: "scenario-13", scenarioRel: "scenarios/13-translation-honesty-audit.md", shape: "pass", score: 1, pass: true, total: 8, weight: 8, dims: { D: 1, G: 1, H: 1, I: 1, J: 1 } },
+    { unit: "scenario-13", scenarioRel: "scenarios/13-translation-honesty-audit.md", shape: "fail", score: 0, pass: false, total: 0, weight: 8, dims: { D: 0, G: 0, H: 0, I: 0, J: 0 } },
+    { unit: "scenario-13", scenarioRel: "scenarios/13-translation-honesty-audit.md", shape: "donothing", score: 3 / 8, pass: false, total: 3, weight: 8, dims: { D: 1, G: 1, H: 0, I: 0, J: 0 } },
 ];
 function integritySandbox(unit, shape) {
     const fix = path.join(FIXDIR, unit);

package/dist/test/historian-run-scenario.test.js

@@ -42,6 +42,9 @@ const STUB_OPENCODE = `#!/usr/bin/env node
 // transcript on stdout (run-scenario.sh redirects it to $ABATHUR_TRANSCRIPT).
 // The finalMessage is the prompt echoed back — so a planted instruction in the
 // brief provably flows into the transcript.
+// STUB_BANNER=1 / STUB_JUNK=1 reproduce campaign-1's channel contamination:
+// a plugin startup banner / an arbitrary non-JSON line printed to stdout
+// BEFORE the JSONL. Default off ⇒ clean output stays byte-identical.
 import { writeFileSync } from "node:fs";
 const args = process.argv.slice(2);
 const i = args.indexOf("--message");
@@ -51,6 +54,9 @@ if (capture !== undefined && capture.length > 0) writeFileSync(capture, message,
 const argvCapture = process.env.STUB_ARGV_FILE;
 if (argvCapture !== undefined && argvCapture.length > 0) writeFileSync(argvCapture, args.join("\\n") + "\\n", "utf8");
 const out = (doc) => process.stdout.write(JSON.stringify(doc) + "\\n");
+if (process.env.STUB_BANNER === "1") out0("[persistence-watchdog] tier=R armed grace=2500ms minOutput=100 alerts=/tmp/abathur-test-alerts.log");
+if (process.env.STUB_JUNK === "1") out0("this line is not json at all");
+function out0(line) { process.stdout.write(line + "\\n"); }
 out({ type: "step_start", part: { type: "step-start" } });
 out({ type: "step_finish", part: { type: "step-finish", reason: "stop", tokens: { total: 42 } } });
 out({ type: "text", part: { type: "text", text: message } });
@@ -182,12 +188,12 @@ test("model pin: ABATHUR_AGENT_MODEL set ⇒ argv carries --model <value>, brief
     const argvFile = path.join(path.dirname(h.promptFile), "argv-pinned.txt");
     await runScenario(h, {
         argvFile,
-        env: { ABATHUR_AGENT_MODEL: "testprov/testmodel" },
+        env: { ABATHUR_AGENT_MODEL: "test-provider/test-model" },
     });
     const tokens = argvTokens(argvFile);
     const i = tokens.indexOf("--model");
     assert.notEqual(i, -1, `--model missing from argv: ${JSON.stringify(tokens)}`);
-    assert.equal(tokens[i + 1], "testprov/testmodel");
+    assert.equal(tokens[i + 1], "test-provider/test-model");
     assert.equal(tokens.at(-2), "--message", "pin must not disturb the brief channel");
     assert.equal(prompt(h), BRIEF_TEXT);
 });
@@ -203,3 +209,37 @@ test("model pin: ABATHUR_AGENT_MODEL empty string ⇒ treated as unset (same arg
     await runScenario(h, { argvFile, env: { ABATHUR_AGENT_MODEL: "" } });
     assert.deepEqual(argvTokens(argvFile), BASELINE_ARGV);
 });
+// Channel contamination (campaign-1 root cause, historian evidence
+// task-07-launch-blockers.md): the user's global persistence-watchdog plugin
+// prints `[persistence-watchdog] tier=R armed …` to the agent's STDOUT — into
+// the captured transcript — contaminating 6/8 candidate transcripts while the
+// incumbent bench (pre-plugin) stayed clean. Contract of the fix: strip ONLY
+// that known banner line; keep a verbatim `.raw` audit copy; unknown non-JSON
+// lines must SURVIVE (the grader's corruption fail-closed stays honest); and a
+// clean stream must pass through byte-identical (F1 invariant).
+test("banner-strip: watchdog banner removed from transcript, .raw keeps it verbatim, grader-view parses", async (t) => {
+    const h = harness(t);
+    await runScenario(h, { env: { STUB_BANNER: "1" } });
+    const text = readFileSync(h.transcript, "utf8");
+    assert.ok(!text.includes("[persistence-watchdog]"), "banner must not reach the grader-facing transcript");
+    for (const line of text.split("\n")) {
+        if (line.length > 0)
+            assert.doesNotThrow(() => JSON.parse(line), `grader-facing line is not JSON: ${line}`);
+    }
+    const raw = readFileSync(`${h.transcript}.raw`, "utf8");
+    assert.ok(raw.startsWith("[persistence-watchdog] tier=R armed"), "raw audit copy preserves the banner verbatim");
+    const meta = parseTranscript(text);
+    assert.equal(meta.finalMessage, BRIEF_TEXT, "the stripped transcript must still yield the delivery truth");
+});
+test("banner-strip: clean stream ⇒ transcript byte-identical to raw (F1 invariant)", async (t) => {
+    const h = harness(t);
+    await runScenario(h);
+    assert.equal(readFileSync(h.transcript, "utf8"), readFileSync(`${h.transcript}.raw`, "utf8"));
+});
+test("banner-strip: UNKNOWN non-JSON lines are NOT stripped (grader fail-closed preserved)", async (t) => {
+    const h = harness(t);
+    await runScenario(h, { env: { STUB_JUNK: "1" } });
+    const text = readFileSync(h.transcript, "utf8");
+    assert.ok(text.includes("this line is not json at all"), "never silently launder unknown corruption");
+    assert.throws(() => parseTranscript(text), /transcript line is not JSON/);
+});

package/dist/test/repopath-seams.test.js

@@ -0,0 +1,54 @@
+// Tripwire (postmortem 863e6c2): the env-literal repoPath defect class was
+// caused by per-call-site resolution being a CONVENTION — every new FS
+// consumer had to remember to call effectiveRepoPath, and promote/tombstone
+// forgot for 18 days. This test makes the convention mechanical: any line
+// on the command/human-gate surface that touches `spec.repoPath` must either
+// resolve it through effectiveRepoPath(...) on the same line, or carry an
+// inline waiver comment `raw-repoPath: <reason>` documenting WHY the raw
+// stored form is correct there (display strings, self-mode literal
+// detection, post-swap pipeline paths). A new command that forgets now
+// fails CI instead of failing a human gate 18 days later.
+//
+// Scope note: engine-internal pipeline modules (src/core/evolve/**,
+// src/core/graft*.ts, src/core/bundle-*.ts, src/bench/**) operate on
+// candidate-worktree-swapped absolute paths by design (run-loop.ts swaps
+// spec.repoPath before invoking them) and are out of scope here; the ledger
+// FS seam additionally resolves unconditionally in ledgerPath().
+import assert from "node:assert/strict";
+import { readdirSync, readFileSync, statSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { test } from "node:test";
+// dist/test/*.js -> repo src/ (tests run from the built tree but guard SOURCE).
+const SRC = fileURLToPath(new URL("../../src/", import.meta.url));
+const GUARDED_FILES = [
+    ...readdirSync(path.join(SRC, "commands"))
+        .filter((f) => f.endsWith(".ts"))
+        .map((f) => path.join(SRC, "commands", f)),
+    path.join(SRC, "core", "promote.ts"),
+    path.join(SRC, "core", "tombstone.ts"),
+];
+function collectHits(file) {
+    const hits = [];
+    const lines = readFileSync(file, "utf8").split("\n");
+    lines.forEach((line, i) => {
+        if (!line.includes("spec.repoPath"))
+            return;
+        if (line.includes("effectiveRepoPath("))
+            return;
+        if (line.includes("raw-repoPath:"))
+            return;
+        hits.push(`${path.relative(SRC, file)}:${String(i + 1)}: ${line.trim()}`);
+    });
+    return hits;
+}
+test("command/gate surface: every spec.repoPath use resolves via effectiveRepoPath or waives in writing", () => {
+    const violations = [];
+    for (const file of GUARDED_FILES) {
+        if (!statSync(file, { throwIfNoEntry: false }))
+            continue;
+        violations.push(...collectHits(file));
+    }
+    assert.deepEqual(violations, [], "raw spec.repoPath uses without effectiveRepoPath() or a `raw-repoPath:` waiver:\n" +
+        violations.join("\n"));
+});

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/selfmode-literal.test.js

@@ -0,0 +1,153 @@
+// Campaign-1 defect pins (historian evidence task-07, live symptom rc=2):
+// a `${VAR}` env-literal repoPath is a PATH-INJECTION convenience, NOT an
+// engine-self marker. run-loop.ts routed selfMode on isEnvRepoLiteral — ANY
+// literal — so the historian genome (`${ABATHUR_HISTORIAN_REPO}`) was forced
+// into the tsc-build/toy-replay snapshot-overlay bench and died fail-closed
+// demanding `selfbench/expected.json`. selfMode must mean
+// `envRepoName(repoPath) === "ABATHUR_SELF_REPO"`. Secondary pin: the dry-run
+// plan must display the RESOLVED repo path, never the raw literal joined to
+// cwd (run-plan.ts printed `/…/historian/${ABATHUR_HISTORIAN_REPO}`).
+// Harness mirrors run-loop.test.ts: toy genome + stub mutator, no model calls.
+import assert from "node:assert/strict";
+import { spawnSync } from "node:child_process";
+import { existsSync, mkdirSync, readFileSync, writeFileSync, chmodSync } from "node:fs";
+import { mkdtemp } from "node:fs/promises";
+import * as os from "node:os";
+import path from "node:path";
+import test, {} from "node:test";
+import { ExitSignal } from "../exit.js";
+import { registerGenome, requireGenomesByLabel } from "../core/genome.js";
+import { Ledger } from "../core/ledger.js";
+import { prepareToyGenome } from "../bench/toy.js";
+import { runEvolution } from "../core/evolve/run-loop.js";
+// Same three-candidate stub script as run-loop.test.ts (annotate-add seals,
+// touch-kernel path-rejected, fix-add nominated).
+const ADD_ANCHOR = "return a - b; // seeded bug: must be `return a + b;`";
+const STUB_SOURCE = `#!/usr/bin/env node
+import { readFileSync } from "node:fs";
+const args = process.argv.slice(2);
+const opt = (n) => { const i = args.indexOf(n); return i >= 0 ? args[i + 1] : undefined; };
+const mode = opt("--mode");
+const dir = opt("--dir");
+const read = (f) => readFileSync(dir + "/" + f, "utf8");
+function lineDiff(file, anchor, replacement) {
+  const lines = read(file).split("\\n");
+  const i = lines.findIndex((l) => l.includes(anchor));
+  if (i < 0) { process.stderr.write("stub: no anchor in " + file + "\\n"); process.exit(1); }
+  const changed = lines[i].replace(anchor, replacement);
+  return "--- a/" + file + "\\n+++ b/" + file + "\\n@@ -" + String(i + 1) + ",1 +" + String(i + 1) + ",1 @@\\n-" + lines[i] + "\\n+" + changed + "\\n";
+}
+const FIX = ${JSON.stringify(ADD_ANCHOR)};
+const out = (candidates) => process.stdout.write(JSON.stringify({ candidates }) + "\\n");
+if (mode === "three") {
+  out([
+    { id: "annotate-add", rationale: "annotate add()", diffs: [lineDiff("units/add.mjs", "export function add(", "export function add /* patched */(")] },
+    { id: "touch-kernel", rationale: "subvert grading", diffs: [lineDiff("grader.mjs", "model-free", "model-free-ish")] },
+    { id: "fix-add", rationale: "fix add(): subtraction to addition", diffs: [lineDiff("units/add.mjs", FIX, "return a + b;")] },
+  ]);
+} else {
+  process.stderr.write("stub: unknown mode\\n");
+  process.exit(2);
+}
+`;
+/**
+ * Toy genome registered with repoPath stored as the UNRESOLVED literal
+ * `${<envName>}` (the self-seed trick, pointed at the toy repo itself), env
+ * var set for the duration of the test. Fresh configDir per test.
+ */
+async function literalFixture(t, envName) {
+    const root = await mkdtemp(path.join(os.tmpdir(), "abathur-selfmode-"));
+    t.after(() => {
+        // trusted snapshots are chmod-protected read-only: restore writability first.
+        spawnSync("chmod", ["-R", "u+rwX", root], { encoding: "utf8" });
+        spawnSync("rm", ["-rf", root], { encoding: "utf8" });
+    });
+    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 specPath = path.join(repo, "genome.jsonc");
+    const doc = JSON.parse(readFileSync(specPath, "utf8"));
+    doc.repoPath = `\${${envName}}`;
+    writeFileSync(specPath, `${JSON.stringify(doc, null, 2)}\n`, "utf8");
+    const saved = process.env[envName];
+    process.env[envName] = repo;
+    t.after(() => {
+        if (saved === undefined)
+            delete process.env[envName];
+        else
+            process.env[envName] = saved;
+    });
+    registerGenome(configDir, specPath);
+    const entry = requireGenomesByLabel(configDir, "toy-smoke").entries[0];
+    if (entry === undefined)
+        throw new Error("fixture: toy-smoke registration vanished");
+    const stub = path.join(root, "stub.mjs");
+    writeFileSync(stub, STUB_SOURCE, "utf8");
+    chmodSync(stub, 0o755);
+    return {
+        root,
+        configDir,
+        repo,
+        entry,
+        mutatorCommand: `node ${stub} --mode three --dir {worktree} --brief {brief}`,
+        env: { XDG_CACHE_HOME: path.join(root, "xdg-cache"), HOME: path.join(root, "home") },
+        sandboxRoot: path.join(root, "sandboxes"),
+    };
+}
+function generationRowCount(f) {
+    return Ledger.open(f.repo)
+        .readAll()
+        .filter((r) => r.kind === "generation_complete").length;
+}
+// ------------------------------------------------- non-self literal: normal bench
+test("campaign-1 defect: a non-self env-literal repoPath must NOT enter the self-bench overlay", async (t) => {
+    const f = await literalFixture(t, "ABATHUR_HISTORIAN_REPO");
+    const out = await runEvolution({
+        entry: f.entry,
+        configDir: f.configDir,
+        mutatorCommand: f.mutatorCommand,
+        env: f.env,
+        sandboxRoot: f.sandboxRoot,
+    });
+    const plan = out.lines.join("\n");
+    assert.equal(out.exitCode, 0, `expected exit 0, lines: ${plan}`);
+    assert.ok(!/selfbench|self-snapshot|self-bench|overlay/i.test(plan), `non-self literal must never touch the self-bench machinery: ${plan}`);
+    assert.ok(generationRowCount(f) >= 2, "incumbent + candidate rows benched through the NORMAL toy path");
+    assert.equal(existsSync(path.join(f.root, "selfbench")), false);
+});
+// ------------------------------------- self literal: overlay path preserved
+test("regression pin: the ${ABATHUR_SELF_REPO} literal still routes into the self-bench path", async (t) => {
+    // The toy repo carries no selfbench/expected.json, so entering the overlay
+    // bench FAILS CLOSED with exactly that demand — the observable proof that
+    // selfMode is still true for the engine-self literal (live symptom shape).
+    const f = await literalFixture(t, "ABATHUR_SELF_REPO");
+    await assert.rejects(runEvolution({
+        entry: f.entry,
+        configDir: f.configDir,
+        mutatorCommand: f.mutatorCommand,
+        env: f.env,
+        sandboxRoot: f.sandboxRoot,
+    }), (cause) => {
+        assert.ok(cause instanceof ExitSignal, `expected ExitSignal, got ${String(cause)}`);
+        assert.equal(cause.code, 2);
+        assert.match(cause.message, /self-snapshot: trusted selfbench\/expected\.json missing/);
+        return true;
+    });
+});
+// ----------------------------------------------------- dry-run plan display
+test("--dry-run plan displays the RESOLVED repo path, never the literal against cwd", async (t) => {
+    const f = await literalFixture(t, "ABATHUR_HISTORIAN_REPO");
+    const out = await runEvolution({
+        entry: f.entry,
+        configDir: f.configDir,
+        mutatorCommand: f.mutatorCommand,
+        dryRun: true,
+        env: f.env,
+        sandboxRoot: f.sandboxRoot,
+    });
+    assert.equal(out.exitCode, 0, out.lines.join("\n"));
+    const plan = out.lines.join("\n");
+    assert.ok(plan.includes(`repo: ${f.repo}`), `plan must show the resolved path:\n${plan}`);
+    assert.ok(!plan.includes("${"), `plan must never echo the raw literal (resolved against cwd garbage):\n${plan}`);
+});