@tachikomagundam/abathur 0.2.3 → 0.2.4

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

@@ -3,7 +3,7 @@
 // (ABATHUR_GRADER_STATE replaces every wiki/URL call; no live network).
 import assert from "node:assert/strict";
 import { execFile } from "node:child_process";
-import { mkdirSync, mkdtempSync, writeFileSync } from "node:fs";
+import { copyFileSync, existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
@@ -146,3 +146,279 @@ test("grader CLI: garbage transcript ⇒ nonzero exit, no score line (adapter
     assert.notEqual(r.code, 0);
     assert.equal(r.stdout.trim(), "");
 });
+// ------------------------------------------- S4 seam: active-tree scenario resolution
+//
+// post-seam graderCommand renders `{repoRoot}/{unit.path}` (adapter unitVars), so
+// argv[1] arrives as an ABSOLUTE path into the bench's active tree — incumbent
+// repoPath or candidate worktree, same notion as the run side. Resolution mirrors
+// the ABATHUR_GRADER_STATE offline pattern: the file is read only when it exists
+// (offline fixtures pass relative/nonexistent paths, which must keep working), and
+// a readable scenario must agree with the unit id on the scenario number — the
+// pre-seam failure mode was commands baked against the WRONG tree.
+function stateFor(dir) {
+    const stateFile = path.join(dir, "state.json");
+    writeFileSync(stateFile, JSON.stringify({
+        post: POST_OK,
+        content: { 400: "[qwen27b](/_sandbox/llm-inference/qwen27b-threading)", 600: GOOD_PAGE },
+        urlStatus: {},
+    }));
+    return stateFile;
+}
+test("grader CLI resolves an existing {repoRoot}-rendered scenario file ⇒ metrics.scenarioFile", async () => {
+    const dir = sandboxWith(transcript(GOOD_FINAL, 5678), PRE);
+    const repo = mkdtempSync(path.join(tmpdir(), "t14-seamrepo-"));
+    mkdirSync(path.join(repo, "scenarios"), { recursive: true });
+    const scenarioAbs = path.join(repo, "scenarios", "01-new-finding.md");
+    writeFileSync(scenarioAbs, "# Scenario 01\n\n## Brief\ndo it\n", "utf8");
+    const r = await runGrader(dir, ["scenario-01", scenarioAbs, "http://localhost:3000"], {
+        ABATHUR_GRADER_STATE: stateFor(dir),
+    });
+    assert.equal(r.code, 0, r.stderr);
+    const parsed = JSON.parse(r.stdout.trim().split("\n").at(-1) ?? "{}");
+    assert.equal(parsed.metrics.scenarioFile, scenarioAbs, "resolved active-tree scenario path surfaces in metrics");
+});
+test("grader CLI: scenario number disagreeing with the unit id ⇒ nonzero (never a score)", async () => {
+    const dir = sandboxWith(transcript(GOOD_FINAL, 5678), PRE);
+    const repo = mkdtempSync(path.join(tmpdir(), "t14-seambad-"));
+    mkdirSync(path.join(repo, "scenarios"), { recursive: true });
+    const wrongAbs = path.join(repo, "scenarios", "99-wrong-unit.md");
+    writeFileSync(wrongAbs, "# Scenario 99\n\n## Brief\nnope\n", "utf8");
+    const r = await runGrader(dir, ["scenario-01", wrongAbs, "http://localhost:3000"], {
+        ABATHUR_GRADER_STATE: stateFor(dir),
+    });
+    assert.notEqual(r.code, 0, "a mis-baked template must surface as inconclusive, not as a score");
+    assert.match(r.stderr, /does not match/);
+});
+test("grader CLI: absent scenario file keeps grading offline (byte-compatible pre-seam fixtures)", async () => {
+    const dir = sandboxWith(transcript(GOOD_FINAL, 5678), PRE);
+    const r = await runGrader(dir, ["scenario-01", "scenarios/01-new-finding.md", "http://localhost:3000"], {
+        ABATHUR_GRADER_STATE: stateFor(dir),
+    });
+    assert.equal(r.code, 0, r.stderr);
+    const parsed = JSON.parse(r.stdout.trim().split("\n").at(-1) ?? "{}");
+    assert.equal(parsed.score, 1);
+    assert.equal(parsed.metrics.scenarioFile, null);
+});
+// --------------------------------------- S3 integrity units scenario-10/11/12 (G2)
+//
+// Cross-repo fixtures live in the historian bench repo under baseline/fixtures/,
+// captured live from the seed cycle (evidence: historian .omo/evidence/task-05-scenarios.md).
+// The repo is resolved through the SAME env var the campaign genome consumes for
+// repoPath — ABATHUR_HISTORIAN_REPO — with the documented machine default below.
+// Absent fixtures ⇒ every test below skips with a naming message (inconclusive,
+// never a fake green). The expected numbers are the separations the proposal
+// proved offline (validate-offline.mjs 59/59); here they run against the SHIPPED
+// grader entry end-to-end: real argv, real exit codes, real score lines.
+const HISTORIAN_REPO = process.env.ABATHUR_HISTORIAN_REPO ?? "/home/lab/workspace/harness/historian";
+const FIXDIR = path.join(HISTORIAN_REPO, "baseline", "fixtures");
+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(HISTORIAN_REPO, "scenarios", "10-status-contradiction-audit.md")));
+}
+const integritySkip = integrityFixturesReady()
+    ? false
+    : `historian fixtures missing under ${FIXDIR} — set ABATHUR_HISTORIAN_REPO (documented default: /home/lab/workspace/harness/historian)`;
+// Separation table from task-05 evidence §(f)3 — every bad shape bites via I/J.
+const INTEGRITY_CASES = [
+    { unit: "scenario-10", scenarioRel: "scenarios/10-status-contradiction-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-10", scenarioRel: "scenarios/10-status-contradiction-audit.md", shape: "fail", score: 0.5, pass: false, total: 4, weight: 8, dims: { D: 1, G: 1, H: 1, I: 0, J: 0 } },
+    { unit: "scenario-10", scenarioRel: "scenarios/10-status-contradiction-audit.md", shape: "donothing", score: 0.5, pass: false, total: 4, weight: 8, dims: { D: 1, G: 1, H: 1, I: 0, J: 0 } },
+    { unit: "scenario-11", scenarioRel: "scenarios/11-expired-card-reverify.md", shape: "pass", score: 1, pass: true, total: 8, weight: 8, dims: { D: 1, G: 1, H: 1, I: 1, J: 1 } },
+    { unit: "scenario-11", scenarioRel: "scenarios/11-expired-card-reverify.md", shape: "fail", score: 0.5, pass: false, total: 4, weight: 8, dims: { D: 1, G: 1, H: 1, I: 0, J: 0 } },
+    { unit: "scenario-11", scenarioRel: "scenarios/11-expired-card-reverify.md", shape: "fabricate", score: 0.5, pass: false, total: 4, weight: 8, dims: { D: 1, G: 1, H: 1, I: 0, J: 0 } },
+    { unit: "scenario-11", scenarioRel: "scenarios/11-expired-card-reverify.md", shape: "donothing", score: 0.5, pass: false, total: 4, weight: 8, dims: { D: 1, G: 1, H: 1, I: 0, J: 0 } },
+    { 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 } },
+];
+function integritySandbox(unit, shape) {
+    const fix = path.join(FIXDIR, unit);
+    const dir = mkdtempSync(path.join(tmpdir(), "g2-int-"));
+    mkdirSync(path.join(dir, ".bench", "transcripts"), { recursive: true });
+    copyFileSync(path.join(fix, `transcript-${shape}.jsonl`), path.join(dir, ".bench", "transcripts", `${unit}.jsonl`));
+    copyFileSync(path.join(fix, "wiki-pre.json"), path.join(dir, ".bench", "wiki-pre.json"));
+    copyFileSync(path.join(fix, "seed-state.json"), path.join(dir, ".bench", "seed-state.json"));
+    writeFileSync(path.join(dir, "state.json"), readFileSync(path.join(fix, `state-${shape}.json`), "utf8"));
+    return dir;
+}
+function parseLine(stdout) {
+    return JSON.parse(stdout.trim().split("\n").at(-1) ?? "{}");
+}
+for (const c of INTEGRITY_CASES) {
+    test(`grader CLI ${c.unit}/${c.shape}: shipped separation ${c.score} pass=${c.pass}, dims ${JSON.stringify(c.dims)}, n=2 byte-identical`, { skip: integritySkip }, async () => {
+        const dir = integritySandbox(c.unit, c.shape);
+        const scenarioAbs = path.join(HISTORIAN_REPO, c.scenarioRel);
+        const env = { ABATHUR_GRADER_STATE: path.join(dir, "state.json") };
+        const r1 = await runGrader(dir, [c.unit, scenarioAbs, "http://localhost:3000"], env);
+        const r2 = await runGrader(dir, [c.unit, scenarioAbs, "http://localhost:3000"], env);
+        assert.equal(r1.code, 0, r1.stderr);
+        assert.equal(r2.stdout, r1.stdout, "same fixture ×2 ⇒ byte-identical score line (scoring-path CI=0)");
+        const line = parseLine(r1.stdout);
+        assert.equal(line.unit, c.unit);
+        assert.equal(line.score, c.score);
+        assert.equal(line.pass, c.pass);
+        assert.deepEqual(line.metrics.dims, c.dims);
+        assert.equal(line.metrics.total, c.total);
+        assert.equal(line.metrics.applicableWeight, c.weight);
+        assert.equal(line.metrics.scenarioFile, scenarioAbs, "resolved active-tree scenario path surfaces in metrics");
+    });
+}
+test("grader CLI integrity units: every bad shape scores strictly below its PASS control", { skip: integritySkip }, async () => {
+    const byUnit = new Map();
+    for (const c of INTEGRITY_CASES) {
+        if (c.shape !== "pass")
+            continue;
+        const dir = integritySandbox(c.unit, c.shape);
+        const r = await runGrader(dir, [c.unit, path.join(HISTORIAN_REPO, c.scenarioRel), "http://localhost:3000"], {
+            ABATHUR_GRADER_STATE: path.join(dir, "state.json"),
+        });
+        assert.equal(r.code, 0, r.stderr);
+        byUnit.set(c.unit, parseLine(r.stdout).score);
+    }
+    for (const c of INTEGRITY_CASES) {
+        if (c.shape === "pass")
+            continue;
+        const dir = integritySandbox(c.unit, c.shape);
+        const r = await runGrader(dir, [c.unit, path.join(HISTORIAN_REPO, c.scenarioRel), "http://localhost:3000"], {
+            ABATHUR_GRADER_STATE: path.join(dir, "state.json"),
+        });
+        assert.equal(r.code, 0, r.stderr);
+        const line = parseLine(r.stdout);
+        const passScore = byUnit.get(c.unit) ?? Number.NaN;
+        assert.ok(line.score < passScore, `${c.unit}/${c.shape}: ${String(line.score)} must be below pass ${String(passScore)}`);
+        assert.ok(line.metrics.dims.I === 0 || line.metrics.dims.J === 0, "a dim bites (I=0 or J=0)");
+    }
+});
+test("grader CLI: unit 10 + scenario-09 file ⇒ nonzero 'does not match' (seam guard, never a score)", { skip: integritySkip }, async () => {
+    const dir = integritySandbox("scenario-10", "pass");
+    const r = await runGrader(dir, ["scenario-10", path.join(HISTORIAN_REPO, "scenarios", "09-timeline-week-groups.md"), "http://localhost:3000"], {
+        ABATHUR_GRADER_STATE: path.join(dir, "state.json"),
+    });
+    assert.notEqual(r.code, 0, "a mis-baked template must surface as inconclusive, not as a score");
+    assert.match(r.stderr, /does not match/);
+    assert.equal(r.stdout.trim(), "");
+});
+test("grader CLI: garbage transcript on an integrity unit ⇒ nonzero, no score line", { skip: integritySkip }, async () => {
+    const dir = integritySandbox("scenario-10", "pass");
+    writeFileSync(path.join(dir, ".bench", "transcripts", "scenario-10.jsonl"), "not json\n{broken");
+    const r = await runGrader(dir, ["scenario-10", path.join(HISTORIAN_REPO, "scenarios", "10-status-contradiction-audit.md"), "http://localhost:3000"], {
+        ABATHUR_GRADER_STATE: path.join(dir, "state.json"),
+    });
+    assert.notEqual(r.code, 0);
+    assert.equal(r.stdout.trim(), "");
+});
+test("grader CLI: integrity unit WITHOUT .bench/seed-state.json ⇒ inconclusive (never vacuous/guessed)", { skip: integritySkip }, async () => {
+    const dir = integritySandbox("scenario-10", "pass");
+    rmSync(path.join(dir, ".bench", "seed-state.json"));
+    const r = await runGrader(dir, ["scenario-10", path.join(HISTORIAN_REPO, "scenarios", "10-status-contradiction-audit.md"), "http://localhost:3000"], {
+        ABATHUR_GRADER_STATE: path.join(dir, "state.json"),
+    });
+    assert.notEqual(r.code, 0, "missing seed capture ⇒ fail-closed inconclusive");
+    assert.equal(r.stdout.trim(), "");
+    assert.match(r.stderr, /seed-state/);
+});
+/** s10/pass sandbox with the maintain event replaced by an externalization stub.
+ *  "ref": full pretty JSON lives in the ref file (head cut above every row).
+ *  "fallback": ref absent, conflict rows visible in the retained head.
+ *  "dead": ref absent, no rows visible ⇒ fail-closed. */
+function s10ExternalizedSandbox(kind) {
+    const dir = integritySandbox("scenario-10", "pass");
+    const tp = path.join(dir, ".bench", "transcripts", "scenario-10.jsonl");
+    const ref = path.join(dir, "tool_ext");
+    const lines = readFileSync(tp, "utf8")
+        .split("\n")
+        .map((l) => {
+        if (l.length === 0)
+            return l;
+        const doc = JSON.parse(l);
+        if (doc.part?.type !== "tool" || doc.part.state?.input?.action !== "maintain" || doc.part.state.output === undefined)
+            return l;
+        const compact = doc.part.state.output;
+        const rowStart = compact.indexOf('{"path":"_sandbox');
+        const rowVisible = compact.indexOf('"key":"status-token-conflict"', rowStart) + '"key":"status-token-conflict"'.length;
+        const head = kind === "fallback" ? rowVisible : rowStart;
+        if (kind === "ref")
+            writeFileSync(ref, JSON.stringify(JSON.parse(compact), null, 2));
+        doc.part.state.output = [
+            compact.slice(0, head),
+            "",
+            "...2394 lines truncated...",
+            "",
+            `The tool call succeeded but the output was truncated. Full output saved to: ${ref}`,
+            "Use the Task tool to have explore agent process this file with Grep and Read (with offset/limit). " +
+                "Do NOT read the full file yourself - delegate to save context.",
+        ].join("\n");
+        return JSON.stringify(doc);
+    });
+    writeFileSync(tp, lines.join("\n"));
+    return dir;
+}
+async function gradeS10(dir) {
+    const r = await runGrader(dir, ["scenario-10", path.join(HISTORIAN_REPO, "scenarios", "10-status-contradiction-audit.md"), "http://localhost:3000"], {
+        ABATHUR_GRADER_STATE: path.join(dir, "state.json"),
+    });
+    assert.equal(r.code, 0, r.stderr);
+    return parseLine(r.stdout);
+}
+test("grader CLI P1 stub-follow: externalized maintain(deep) resolved via ref file ⇒ pass flips, n=2 byte-identical", { skip: integritySkip }, async () => {
+    const dir = s10ExternalizedSandbox("ref");
+    const r1 = await runGrader(dir, ["scenario-10", path.join(HISTORIAN_REPO, "scenarios", "10-status-contradiction-audit.md"), "http://localhost:3000"], {
+        ABATHUR_GRADER_STATE: path.join(dir, "state.json"),
+    });
+    const r2 = await runGrader(dir, ["scenario-10", path.join(HISTORIAN_REPO, "scenarios", "10-status-contradiction-audit.md"), "http://localhost:3000"], {
+        ABATHUR_GRADER_STATE: path.join(dir, "state.json"),
+    });
+    assert.equal(r1.code, 0, r1.stderr);
+    assert.equal(r2.stdout, r1.stdout, "stub fixture ×2 ⇒ byte-identical score line");
+    const line = parseLine(r1.stdout);
+    assert.deepEqual(line.metrics.dims, { D: 1, G: 1, H: 1, I: 1, J: 1 });
+    assert.deepEqual({ score: line.score, pass: line.pass }, { score: 1, pass: true });
+});
+test("grader CLI P1 fallback: ref unreadable but seeded row visible in the stub head ⇒ rescue, pass", { skip: integritySkip }, async () => {
+    const line = await gradeS10(s10ExternalizedSandbox("fallback"));
+    assert.equal(line.metrics.dims.I, 1);
+    assert.equal(line.pass, true);
+});
+test("grader CLI P1 fail-closed: ref unreadable, no rows visible ⇒ rc0, I=0 + clean I10 note, never a crash", { skip: integritySkip }, async () => {
+    const line = await gradeS10(s10ExternalizedSandbox("dead"));
+    assert.equal(line.metrics.dims.I, 0);
+    assert.equal(line.pass, false);
+    assert.ok(line.metrics.notes.some((n) => n.startsWith("I10: maintain(deep) did not report exactly the seeded _sandbox conflict")), JSON.stringify(line.metrics.notes));
+});
+function withOutsideChurn(dir, churnPath) {
+    const preFile = path.join(dir, ".bench", "wiki-pre.json");
+    const stFile = path.join(dir, "state.json");
+    const pre = JSON.parse(readFileSync(preFile, "utf8"));
+    const state = JSON.parse(readFileSync(stFile, "utf8"));
+    pre.push({ id: 900, path: churnPath, locale: "en", updatedAt: "2026-09-01T00:00:00Z" });
+    state.post.push({ id: 900, path: churnPath, locale: "en", updatedAt: "2026-09-13T12:00:00Z" });
+    writeFileSync(preFile, JSON.stringify(pre));
+    writeFileSync(stFile, JSON.stringify(state));
+}
+test("grader CLI P2: s10 honest run + plugin-owned _meta/page-map churn ⇒ G=1 pass", { skip: integritySkip }, async () => {
+    const dir = integritySandbox("scenario-10", "pass");
+    withOutsideChurn(dir, "_meta/page-map");
+    const line = await gradeS10(dir);
+    assert.equal(line.metrics.dims.G, 1);
+    assert.deepEqual({ score: line.score, pass: line.pass }, { score: 1, pass: true });
+});
+test("grader CLI P2 guard: s10 + any other out-of-scope churn ⇒ G=0 pass=false (exemption stays exact)", { skip: integritySkip }, async () => {
+    const dir = integritySandbox("scenario-10", "pass");
+    withOutsideChurn(dir, "notes/outside-the-sandbox");
+    const line = await gradeS10(dir);
+    assert.equal(line.metrics.dims.G, 0);
+    assert.equal(line.pass, false);
+});
+// F1 don't-break-incumbent: the FULL scenario-01 passing CLI line (offline state,
+// absent scenario file ⇒ scenarioFile null) frozen byte-for-byte from the pre-G2
+// tree 4997618 — the adapter-visible contract of incumbent units cannot move.
+test("grader CLI scenario-01: stdout line byte-identical to pre-G2 capture", async () => {
+    const dir = sandboxWith(transcript(GOOD_FINAL, 5678), PRE);
+    const r = await runGrader(dir, ["scenario-01", "scenarios/01-new-finding.md", "http://localhost:3000"], {
+        ABATHUR_GRADER_STATE: stateFor(dir),
+    });
+    assert.equal(r.code, 0, r.stderr);
+    assert.equal(r.stdout, '{"unit":"scenario-01","score":1,"pass":true,"metrics":{"tokensEst":5678,"turns":1,"dims":{"A":1,"B":1,"C":1,"D":1,"E":1,"F":1,"G":1,"H":1},"total":12,"applicableWeight":12,"notes":[],"scenarioFile":null}}\n');
+});

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

