@tachikomagundam/abathur 0.1.0

package/dist/test/include-val.test.js

@@ -0,0 +1,120 @@
+// --include-val operator flag (plan todo 6 wording, F1 fix): the CLI switch must
+// parse, thread down the bench seam to the fixture adapter (val units runnable,
+// manifest no longer opaque), and fail CLOSED with exit 2 on toy genomes —
+// never silently ignored. Adapter-level val hiding itself is pinned by
+// bench-fixture.test.ts AC (B); these tests cover the CLI + factory seam.
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync } from "node:fs";
+import * as os from "node:os";
+import path from "node:path";
+import test, {} from "node:test";
+import { ExitSignal } from "../exit.js";
+import { parseGenomeSpecDocument } from "../core/spec.js";
+import { openBenchAdapter } from "../core/evolve/run-bench.js";
+import { runEvolution } from "../core/evolve/run-loop.js";
+import { FixtureScenariosAdapter } from "../bench/fixture.js";
+import { parseRunFlags } from "../commands/run.js";
+// ------------------------------------------------------------- parse seam
+test("parseRunFlags: --include-val is a boolean operator switch", () => {
+    assert.equal(parseRunFlags(["--genome", "g", "--include-val"]).includeVal, true);
+    assert.equal(parseRunFlags(["--genome", "g"]).includeVal, false);
+    const combo = parseRunFlags(["--genome", "g", "--include-val", "--dry-run"]);
+    assert.equal(combo.includeVal, true);
+    assert.equal(combo.dryRun, true);
+});
+// -------------------------------------------------- adapter factory seam
+const VAL_CANARY = "valcanary-7f41";
+function fixtureSpec(genDir) {
+    return parseGenomeSpecDocument({
+        label: "iv-germ",
+        repoPath: genDir,
+        bench: {
+            type: "opencode-fixture-scenarios",
+            units: [
+                { id: "one", path: "scenarios/scenarios-one.md", split: "train" },
+                { id: "two", path: "scenarios/scenarios-two.md", split: "train" },
+                { id: "hidden", path: `scenarios/${VAL_CANARY}.md`, split: "val" },
+            ],
+            runCommand: "opencode run {unit.path}",
+            seedCommand: "seed.sh {sandbox}",
+            resetCommand: "reset.sh {sandbox}",
+            graderCommand: "node grader.mjs {unit.id}",
+            judgeCommand: "node judge.mjs {unit.id}",
+            judgeModel: "test/judge",
+            agentModel: "test/agent",
+            timeoutS: 5,
+            stats: { halfWidth: 0.1, minEffect: 0.05, nReps: { initial: 1, max: 2 } },
+        },
+        budget: { maxCandidates: 2, maxModelCalls: 10, maxTokens: 1000, maxWallS: 60 },
+        kernel: { immutableGlobs: [] },
+        requires: [{ cmd: "node", args: ["--version"], probeExit: 0 }],
+        opencodeBinVersion: { minVersion: "1.0.0" },
+    }, "<include-val-test>");
+}
+function fixtureEntry(t, genDir) {
+    t.after(() => rmSync(genDir, { recursive: true, force: true }));
+    return fixtureSpec(genDir);
+}
+function manifestOf(t, spec, includeVal) {
+    const configDir = mkdtempSync(path.join(os.tmpdir(), "abathur-iv-cfg-"));
+    t.after(() => rmSync(configDir, { recursive: true, force: true }));
+    // ctor validates type + repoPath only; probes/locks are lazy, so no spawn here.
+    const bundle = openBenchAdapter(spec, {
+        configDir,
+        ...(includeVal === undefined ? {} : { includeVal }),
+    });
+    t.after(() => bundle.release());
+    assert.ok(bundle.adapter instanceof FixtureScenariosAdapter, "fixture bench must build the fixture adapter");
+    return bundle.adapter.scenarioManifest();
+}
+test("openBenchAdapter: includeVal threads into the fixture adapter manifest", (t) => {
+    const spec = fixtureEntry(t, mkdtempSync(path.join(os.tmpdir(), "abathur-iv-gen-")));
+    const val = (entries) => {
+        const found = entries.find((e) => e.split === "val");
+        assert.ok(found !== undefined, "fixture spec must carry a val unit");
+        return found;
+    };
+    const hidden = manifestOf(t, spec); // default: operator did NOT pass the flag
+    const v1 = val(hidden);
+    assert.equal(v1.id, undefined, "val id must stay hidden without the operator flag");
+    assert.equal(v1.path, undefined, "val path must stay hidden without the operator flag");
+    assert.match(v1.alias, /^scenario-\d{2}$/);
+    assert.ok(!JSON.stringify(hidden).includes(VAL_CANARY), "val canary leaked into the default manifest");
+    const shown = manifestOf(t, spec, true);
+    const v2 = val(shown);
+    assert.equal(v2.id, "hidden");
+    assert.equal(v2.path, `scenarios/${VAL_CANARY}.md`);
+});
+// --------------------------------------------------------- toy fail-closed
+function toyEntry(t) {
+    const repoPath = mkdtempSync(path.join(os.tmpdir(), "abathur-iv-toy-"));
+    t.after(() => rmSync(repoPath, { recursive: true, force: true }));
+    const spec = parseGenomeSpecDocument({
+        label: "iv-toy",
+        repoPath,
+        bench: {
+            type: "toy",
+            units: [
+                { id: "add", path: "units/add.mjs", split: "train" },
+                { id: "sub", path: "units/sub.mjs", split: "val" },
+            ],
+            runCommand: "node {unit.path}",
+            graderCommand: "node grader.mjs {unit.path}",
+            timeoutS: 10,
+            stats: { halfWidth: 0.25, minEffect: 0.5, nReps: { initial: 2, max: 4 } },
+        },
+        budget: { maxCandidates: 4, maxModelCalls: 16, maxTokens: 100000, maxWallS: 300 },
+        kernel: { immutableGlobs: [] },
+    }, "<include-val-test>");
+    return { fingerprint: "0123456789abcdef", label: "iv-toy", spec, registryFile: "<test>/iv-toy.jsonc", storedText: "{}" };
+}
+test("runEvolution: toy genome + --include-val fails closed (exit 2), even with --dry-run", async (t) => {
+    const configDir = mkdtempSync(path.join(os.tmpdir(), "abathur-iv-cfg-"));
+    t.after(() => rmSync(configDir, { recursive: true, force: true }));
+    await assert.rejects(runEvolution({ entry: toyEntry(t), configDir, includeVal: true, dryRun: true }), (cause) => {
+        assert.ok(cause instanceof ExitSignal, `expected ExitSignal, got ${String(cause)}`);
+        assert.equal(cause.code, 2);
+        assert.match(cause.message, /--include-val is only supported by the opencode-fixture-scenarios bench/);
+        return true;
+    });
+});

