@tachikomagundam/abathur 0.2.5 → 0.2.7

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,84 @@
+// 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("retract with env-literal repoPath: exported ⇒ blocked naming the RESOLVED repo path", async (t) => {
+    const f = await fixture(t, "seam-gate-retract");
+    const r = cli(f, ["retract", 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/self-snapshot.test.js

@@ -283,8 +283,8 @@ function commitSurgery(fx, message, surgery) {
     exec("git", ["-C", fx.harness.repo, "reset", "--hard", fx.head]);
     surgery();
     const repo = fx.harness.repo;
-    exec("git", ["-c", "user.name=abathur", "-c", "user.email=abathur@harness.local", "-C", repo, "add", "-A"]);
-    exec("git", ["-c", "user.name=abathur", "-c", "user.email=abathur@harness.local", "-C", repo, "commit", "-m", message]);
+    exec("git", ["-c", "user.name=abathur", "-c", "user.email=agent@host.example", "-C", repo, "add", "-A"]);
+    exec("git", ["-c", "user.name=abathur", "-c", "user.email=agent@host.example", "-C", repo, "commit", "-m", message]);
     return headSha(repo);
 }
 function exec(bin, args) {