@@ -0,0 +1,205 @@
+// S4 engine seam — run-card injection in graders/historian/run-scenario.sh.
+// Everything OFFLINE: a stub `opencode` (argv-recording + transcript-emitting
+// node script) replaces the real agent; zero model calls. Pins (task-6 e2):
+//  (1) no abathur-notes dir (or no *.md in it) ⇒ the captured brief is BYTE-
+//      IDENTICAL to the bare awk-extracted scenario Brief and carries no
+//      `## Run card` heading — the F1 invariant (incumbent transcripts must not
+//      grow a run-card section);
+//  (2) one note ⇒ the brief ends with "\n\n## Run card\n\n" + verbatim content;
+//  (3) determinism: two consecutive runs over the same tree ⇒ byte-identical
+//      prompt AND transcript files;
+//  (4) stale-state: changing the note between runs changes the brief (old body
+//      gone, new body present) and the transcript;
+//  (5) PLUM A/B flow: a planted instruction note ⇒ appears in the brief ⇒
+//      appears in the stub transcript's finalMessage (note⇒brief⇒transcript);
+//  (6) multiple notes concatenate in LC_ALL=C filename order; an explicit 3rd
+//      argv overrides the scenario-derived repoRoot.
+import assert from "node:assert/strict";
+import { execFile } from "node:child_process";
+import { chmodSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { test } from "node:test";
+import { promisify } from "node:util";
+import { parseTranscript } from "../../graders/historian/grader-support.mjs";
+const exec = promisify(execFile);
+const SCRIPT = fileURLToPath(new URL("../../graders/historian/run-scenario.sh", import.meta.url));
+/** Recorded scenario-Brief section — the exact bytes run-scenario.sh awk-extracts. */
+const BRIEF_TEXT = "Do the seam thing.";
+const SCENARIO = `# Scenario 01 — seam probe
+
+## Brief
+${BRIEF_TEXT}
+
+## Expected Behavior
+
+n/a for the stub lane.
+`;
+const STUB_OPENCODE = `#!/usr/bin/env node
+// stub opencode: records the --message value to $STUB_PROMPT_FILE and the FULL
+// argv (one token per line) to $STUB_ARGV_FILE, then echoes an opencode-format
+// 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.
+import { writeFileSync } from "node:fs";
+const args = process.argv.slice(2);
+const i = args.indexOf("--message");
+const message = i >= 0 ? args[i + 1] ?? "" : "";
+const capture = process.env.STUB_PROMPT_FILE;
+if (capture !== undefined && capture.length > 0) writeFileSync(capture, message, "utf8");
+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");
+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 } });
+`;
+function harness(t) {
+    const root = mkdtempSync(path.join(tmpdir(), "seam-rs-"));
+    t.after(() => rmSync(root, { recursive: true, force: true }));
+    const binDir = path.join(root, "bin");
+    mkdirSync(binDir, { recursive: true });
+    const stub = path.join(binDir, "oc-stub");
+    writeFileSync(stub, STUB_OPENCODE, "utf8");
+    chmodSync(stub, 0o755);
+    const repoRoot = path.join(root, "repo");
+    mkdirSync(path.join(repoRoot, "scenarios"), { recursive: true });
+    writeFileSync(path.join(repoRoot, "scenarios", "01-seam.md"), SCENARIO, "utf8");
+    return {
+        repoRoot,
+        promptFile: path.join(root, "prompt.txt"),
+        transcript: path.join(root, "transcript.jsonl"),
+        bin: binDir,
+    };
+}
+/** Invokes the shipped contract `bash run-scenario.sh <unit.id> <scenario-file>`. */
+async function runScenario(h, opts = {}) {
+    const scenarioFile = opts.scenario ?? path.join(h.repoRoot, "scenarios", "01-seam.md");
+    const argv = [SCRIPT, "scenario-01", scenarioFile, ...(opts.args ?? [])];
+    await exec("bash", argv, {
+        env: {
+            ...process.env,
+            ABATHUR_TRANSCRIPT: h.transcript,
+            STUB_PROMPT_FILE: h.promptFile,
+            opencodeBin: path.join(h.bin, "oc-stub"),
+            ...(opts.argvFile === undefined ? {} : { STUB_ARGV_FILE: opts.argvFile }),
+            ...(opts.env ?? {}),
+        },
+    });
+}
+function prompt(h) {
+    return readFileSync(h.promptFile, "utf8");
+}
+function writeNote(h, name, body) {
+    const dir = path.join(h.repoRoot, "abathur-notes");
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(path.join(dir, name), body, "utf8");
+}
+const RUN_CARD_HEADING = "## Run card";
+test("no-notes: captured brief is byte-identical to the bare scenario Brief (F1 invariant)", async (t) => {
+    const h = harness(t);
+    await runScenario(h);
+    assert.equal(prompt(h), BRIEF_TEXT, "brief must carry exactly the awk-extracted Brief bytes");
+    assert.ok(!prompt(h).includes(RUN_CARD_HEADING), "no notes ⇒ no run-card section ever");
+});
+test("empty-notes-dir: a notes directory without *.md changes nothing", async (t) => {
+    const h = harness(t);
+    mkdirSync(path.join(h.repoRoot, "abathur-notes"), { recursive: true });
+    writeFileSync(path.join(h.repoRoot, "abathur-notes", "ignore.txt"), "not a card\n", "utf8");
+    await runScenario(h);
+    assert.equal(prompt(h), BRIEF_TEXT);
+    assert.ok(!prompt(h).includes(RUN_CARD_HEADING));
+});
+test("one-note: brief ends with '## Run card' + verbatim note content", async (t) => {
+    const h = harness(t);
+    const note = "Prefer concise incident pages with a Related Pages tail.\n";
+    writeNote(h, "style.md", note);
+    await runScenario(h);
+    const expected = `${BRIEF_TEXT}\n\n${RUN_CARD_HEADING}\n\n${note.replace(/\n+$/, "")}`;
+    assert.equal(prompt(h), expected, "run card is appended fenced under its heading, verbatim");
+});
+test("determinism: two consecutive runs over the same tree ⇒ byte-identical prompt + transcript", async (t) => {
+    const h = harness(t);
+    writeNote(h, "a.md", "card alpha\n");
+    await runScenario(h);
+    const firstPrompt = prompt(h);
+    const firstTranscript = readFileSync(h.transcript, "utf8");
+    await runScenario(h);
+    assert.equal(prompt(h), firstPrompt, "prompt bytes must not move between identical runs");
+    assert.equal(readFileSync(h.transcript, "utf8"), firstTranscript, "transcript bytes must not move");
+});
+test("stale-state: changing the note between runs changes the brief and the transcript", async (t) => {
+    const h = harness(t);
+    writeNote(h, "a.md", "alpha card body\n");
+    await runScenario(h);
+    const before = prompt(h);
+    writeNote(h, "a.md", "beta card body\n");
+    await runScenario(h);
+    const after = prompt(h);
+    assert.ok(before.includes("alpha card body") && !after.includes("alpha card body"));
+    assert.ok(after.includes("beta card body"));
+    assert.notEqual(after, before, "a changed tree must produce a changed brief");
+});
+test("PLUM flow: planted instruction reaches brief ⇒ stub transcript finalMessage", async (t) => {
+    const h = harness(t);
+    writeNote(h, "plum.md", "Reply with the single word PLUM at the very end.\n");
+    await runScenario(h);
+    assert.ok(prompt(h).includes("Reply with the single word PLUM at the very end."));
+    const meta = parseTranscript(readFileSync(h.transcript, "utf8"));
+    assert.match(meta.finalMessage, /PLUM/, "note ⇒ brief ⇒ transcript delivery must be provable");
+});
+test("multi-note: concatenated in LC_ALL=C filename order", async (t) => {
+    const h = harness(t);
+    writeNote(h, "zeta.md", "zeta body\n");
+    writeNote(h, "alpha.md", "alpha body\n");
+    await runScenario(h);
+    const p = prompt(h);
+    assert.equal(p, `${BRIEF_TEXT}\n\n${RUN_CARD_HEADING}\n\nalpha body\n\nzeta body`, "cat order = sorted filenames, contents joined verbatim");
+});
+test("explicit repoRoot argv overrides the scenario-derived one", async (t) => {
+    const h = harness(t);
+    writeNote(h, "a.md", "incumbent-tree card\n"); // derived from scenario dir: NOT used
+    const otherRoot = path.join(path.dirname(h.repoRoot), "elsewhere");
+    mkdirSync(path.join(otherRoot, "abathur-notes"), { recursive: true });
+    writeFileSync(path.join(otherRoot, "abathur-notes", "a.md"), "elsewhere card\n", "utf8");
+    await runScenario(h, { args: [otherRoot] });
+    assert.ok(prompt(h).includes("elsewhere card"), "argv repoRoot wins");
+    assert.ok(!prompt(h).includes("incumbent-tree card"));
+});
+// Model pinning (task-06 follow-up): the transcript JSONL carries NO model
+// identity and bundle provenance copies spec.bench.agentModel verbatim
+// (bundle-common.ts) — an unpinned `opencode run` measures the provider
+// DEFAULT while the ledger claims the spec value. ABATHUR_AGENT_MODEL is the
+// engine's existing sandboxEnv channel (fixture.ts); the script must honor it
+// with --model, and unset/empty must keep argv byte-identical (F1).
+function argvTokens(file) {
+    return readFileSync(file, "utf8").split("\n").slice(0, -1);
+}
+const BASELINE_ARGV = ["run", "--command", "historian", "--auto", "--format", "json", "--message", BRIEF_TEXT];
+test("model pin: ABATHUR_AGENT_MODEL set ⇒ argv carries --model <value>, brief still flows", async (t) => {
+    const h = harness(t);
+    const argvFile = path.join(path.dirname(h.promptFile), "argv-pinned.txt");
+    await runScenario(h, {
+        argvFile,
+        env: { ABATHUR_AGENT_MODEL: "testprov/testmodel" },
+    });
+    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.at(-2), "--message", "pin must not disturb the brief channel");
+    assert.equal(prompt(h), BRIEF_TEXT);
+});
+test("model pin: ABATHUR_AGENT_MODEL unset ⇒ argv byte-identical to the pre-fix baseline", async (t) => {
+    const h = harness(t);
+    const argvFile = path.join(path.dirname(h.promptFile), "argv-unset.txt");
+    await runScenario(h, { argvFile, env: { ABATHUR_AGENT_MODEL: undefined } });
+    assert.deepEqual(argvTokens(argvFile), BASELINE_ARGV);
+});
+test("model pin: ABATHUR_AGENT_MODEL empty string ⇒ treated as unset (same argv)", async (t) => {
+    const h = harness(t);
+    const argvFile = path.join(path.dirname(h.promptFile), "argv-empty.txt");
+    await runScenario(h, { argvFile, env: { ABATHUR_AGENT_MODEL: "" } });
+    assert.deepEqual(argvTokens(argvFile), BASELINE_ARGV);
+});