package/dist/test/ledger-lock.test.js

@@ -0,0 +1,99 @@
+// Todo 2 pins: crash-safe locks + friction queue (plan AC d, e, f).
+// RED first. The genome lock must exit 2 naming a live holder, take over a
+// provably-dead holder with a ledger event, and serialize cross-process
+// friction appends without interleaving.
+import assert from "node:assert/strict";
+import { spawn, spawnSync } from "node:child_process";
+import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import { test } from "node:test";
+import { fileURLToPath } from "node:url";
+import { canonicalJson } from "../core/ids.js";
+import { LEDGER_KIND_LOCK_TAKEOVER, Ledger, acquireGenomeLock, acquireLock, appendFriction, frictionQueuePath, lockDirFor, readFriction, } from "../core/ledger.js";
+import { ExitSignal } from "../exit.js";
+import { FIXED_CLOCK, freshPair, isAlive, rawLines } from "./testutil.js";
+function seedStaleLock(config, key, owner) {
+    const dir = lockDirFor(config, key);
+    mkdirSync(dir, { recursive: true });
+    if (owner !== null) {
+        writeFileSync(path.join(dir, "owner.json"), JSON.stringify({ ...owner, createdAt: "x", label: "genome" }));
+    }
+    return dir;
+}
+// -------------------------------------------------------------------- locks
+test("live holder blocks the second acquirer: exit 2 naming holder pid (AC d)", async (t) => {
+    const { config } = await freshPair(t);
+    const lease = acquireLock({ configDir: config, key: "fp-live", ...FIXED_CLOCK });
+    assert.ok(existsSync(path.join(lease.lockDir, "owner.json")));
+    assert.throws(() => acquireLock({ configDir: config, key: "fp-live", ...FIXED_CLOCK }), (e) => e instanceof ExitSignal &&
+        e.code === 2 &&
+        e.message.includes(`pid ${process.pid}`) &&
+        e.message.includes("fp-live"));
+    lease.release();
+    assert.ok(!existsSync(lease.lockDir));
+    acquireLock({ configDir: config, key: "fp-live", ...FIXED_CLOCK }).release();
+});
+test("dead-PID holder is taken over; a lock_takeover event lands in the genome ledger (AC e)", async (t) => {
+    const { genome, config } = await freshPair(t);
+    const deadPid = spawnSync(process.execPath, ["-e", ""]).pid;
+    if (deadPid === undefined)
+        throw new Error("fixture must yield a child pid");
+    assert.ok(!isAlive(deadPid), "fixture pid must be provably dead");
+    const staleDir = seedStaleLock(config, "fp-dead", { pid: deadPid });
+    const ledger = Ledger.open(genome, FIXED_CLOCK);
+    const lease = acquireGenomeLock({ ledger, configDir: config, genomeFp: "fp-dead", ...FIXED_CLOCK });
+    assert.equal(lease.lockDir, staleDir);
+    assert.equal(JSON.parse(readFileSync(path.join(staleDir, "owner.json"), "utf8")).pid, process.pid);
+    const takeover = ledger.readAll().filter((r) => r.kind === LEDGER_KIND_LOCK_TAKEOVER);
+    assert.equal(takeover.length, 1);
+    assert.deepEqual(takeover[0]?.data, { lockKey: "fp-dead", stalePid: deadPid, takenOverByPid: process.pid });
+    assert.deepEqual(readdirSync(path.join(config, ".locks")), ["fp-dead.lock"], "stale quarantine must be cleaned up");
+    lease.release();
+});
+test("lock dir without a readable owner.json is stale (crash mid-acquire) and taken over", async (t) => {
+    const { genome, config } = await freshPair(t);
+    seedStaleLock(config, "fp-empty", null);
+    const ledger = Ledger.open(genome, FIXED_CLOCK);
+    const lease = acquireGenomeLock({ ledger, configDir: config, genomeFp: "fp-empty", ...FIXED_CLOCK });
+    assert.deepEqual(ledger.readAll().map((r) => r.data.stalePid), [null]);
+    lease.release();
+});
+// ------------------------------------------------------------- friction queue
+test("friction queue lives under config home and validates every append", async (t) => {
+    const { config } = await freshPair(t);
+    assert.equal(frictionQueuePath(config), path.join(config, "friction.jsonl"));
+    const rec = appendFriction(config, { kind: "friction", data: { genome: "g1", note: "slow" } }, FIXED_CLOCK);
+    assert.equal(rec.kind, "friction");
+    assert.deepEqual(readFriction(config).map((r) => canonicalJson(r)), [canonicalJson(rec)]);
+    assert.throws(() => appendFriction(config, { kind: "" }, FIXED_CLOCK), Error);
+    assert.equal(rawLines(frictionQueuePath(config)).length, 1, "failed append wrote nothing");
+});
+test("two genomes append 200 friction records each concurrently: 400 clean zod-valid lines (AC f)", async (t) => {
+    const { config } = await freshPair(t);
+    const writer = fileURLToPath(new URL("./fixtures/friction-writer.js", import.meta.url));
+    const run = (source) => new Promise((resolve, reject) => {
+        const child = spawn(process.execPath, [writer, config, source, "200"], { stdio: "inherit" });
+        child.on("error", reject);
+        child.on("close", resolve);
+    });
+    assert.deepEqual(await Promise.all([run("genome-a"), run("genome-b")]), [0, 0]);
+    const lines = rawLines(frictionQueuePath(config));
+    assert.equal(lines.length, 400, "no interleaved/partial lines under concurrent appends");
+    const parsed = readFriction(config);
+    assert.equal(parsed.length, 400);
+    for (const source of ["genome-a", "genome-b"]) {
+        const seqs = parsed
+            .filter((r) => r.data.source === source)
+            .map((r) => Number(r.data.seq))
+            .sort((x, y) => x - y);
+        assert.deepEqual(seqs, Array.from({ length: 200 }, (_, i) => i), `${source}: all records intact`);
+    }
+});
+test("friction append waits for a live holder within budget, then exits 2 naming the pid", async (t) => {
+    const { config } = await freshPair(t);
+    const held = acquireLock({ configDir: config, key: "friction", ...FIXED_CLOCK });
+    assert.throws(() => appendFriction(config, { kind: "friction", data: {} }, { ...FIXED_CLOCK, waitMs: 30 }), (e) => e instanceof ExitSignal && e.code === 2 && e.message.includes(`pid ${process.pid}`));
+    held.release();
+    appendFriction(config, { kind: "friction", data: { afterRelease: true } }, FIXED_CLOCK);
+    assert.equal(readFriction(config).length, 1);
+});