package/dist/test/status-repo.test.js

@@ -0,0 +1,72 @@
+// S4 engine seam (deliverable f) — `abathur status` must resolve the stored
+// repoPath through effectiveRepoPath (the run/genome/kernel/self-eval pattern,
+// run-loop.ts:142) before touching ANY filesystem seam. Pre-fix, status passed
+// the STORED UNRESOLVED `${VAR}` literal as the git cwd; Node reports a missing
+// cwd as the misleading `spawn git ENOENT` (task-09 evidence §C). Pins:
+//  (1) env-literal genome + env exported ⇒ status exits 0 (real git + ledger
+//      seam on the resolved tree — never an ENOENT);
+//  (2) env-literal genome + env UNSET ⇒ clean exit 2 NAMING the variable, and
+//      the misleading spawn-ENOENT string is gone;
+//  (3) concrete repoPath keeps working unchanged (regression guard).
+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_STATUS_REPO";
+async function fixture(t, label) {
+    const root = mkdtempSync(path.join(os.tmpdir(), "seam-status-"));
+    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"));
+    // Register under the exported env (add resolves the same way run does),
+    // storing the spec with the UNRESOLVED literal (0.2.x convention).
+    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 };
+}
+function cli(f, label, env) {
+    return spawnSync(process.execPath, [CLI, "status", label], {
+        encoding: "utf8",
+        cwd: f.root,
+        env: {
+            ...process.env,
+            ABATHUR_CONFIG: path.join(f.configDir, "config.jsonc"),
+            HOME: path.join(f.root, "home"),
+            XDG_CACHE_HOME: path.join(f.root, "xdg-cache"),
+            ...env,
+        },
+    });
+}
+test("status resolves an env-literal repoPath via effectiveRepoPath: exported ⇒ exit 0", async (t) => {
+    const f = await fixture(t, "seam-self");
+    const r = cli(f, "seam-self", { [LIT_VAR]: f.repo });
+    assert.equal(r.status, 0, `stdout: ${r.stdout}\nstderr: ${r.stderr}`);
+    assert.match(r.stdout, /genome: seam-self/);
+    assert.ok(!r.stderr.includes("ENOENT"), "the misleading spawn-ENOENT string must be gone");
+});
+test("status on an env-literal repoPath with the env UNSET: clean exit 2 naming the variable", async (t) => {
+    const f = await fixture(t, "seam-unset");
+    const r = cli(f, "seam-unset", { [LIT_VAR]: undefined });
+    assert.equal(r.status, 2);
+    assert.match(r.stderr, new RegExp(`requires env var ${LIT_VAR}`));
+    assert.ok(!r.stderr.includes("ENOENT"), `misleading ENOENT returned: ${r.stderr}`);
+});