package/dist/test/ledger.test.js

@@ -0,0 +1,102 @@
+// Todo 2 pins: append-only ledger file semantics (plan AC b, c + resume).
+// Lock/friction pins live in ledger-lock.test.ts. TDD RED first.
+import assert from "node:assert/strict";
+import { mkdirSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import { test } from "node:test";
+import { canonicalJson } from "../core/ids.js";
+import { LEDGER_KIND_GENERATION_COMPLETE, Ledger, LedgerError, ledgerPath } from "../core/ledger.js";
+import { FIXED_CLOCK, freshPair, rawLines } from "./testutil.js";
+function seedLedgerFile(genome, text) {
+    mkdirSync(path.dirname(ledgerPath(genome)), { recursive: true });
+    writeFileSync(ledgerPath(genome), text, "utf8");
+}
+// --------------------------------------------------------- append + read-back
+test("1000 appends read back byte-exact via a single O_APPEND write each (AC b)", async (t) => {
+    const { genome } = await freshPair(t);
+    const ledger = Ledger.open(genome, FIXED_CLOCK);
+    const expected = [];
+    for (let seq = 0; seq < 1000; seq += 1) {
+        const rec = ledger.append({ kind: "run_result", data: { seq, note: "x".repeat(seq % 7) } });
+        expected.push(`${canonicalJson(rec)}\n`);
+    }
+    assert.equal(readFileSync(ledgerPath(genome), "utf8"), expected.join(""));
+    const all = ledger.readAll();
+    assert.equal(all.length, 1000);
+    assert.deepEqual(all.map((r) => r.data.seq), Array.from({ length: 1000 }, (_, i) => i));
+});
+test("append stamps ts from the injected clock and fails closed on invalid records", async (t) => {
+    const { genome } = await freshPair(t);
+    const ledger = Ledger.open(genome, FIXED_CLOCK);
+    const rec = ledger.append({ kind: "k", genId: "g-1", data: { z: [1, { b: 2, a: 3 }] } });
+    assert.deepEqual(rec, {
+        v: 1,
+        ts: "2026-09-09T12:00:00.000Z",
+        kind: "k",
+        genId: "g-1",
+        data: { z: [1, { b: 2, a: 3 }] },
+    });
+    assert.throws(() => ledger.append({ kind: "" }), Error);
+    assert.throws(() => ledger.append({ kind: "k", genId: "" }), Error);
+    assert.equal(rawLines(ledgerPath(genome)).length, 1, "failed appends must write nothing");
+});
+// ------------------------------------------------------------- corrupt tail
+test("pre-truncated tail is quarantined to ledger.corrupt-*, prior records preserved verbatim (AC c)", async (t) => {
+    const { genome } = await freshPair(t);
+    const good = Array.from({ length: 10 }, (_, i) => canonicalJson({
+        v: 1,
+        ts: `2026-09-09T12:00:0${i}.000Z`,
+        kind: LEDGER_KIND_GENERATION_COMPLETE,
+        genId: `g-${i}`,
+        data: {},
+    })).join("\n");
+    const partial = '{"v":1,"ts":"2026-09-09T12:00:10.000Z","kind":"gen';
+    const original = `${good}\n${partial}`;
+    seedLedgerFile(genome, original);
+    const ledger = Ledger.open(genome, FIXED_CLOCK);
+    const dir = path.dirname(ledgerPath(genome));
+    const corruptName = readdirSync(dir).find((f) => f.startsWith("ledger.corrupt-"));
+    assert.ok(corruptName, "quarantine file ledger.corrupt-* must exist");
+    // The archive keeps the FULL original bytes — nothing is lost, only relocated.
+    assert.equal(readFileSync(path.join(dir, corruptName), "utf8"), original);
+    // The ledger keeps the 10 complete lines byte-identical, newline-terminated.
+    assert.equal(readFileSync(ledgerPath(genome), "utf8"), `${good}\n`);
+    assert.deepEqual(ledger.readAll().map((r) => r.genId), Array.from({ length: 10 }, (_, i) => `g-${i}`));
+    const next = ledger.append({ kind: "after_repair" });
+    assert.equal(next.kind, "after_repair");
+    assert.equal(ledger.readAll().length, 11);
+});
+test("entire-file partial write (no newline anywhere) quarantines to an empty valid ledger", async (t) => {
+    const { genome } = await freshPair(t);
+    seedLedgerFile(genome, '{"v":1,"ts":');
+    const ledger = Ledger.open(genome, FIXED_CLOCK);
+    assert.deepEqual(ledger.readAll(), []);
+    assert.equal(readFileSync(ledgerPath(genome), "utf8"), "");
+});
+test("malformed line in the MIDDLE is an integrity failure, never silently skipped or repaired", async (t) => {
+    const { genome } = await freshPair(t);
+    const l1 = canonicalJson({ v: 1, ts: "t", kind: "a", data: {} });
+    const l3 = canonicalJson({ v: 1, ts: "t", kind: "c", data: {} });
+    seedLedgerFile(genome, `${l1}\n{"v":1,"ts":oops}\n${l3}\n`);
+    for (const attempt of [
+        () => Ledger.open(genome, FIXED_CLOCK),
+        () => Ledger.open(genome).readAll(),
+    ]) {
+        assert.throws(attempt, (e) => e instanceof LedgerError && /line 2/.test(e.message), "mid-file corruption must name the offending line");
+    }
+    assert.ok(!readdirSync(path.dirname(ledgerPath(genome))).some((f) => f.startsWith("ledger.corrupt-")), "integrity failure must not quarantine anything");
+});
+// --------------------------------------------------------------- resume API
+test("lastCompleteGeneration: null when empty or no matching kind, latest generation_complete otherwise", async (t) => {
+    const { genome } = await freshPair(t);
+    const ledger = Ledger.open(genome, FIXED_CLOCK);
+    assert.equal(ledger.lastCompleteGeneration(), null);
+    ledger.append({ kind: "run_result", genId: "g-a", data: {} });
+    assert.equal(ledger.lastCompleteGeneration(), null);
+    ledger.append({ kind: LEDGER_KIND_GENERATION_COMPLETE, genId: "g-a" });
+    ledger.append({ kind: "run_result", genId: "g-b" });
+    ledger.append({ kind: LEDGER_KIND_GENERATION_COMPLETE, genId: "g-b" });
+    assert.equal(ledger.lastCompleteGeneration(), "g-b");
+    // A fresh instance sees the same state — resume reads the file, not memory.
+    assert.equal(Ledger.open(genome, FIXED_CLOCK).lastCompleteGeneration(), "g-b");
+});