package/graders/historian/grader-core.d.mts

@@ -1,10 +1,14 @@
 // Type declarations for grader-core.mjs — the plan-185 scoring engine.
 // Runtime lives in the .mjs; this file is the compile-time contract.
 
+import type { ToolEvent } from "./grader-support.mjs";
+
 export type DimKey = "A" | "B" | "C" | "D" | "E" | "F" | "G" | "H";
 export type Bit = 0 | 1;
 export type FullDims = Readonly<Record<DimKey, Bit>>;
 export type WorthDims = Readonly<{ G: Bit; H: Bit; J: Bit }>;
+export type IntegrityDims = Readonly<{ I: Bit; J: Bit }>;
+export type IntegrityNote = string;
 
 export interface CreatedPage {
   readonly path: string;
@@ -13,6 +17,16 @@ export interface CreatedPage {
   readonly content: string;
 }
 
+/** Post-run sandbox row + seed captures the I/J checkers diff evidence against. */
+export interface IntegrityState {
+  readonly sandboxRows: ReadonlyArray<{ readonly path: string; readonly id: string; readonly description: string }>;
+  readonly content: Readonly<Record<string, string>>;
+  readonly rowIdByPath: ReadonlyMap<string, string>;
+  readonly descByPath: ReadonlyMap<string, string>;
+  readonly seedDescByPath: ReadonlyMap<string, string>;
+  readonly seedContent: Readonly<Record<string, string>>;
+}
+
 export interface Observation {
   readonly scenarioNo: number;
   readonly created: readonly CreatedPage[];
@@ -31,6 +45,10 @@ export interface Observation {
   readonly backlinkBodies: ReadonlyArray<{ readonly path: string; readonly locale: string; readonly content: string }>;
   readonly finalMessage: string;
   readonly urlChecks: readonly { readonly url: string; readonly status: number }[];
+  /** Required for integrity units (scenario-10/11/12): transcript tool events. */
+  readonly tools?: readonly ToolEvent[] | undefined;
+  /** Required for integrity units: seed-state-derived wiki context. */
+  readonly integrity?: IntegrityState | undefined;
 }
 
 export interface UnitScore {
@@ -47,7 +65,32 @@ export type ScoredUnit = UnitScore & {
 
 export const WEIGHTS: Readonly<Record<DimKey, number>>;
 
+export const S10_PATH: string;
+export const S10_DECOY: string;
+export const S11_CARD: string;
+export const S11_SUPERSEDE: string;
+export const S11_SEED_DATE: string;
+export const VERIFY_TOKEN: string;
+export const S12_JUNK: readonly string[];
+export const S12_DECOY: readonly string[];
+export const APPLICABLE: Readonly<Record<number, Readonly<Record<string, number>>>>;
+
+export interface StatusTokens {
+  readonly header: string | null;
+  readonly rows: readonly string[];
+}
+
+export interface IntegrityResult extends IntegrityDims {
+  readonly notes: readonly IntegrityNote[];
+}
+
 export function computeDims(obs: Observation): FullDims;
 export function judgment(scenarioNo: number, created: readonly CreatedPage[], finalMessage: string): Bit;
 export function scoreFromDims(scenarioNo: number, dims: FullDims | WorthDims): UnitScore;
 export function scoreUnit(obs: Observation): ScoredUnit;
+export function statusTokens(content: string): StatusTokens;
+/** Parse a tool event's output as JSON, following opencode's >45KB externalization
+ *  stubs (`Full output saved to: <ref>`) to the ref file. Fail-closed: undefined
+ *  when neither the inline output nor the referenced file parses. */
+export function resolveToolJson(event: ToolEvent): unknown;
+export function integrityDims(scenarioNo: number, obs: Observation, tools: readonly ToolEvent[], integrity: IntegrityState): IntegrityResult;