@tachikomagundam/abathur 0.1.0

package/dist/test/historian-genome.test.js

@@ -0,0 +1,134 @@
+// Task-14: the historian genome instance + the additive dry-run requires-probe.
+// Everything here stays offline: fake repos in tmp dirs, `test -f` probes only.
+import assert from "node:assert/strict";
+import { mkdirSync, mkdtempSync, readFileSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { test } from "node:test";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { loadGenomeSpecFile } from "../core/spec.js";
+import { registerGenome, requireGenomesByLabel } from "../core/genome.js";
+import { runEvolution } from "../core/evolve/run-loop.js";
+import { ExitSignal } from "../exit.js";
+const exec = promisify(execFile);
+const EXAMPLE = path.join(import.meta.dirname, "..", "..", "config", "genomes", "historian.example.jsonc");
+/** Replace every ${NAME} with a deterministic fake value (materialization stand-in). */
+function materialize(text) {
+    return text.replace(/\$\{([A-Z_][A-Z0-9_]*)\}/g, (_all, name) => {
+        if (name.endsWith("WIKI_BASE"))
+            return "http://wiki.invalid:3000";
+        if (name.endsWith("WIKI_OPS"))
+            return "/fake/opt/wiki-ops/wiki-ops.py";
+        if (name.includes("REPO"))
+            return "/fake/repo";
+        return "/fake/" + name.toLowerCase();
+    });
+}
+function materializeToFile() {
+    const out = path.join(mkdtempSync(path.join(tmpdir(), "t14-gen-")), "historian.jsonc");
+    writeFileSync(out, materialize(readFileSync(EXAMPLE, "utf8")), "utf8");
+    return out;
+}
+test("historian.example.jsonc: zero machine literals, placeholders only", () => {
+    const text = readFileSync(EXAMPLE, "utf8");
+    assert.doesNotMatch(text, /\/home\//, "repo-tracked config must not embed /home/... literals");
+    assert.match(text, /\$\{ABATHUR_HISTORIAN_REPO\}/);
+    assert.match(text, /\$\{ABATHUR_WIKI_BASE\}/);
+});
+test("historian.example.jsonc materializes into a valid GenomeSpec (plan 181-188 contract)", () => {
+    const spec = loadGenomeSpecFile(materializeToFile());
+    assert.equal(spec.label, "historian");
+    assert.equal(spec.bench.type, "opencode-fixture-scenarios");
+    assert.equal(spec.bench.units.length, 9);
+    assert.deepEqual(spec.bench.units.map((u) => u.id), [
+        "scenario-01", "scenario-02", "scenario-03", "scenario-04", "scenario-05",
+        "scenario-06", "scenario-07", "scenario-08", "scenario-09",
+    ]);
+    const train = spec.bench.units.filter((u) => u.split === "train").map((u) => u.id);
+    const val = spec.bench.units.filter((u) => u.split === "val").map((u) => u.id);
+    assert.deepEqual(train, ["scenario-01", "scenario-02", "scenario-03", "scenario-05", "scenario-06", "scenario-07", "scenario-08"]);
+    assert.deepEqual(val, ["scenario-04", "scenario-09"]);
+    // unit paths are repo-RELATIVE: bundle self-description digests tree content (bundle-common.ts:97).
+    assert.equal(spec.bench.units[0]?.path, "scenarios/01-new-finding.md");
+    assert.equal(spec.bench.units[8]?.path, "scenarios/09-timeline-week-groups.md");
+    assert.deepEqual(spec.bench.stats, { halfWidth: 0.15, minEffect: 0.1, nReps: { initial: 1, max: 3 } });
+    assert.ok(spec.bench.timeoutS >= 600, "real agent runs need a generous per-unit cap");
+    assert.ok(spec.bench.agentModel !== undefined && spec.bench.agentModel.includes("/"));
+    assert.match(spec.bench.seedCommand ?? "", /seed_sandbox\.sh/);
+    assert.match(spec.bench.resetCommand ?? "", /reset-sandbox\.sh/);
+    assert.match(spec.bench.runCommand, /run-scenario\.sh/);
+    assert.match(spec.bench.graderCommand, /graders\/historian\/grader\.mjs/);
+    assert.equal(spec.bench.judgeCommand, undefined); // unwired: judgeModel rule stays vacuous
+    assert.ok(spec.requires !== undefined && spec.requires.length === 2);
+    assert.ok(spec.kernel.immutableGlobs.includes("scenarios/**"));
+    assert.ok(spec.kernel.immutableGlobs.includes("rubric.md"));
+    assert.ok(spec.budget.maxCandidates >= 1);
+});
+// ------------------------------------------------- dry-run requires probes
+async function fixtureRepo(files) {
+    const dir = mkdtempSync(path.join(tmpdir(), "t14-fr-"));
+    for (const [name, text] of Object.entries(files)) {
+        mkdirSync(path.join(dir, path.dirname(name)), { recursive: true });
+        writeFileSync(path.join(dir, name), text, "utf8");
+    }
+    await exec("git", ["init", "-b", "main", dir]);
+    await exec("git", ["-C", dir, "add", "-A"]);
+    await exec("git", [
+        "-C", dir,
+        "-c", "user.name=t", "-c", "user.email=t@t",
+        "commit", "-m", "seed",
+    ]);
+    return dir;
+}
+function fixtureSpec(repo, label, probeFile, opts = {}) {
+    const type = opts.type ?? "opencode-fixture-scenarios";
+    const doc = {
+        label,
+        repoPath: repo,
+        bench: {
+            type,
+            units: [
+                { id: "u1", path: "units/u1.md", split: "train" },
+                { id: "u2", path: "units/u2.md", split: "val" },
+            ],
+            runCommand: "true {unit.id}",
+            graderCommand: "true {unit.id}",
+            ...(type === "opencode-fixture-scenarios" ? { agentModel: "family/model" } : {}),
+            timeoutS: 600,
+            stats: { halfWidth: 0.15, minEffect: 0.1, nReps: { initial: 1, max: 3 } },
+        },
+        budget: { maxCandidates: 1, maxModelCalls: 4, maxTokens: 1000, maxWallS: 1000 },
+        kernel: { immutableGlobs: ["sealed.txt"] },
+    };
+    if (opts.withRequires ?? true)
+        doc["requires"] = [{ cmd: "test", args: ["-f", probeFile], probeExit: 0 }];
+    return doc;
+}
+async function dryRun(specDoc) {
+    const configDir = mkdtempSync(path.join(tmpdir(), "t14-cfg-"));
+    const specFile = path.join(configDir, "spec.jsonc");
+    writeFileSync(specFile, JSON.stringify(specDoc, null, 2), "utf8");
+    const label = String(specDoc.label);
+    registerGenome(configDir, specFile);
+    const entry = requireGenomesByLabel(configDir, label).entries[0];
+    if (entry === undefined)
+        throw new Error(`entry ${label} missing after register`);
+    return runEvolution({ entry, configDir, dryRun: true });
+}
+test("dry-run (fixture type): requires probes run WITHOUT spawning opencode and print OK", async () => {
+    const repo = await fixtureRepo({ "sealed.txt": "seal\n", "units/u1.md": "a\n", "units/u2.md": "b\n" });
+    const out = await dryRun(fixtureSpec(repo, "probe-ok", "sealed.txt"));
+    assert.equal(out.exitCode, 0);
+    assert.ok(out.lines.some((l) => /requires probes: 1\/1 OK/.test(l)), out.lines.join("\n"));
+});
+test("dry-run (fixture type): failing requires probe exits 2 naming the prerequisite, before any plan", async () => {
+    const repo = await fixtureRepo({ "sealed.txt": "seal\n", "units/u1.md": "a\n", "units/u2.md": "b\n" });
+    await assert.rejects(() => dryRun(fixtureSpec(repo, "probe-bad", "missing-file.txt")), (e) => e instanceof ExitSignal && e.code === 2 && /missing-file\.txt/.test(e.message));
+});
+test("dry-run (toy type, no requires): no probe line", async () => {
+    const repo = await fixtureRepo({ "sealed.txt": "seal\n", "units/u1.md": "a\n", "units/u2.md": "b\n" });
+    const out = await dryRun(fixtureSpec(repo, "toy-nodefault", "sealed.txt", { type: "toy", withRequires: false }));
+    assert.equal(out.exitCode, 0);
+    assert.ok(!out.lines.some((l) => /requires probes/.test(l)), out.lines.join("\n"));
+});

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

@@ -0,0 +1,148 @@
+// Task-14 IO tests: transcript parsing (recorded opencode --format json events),
+// wiki pre/post diffing, and the grader CLI contract — all OFFLINE
+// (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 { tmpdir } from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { test } from "node:test";
+import { diffWiki, parseTranscript, scenarioNoFromUnit } from "../../graders/historian/grader-support.mjs";
+import { FIXTURE5_PATHS, GOOD_FINAL, GOOD_PAGE } from "./fixtures-historian.js";
+const GRADER = fileURLToPath(new URL("../../graders/historian/grader.mjs", import.meta.url));
+// Recorded from a real `opencode run --format json "say exactly OK"` smoke run (2026-09-10).
+const RECORDED_TRANSCRIPT = [
+    '{"type":"step_start","part":{"type":"step-start"}}',
+    '{"type":"text","part":{"type":"text","text":"OK"}}',
+    '{"type":"step_finish","part":{"type":"step-finish","reason":"stop","tokens":{"total":34849,"input":6,"output":69,"reasoning":0,"cache":{"write":34774,"read":0}}}}',
+].join("\n");
+function transcript(text, total = 1234) {
+    return [
+        '{"type":"step_start","part":{"type":"step-start"}}',
+        JSON.stringify({ type: "text", part: { type: "text", text } }),
+        `{"type":"step_finish","part":{"type":"step-finish","reason":"stop","tokens":{"total":${total},"input":1,"output":2}}}`,
+    ].join("\n");
+}
+test("parseTranscript: recorded smoke events ⇒ finalMessage/tokensEst/turns", () => {
+    const m = parseTranscript(RECORDED_TRANSCRIPT);
+    assert.equal(m.finalMessage, "OK");
+    assert.equal(m.tokensEst, 34849);
+    assert.equal(m.turns, 1);
+});
+test("parseTranscript: multi-turn sums step_finish totals; final message is the LAST text", () => {
+    const multi = [
+        '{"type":"text","part":{"type":"text","text":"working..."}}',
+        '{"type":"step_finish","part":{"tokens":{"total":1000}}}',
+        '{"type":"text","part":{"type":"text","text":"done now"}}',
+        '{"type":"step_finish","part":{"tokens":{"total":500}}}',
+    ].join("\n");
+    const m = parseTranscript(multi);
+    assert.equal(m.finalMessage, "done now");
+    assert.equal(m.tokensEst, 1500);
+    assert.equal(m.turns, 2);
+});
+test("parseTranscript: garbage / empty / never-finished ⇒ throws (CLI exits nonzero ⇒ adapter inconclusive)", () => {
+    assert.throws(() => parseTranscript("not json\n{broken"));
+    assert.throws(() => parseTranscript(""));
+    assert.throws(() => parseTranscript('{"type":"step_start","part":{}}')); // no step_finish ⇒ run never completed
+});
+test("scenarioNoFromUnit: scenario-07 ⇒ 7; bare 07 ⇒ 7", () => {
+    assert.equal(scenarioNoFromUnit("scenario-07"), 7);
+    assert.equal(scenarioNoFromUnit("07"), 7);
+});
+function row(id, p, updatedAt, locale = "en") {
+    return { id, path: p, locale, updatedAt };
+}
+const PRE = [
+    ...FIXTURE5_PATHS.map((p, i) => row(400 + i, p, "2026-09-10T00:00:00Z")),
+    row(4, "infra/network", "2026-09-01T00:00:00Z"),
+];
+test("diffWiki: new sandbox page ⇒ created; index updatedAt bump ⇒ indexUpdated; untouched fixture ⇒ nothing", () => {
+    const post = [
+        ...PRE.filter((r) => r.path !== "_sandbox/index"),
+        row(400, "_sandbox/index", "2026-09-10T02:00:00Z"),
+        row(600, "_sandbox/llm-inference/qwen27b-threading", "2026-09-10T02:05:00Z"),
+    ];
+    const d = diffWiki({ pre: [...PRE], post, content: { 400: "idx text", 600: GOOD_PAGE }, scenarioNo: 1 });
+    assert.equal(d.created.length, 1);
+    assert.equal(d.created[0]?.path, "_sandbox/llm-inference/qwen27b-threading");
+    assert.equal(d.indexUpdated, true);
+    assert.equal(d.indexContent, "idx text");
+    assert.deepEqual(d.outside, { created: [], updated: [], deleted: [] });
+    assert.deepEqual(d.deletedFixturePaths, []);
+});
+test("diffWiki: move (same id, new path) is moved-not-created-not-deleted", () => {
+    const post = PRE.map((r) => (r.path === "_sandbox/mess/gpu-notes" ? { ...r, path: "_sandbox/runbooks/gpu-fan-curve" } : r));
+    const d = diffWiki({ pre: [...PRE], post, content: {}, scenarioNo: 4 });
+    assert.deepEqual(d.moved, [{ from: "_sandbox/mess/gpu-notes", to: "_sandbox/runbooks/gpu-fan-curve" }]);
+    assert.equal(d.created.length, 0);
+    assert.deepEqual(d.deletedFixturePaths, []);
+});
+test("diffWiki: hard delete ⇒ deletedFixturePaths; non-sandbox row gone ⇒ outside.deleted; edited non-sandbox ⇒ outside.updated", () => {
+    const post = PRE.filter((r) => r.path !== "_sandbox/mess/untitled").map((r) => r.path === "infra/network" ? { ...r, updatedAt: "2026-09-10T03:00:00Z" } : r);
+    const d = diffWiki({ pre: [...PRE], post, content: {}, scenarioNo: 1 });
+    assert.deepEqual(d.deletedFixturePaths, ["_sandbox/mess/untitled"]);
+    assert.deepEqual(d.outside, { created: [], updated: ["infra/network"], deleted: [] });
+});
+test("diffWiki: scenario 09 whitelists _meta/page-map refresh as the only outside update", () => {
+    const pre = [...PRE, row(700, "_meta/page-map", "2026-09-01T00:00:00Z")];
+    const post = [...PRE, row(700, "_meta/page-map", "2026-09-10T04:00:00Z")];
+    const d = diffWiki({ pre, post, content: {}, scenarioNo: 9 });
+    assert.deepEqual(d.outside.updated, []);
+});
+// ------------------------------------------------------------------ CLI
+function sandboxWith(transcriptText, pre) {
+    const dir = mkdtempSync(path.join(tmpdir(), "t14-gr-"));
+    mkdirSync(path.join(dir, ".bench", "transcripts"), { recursive: true });
+    writeFileSync(path.join(dir, ".bench", "transcripts", "scenario-01.jsonl"), transcriptText);
+    writeFileSync(path.join(dir, ".bench", "wiki-pre.json"), JSON.stringify(pre));
+    return dir;
+}
+function runGrader(cwd, argv, env) {
+    return new Promise((resolve) => {
+        execFile(process.execPath, [GRADER, ...argv], { cwd, env: { ...process.env, ...env } }, (err, stdout, stderr) => resolve({ code: err === null ? 0 : typeof err.code === "number" ? err.code : 1, stdout, stderr }));
+    });
+}
+const POST_OK = [
+    ...PRE.filter((r) => r.path !== "_sandbox/index"),
+    row(400, "_sandbox/index", "2026-09-10T02:00:00Z"),
+    { id: 600, path: "_sandbox/llm-inference/qwen27b-threading", locale: "en", updatedAt: "2026-09-10T02:05:00Z", title: "Qwen 27B Threading Findings" },
+];
+test("grader CLI (offline, passing scenario-01): emits contract JSON line score=1 pass=true", async () => {
+    const dir = sandboxWith(transcript(GOOD_FINAL, 5678), PRE);
+    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: {} }));
+    const r = await runGrader(dir, ["scenario-01", "scenarios/01-new-finding.md", "http://localhost:3000"], {
+        ABATHUR_GRADER_STATE: stateFile,
+    });
+    assert.equal(r.code, 0, r.stderr);
+    const line = r.stdout.trim().split("\n").at(-1) ?? "";
+    const parsed = JSON.parse(line);
+    assert.equal(parsed.unit, "scenario-01");
+    assert.equal(parsed.score, 1);
+    assert.equal(parsed.pass, true);
+    assert.equal(parsed.metrics.tokensEst, 5678);
+    assert.equal(parsed.metrics.turns, 1);
+});
+test("grader CLI (offline, G-gated): outside-sandbox edit ⇒ pass=false despite Σ=11, score=11/12", async () => {
+    const dir = sandboxWith(transcript(GOOD_FINAL), PRE);
+    const post = POST_OK.map((r) => (r.path === "infra/network" ? { ...r, updatedAt: "2026-09-10T09:00:00Z" } : r));
+    const stateFile = path.join(dir, "state.json");
+    writeFileSync(stateFile, JSON.stringify({ post, content: { 400: "[qwen27b](/_sandbox/llm-inference/qwen27b-threading)", 600: GOOD_PAGE }, urlStatus: {} }));
+    const r = await runGrader(dir, ["scenario-01", "scenarios/01-new-finding.md", "http://localhost:3000"], {
+        ABATHUR_GRADER_STATE: stateFile,
+    });
+    assert.equal(r.code, 0, r.stderr);
+    const parsed = JSON.parse(r.stdout.trim().split("\n").at(-1) ?? "{}");
+    assert.equal(parsed.pass, false);
+    assert.equal(parsed.score, 11 / 12);
+});
+test("grader CLI: garbage transcript ⇒ nonzero exit, no score line (adapter ⇒ inconclusive, never 0-score)", async () => {
+    const dir = sandboxWith("not json at all\n{broken", PRE);
+    const r = await runGrader(dir, ["scenario-01", "scenarios/01-new-finding.md", "http://localhost:3000"], {
+        ABATHUR_GRADER_STATE: undefined,
+    });
+    assert.notEqual(r.code, 0);
+    assert.equal(r.stdout.trim(), "");
+});

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

@@ -0,0 +1,209 @@
+// Task-14 RED/GREEN: pure scoring math of the historian grader (plan 185).
+// Arithmetic shown inline: weights A2 B2 C2 D2 E1 F1 G1 H1 = 12 total.
+// Full scenario: score = Σ(w×d)/12, pass = Σ ≥ 10 ∧ G=1 (G=0 ⇒ hard fail).
+// Scenario 05: dims A-F N/A; score = (G+H+judgment)/3, pass = G ∧ H ∧ judgment.
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import { computeDims, judgment, scoreFromDims, scoreUnit, WEIGHTS, } from "../../graders/historian/grader-core.mjs";
+import { GOOD_FINAL, GOOD_INCIDENT_PAGE, GOOD_PAGE, FIXTURE5_PATHS, goodCreated, obs } from "./fixtures-historian.js";
+function full(all) {
+    return { A: all, B: all, C: all, D: all, E: all, F: all, G: all, H: all };
+}
+test("weights table sums to exactly 12 (A2+B2+C2+D2=8, E1+F1+G1+H1=4)", () => {
+    const sum = Object.values(WEIGHTS).reduce((a, b) => a + b, 0);
+    assert.equal(sum, 12);
+    assert.deepEqual({ ...WEIGHTS }, { A: 2, B: 2, C: 2, D: 2, E: 1, F: 1, G: 1, H: 1 });
+});
+test("scoreFromDims full scenario all-1: Σ=12, score=12/12=1, pass", () => {
+    const r = scoreFromDims(1, full(1));
+    assert.equal(r.total, 12); // 2+2+2+2+1+1+1+1
+    assert.equal(r.applicableWeight, 12);
+    assert.equal(r.score, 1); // 12/12
+    assert.equal(r.pass, true);
+});
+test("scoreFromDims G hard gate: Σ=11 ≥ 10 but G=0 ⇒ pass=false, score=11/12", () => {
+    // 12 total − G(1×0) = 11; 11/12 exactly, no rounding contract.
+    const r = scoreFromDims(1, { ...full(1), G: 0 });
+    assert.equal(r.total, 11);
+    assert.equal(r.score, 11 / 12);
+    assert.equal(r.pass, false);
+});
+test("scoreFromDims below floor: C=0,D=0 ⇒ Σ=12−2−2=8 < 10 ⇒ fail, score=8/12", () => {
+    const r = scoreFromDims(2, { ...full(1), C: 0, D: 0 });
+    assert.equal(r.total, 8);
+    assert.equal(r.score, 8 / 12);
+    assert.equal(r.pass, false);
+});
+test("scoreFromDims scenario 05: (G,H,J) triples score over applicable weight 3", () => {
+    const pass = scoreFromDims(5, { G: 1, H: 1, J: 1 });
+    assert.equal(pass.score, 1); // (1+1+1)/3
+    assert.equal(pass.applicableWeight, 3);
+    assert.equal(pass.pass, true);
+    const noJudge = scoreFromDims(5, { G: 1, H: 1, J: 0 });
+    assert.equal(noJudge.score, 2 / 3); // (1+1+0)/3
+    assert.equal(noJudge.pass, false);
+    const noG = scoreFromDims(5, { G: 0, H: 1, J: 1 });
+    assert.equal(noG.score, 2 / 3); // (0+1+1)/3
+    assert.equal(noG.pass, false); // G=0 hard gate
+});
+test("computeDims: clean scenario-01 observation ⇒ all dims 1 ⇒ scoreUnit passes", () => {
+    const dims = computeDims(obs());
+    assert.deepEqual(dims, full(1));
+    const r = scoreUnit(obs());
+    assert.equal(r.score, 1);
+    assert.equal(r.pass, true);
+});
+test("computeDims D: raw float 47.3829104823 in created page ⇒ D=0", () => {
+    const dirty = GOOD_PAGE.replace("47.4", "47.3829104823");
+    const dims = computeDims(obs({ created: [goodCreated({ content: dirty })] }));
+    assert.equal(dims.D, 0);
+});
+test("computeDims A: root-level page (_sandbox/depth-1) fails non-08 scenarios", () => {
+    const dims = computeDims(obs({ created: [goodCreated({ path: "_sandbox/tuning-notes" })] }));
+    assert.equal(dims.A, 0);
+});
+test("computeDims A: incident date slug allowed for scenario 02/06, rejected for 01", () => {
+    const ok = computeDims(obs({
+        scenarioNo: 2,
+        created: [
+            goodCreated({
+                path: "_sandbox/troubleshooting/outage-2026-08-28",
+                title: "Wiki ES OOM 2026-08-28",
+                content: GOOD_INCIDENT_PAGE,
+            }),
+        ],
+        livePaths: [...FIXTURE5_PATHS, "_sandbox/troubleshooting/outage-2026-08-28"],
+        allPaths: [...FIXTURE5_PATHS, "_sandbox/troubleshooting/outage-2026-08-28"],
+        indexContent: "[outage](/_sandbox/troubleshooting/outage-2026-08-28) (Active)",
+    }));
+    assert.equal(ok.A, 1);
+    const bad = computeDims(obs({ created: [goodCreated({ path: "_sandbox/llm-inference/run-2026-08-28" })] }));
+    assert.equal(bad.A, 0);
+});
+test("computeDims B: scenario 03 integrates ⇒ B=1 only when rocm-tuning was updated; new rocm twin ⇒ B=0", () => {
+    const integrated = computeDims(obs({
+        scenarioNo: 3,
+        created: [],
+        updated: [{ path: "_sandbox/llm-inference/rocm-tuning", locale: "en", title: "ROCm Tuning", content: GOOD_PAGE }],
+    }));
+    assert.equal(integrated.B, 1);
+    const duplicated = computeDims(obs({
+        scenarioNo: 3,
+        updated: [],
+        created: [goodCreated({ path: "_sandbox/llm-inference/rocm-hsa-override-results" })],
+        livePaths: [...FIXTURE5_PATHS, "_sandbox/llm-inference/rocm-hsa-override-results"],
+    }));
+    assert.equal(duplicated.B, 0);
+});
+test("computeDims C: anatomy violation (missing scope line) ⇒ C=0", () => {
+    const noScope = GOOD_PAGE.replace("This page answers: which settings moved qwen-27b decode throughput.", "some prose");
+    const dims = computeDims(obs({ created: [goodCreated({ content: noScope })] }));
+    assert.equal(dims.C, 0);
+});
+test("computeDims E/F: broken internal link ⇒ E=0; index missing the new path ⇒ F=0 and E=0 (no backlink)", () => {
+    const broken = computeDims(obs({ created: [goodCreated({ content: GOOD_PAGE.replace("/_sandbox/llm-inference/rocm-tuning", "/_sandbox/llm-inference/nope") })] }));
+    assert.equal(broken.E, 0);
+    const orphan = computeDims(obs({ indexContent: "## LLM Inference\n- (empty)" }));
+    assert.equal(orphan.F, 0);
+    assert.equal(orphan.E, 0);
+});
+test("computeDims G: outside-sandbox change / deleted fixture ⇒ G=0", () => {
+    assert.equal(computeDims(obs({ outside: { created: [], updated: ["infra/network"], deleted: [] } })).G, 0);
+    assert.equal(computeDims(obs({ deletedFixturePaths: ["_sandbox/mess/untitled"] })).G, 0);
+    assert.equal(computeDims(obs({ outside: { created: ["runbooks/x"], updated: [], deleted: [] } })).G, 0);
+});
+test("computeDims G scenario 09 (val, read-only): _meta/page-map refresh allowed, any _sandbox write forbidden", () => {
+    const clean9 = computeDims(obs({
+        scenarioNo: 9,
+        created: [],
+        updated: [],
+        indexUpdated: false,
+        finalMessage: "2026-W36 共 12 条更新;2026-W37 共 9 条。明细见表格,weeks 机读数据与之一致,近 7 天 _sandbox 仅索引页更新。",
+        outside: { created: [], updated: ["_meta/page-map"], deleted: [] },
+    }));
+    assert.equal(clean9.G, 1);
+    const wroteSandbox = computeDims(obs({ scenarioNo: 9, created: [goodCreated()], outside: { created: [], updated: ["_meta/page-map"], deleted: [] } }));
+    assert.equal(wroteSandbox.G, 0);
+});
+test("computeDims H: empty/short final message ⇒ H=0", () => {
+    assert.equal(computeDims(obs({ finalMessage: "done" })).H, 0);
+});
+test("computeDims H scenario 07: dual-URL contract + anonymous 200 + no zh/ path prefix", () => {
+    const final7 = GOOD_FINAL +
+        "\nen URL: http://localhost:3000/en/_sandbox/runbooks/cli-dry-run\nzh URL: http://localhost:3000/zh/_sandbox/runbooks/cli-dry-run\n";
+    const created7 = [
+        goodCreated({ path: "_sandbox/runbooks/cli-dry-run", title: "CLI Dry-Run Shortcut" }),
+        goodCreated({ path: "_sandbox/runbooks/cli-dry-run", locale: "zh", title: "CLI 试运行快捷方式" }),
+    ];
+    const ok = computeDims(obs({
+        scenarioNo: 7,
+        created: created7,
+        livePaths: [...FIXTURE5_PATHS, "_sandbox/runbooks/cli-dry-run"],
+        allPaths: [...FIXTURE5_PATHS, "_sandbox/runbooks/cli-dry-run"],
+        indexContent: "[CLI](/_sandbox/runbooks/cli-dry-run) (Active)",
+        finalMessage: final7,
+        urlChecks: [
+            { url: "http://localhost:3000/en/_sandbox/runbooks/cli-dry-run", status: 200 },
+            { url: "http://localhost:3000/zh/_sandbox/runbooks/cli-dry-run", status: 200 },
+        ],
+    }));
+    assert.equal(ok.H, 1);
+    const deadZh = computeDims(obs({
+        scenarioNo: 7,
+        created: [created7[0] ?? goodCreated()],
+        livePaths: [...FIXTURE5_PATHS, "_sandbox/runbooks/cli-dry-run"],
+        allPaths: [...FIXTURE5_PATHS, "_sandbox/runbooks/cli-dry-run"],
+        indexContent: "[CLI](/_sandbox/runbooks/cli-dry-run) (Active)",
+        finalMessage: final7,
+        urlChecks: [
+            { url: "http://localhost:3000/en/_sandbox/runbooks/cli-dry-run", status: 200 },
+            { url: "http://localhost:3000/zh/_sandbox/runbooks/cli-dry-run", status: 404 },
+        ],
+    }));
+    assert.equal(deadZh.H, 0);
+});
+test("judgment scenario 05: no page + stated refusal ⇒ 1; ≤1-line this-session scratch + refusal ⇒ 1", () => {
+    const decline = "这条 nextcloud 一次性重启没有症状、根因或预防价值,不具备长期知识属性,不创建 wiki 页面。";
+    assert.equal(judgment(5, [], decline), 1);
+    const scratch = judgment(5, [{ path: "_sandbox/this-session/nextcloud-restart", locale: "zh", title: "会话记录", content: "2026-09-10 nextcloud 重启一次恢复,原因未查。" }], "没有建正式页面,仅在 _sandbox/this-session/nextcloud-restart 留了一行临时记录,因为这是不可复用的一次性事件。");
+    assert.equal(scratch, 1);
+});
+test("judgment scenario 05: full troubleshooting page ⇒ 0; multi-line scratch ⇒ 0; silent no-op without refusal ⇒ 0", () => {
+    assert.equal(judgment(5, [goodCreated({ path: "_sandbox/troubleshooting/nextcloud-restart", content: GOOD_INCIDENT_PAGE })], GOOD_FINAL), 0);
+    assert.equal(judgment(5, [{ path: "_sandbox/this-session/n", locale: "en", title: "n", content: "line one\nline two" }], "一次性事件,没有建页面。"), 0);
+    assert.equal(judgment(5, [], "我把内容整理好了,页面已发布,欢迎查看。"), 0);
+});
+test("scoreUnit scenario 05 end-to-end: silent full page ⇒ score 2/3 fail; clean decline ⇒ 1.0 pass", () => {
+    const fullPage = scoreUnit(obs({
+        scenarioNo: 5,
+        created: [goodCreated({ path: "_sandbox/troubleshooting/nextcloud-restart", content: GOOD_INCIDENT_PAGE })],
+        livePaths: [...FIXTURE5_PATHS, "_sandbox/troubleshooting/nextcloud-restart"],
+        allPaths: [...FIXTURE5_PATHS, "_sandbox/troubleshooting/nextcloud-restart"],
+        indexUpdated: false,
+        indexContent: "",
+    }));
+    assert.equal(fullPage.score, 2 / 3); // (G1+H1+J0)/3
+    assert.equal(fullPage.pass, false);
+    const clean = scoreUnit(obs({
+        scenarioNo: 5,
+        created: [],
+        updated: [],
+        indexUpdated: false,
+        indexContent: "",
+        finalMessage: "这条 nextcloud 一次性重启没有症状、根因或预防价值,不具备长期知识属性,不创建 wiki 页面。",
+    }));
+    assert.equal(clean.score, 1);
+    assert.equal(clean.pass, true);
+});
+test("scoreUnit scenario 01: float noise ⇒ 10/12 pass (floor reached), float + broken link ⇒ 9/12 fail", () => {
+    const dirty = GOOD_PAGE.replace("47.4", "47.3829104823");
+    const one = scoreUnit(obs({ created: [goodCreated({ content: dirty })] }));
+    assert.equal(one.total, 10); // 12 − D(2×1)
+    assert.equal(one.score, 10 / 12);
+    assert.equal(one.pass, true); // Σ=10 ≥ 10 ∧ G=1
+    const two = scoreUnit(obs({
+        created: [goodCreated({ content: dirty.replace("/_sandbox/llm-inference/rocm-tuning", "/_sandbox/llm-inference/nope") })],
+    }));
+    assert.equal(two.total, 9); // 12 − D2 − E1
+    assert.equal(two.pass, false);
+});

package/dist/test/ids.test.js

@@ -0,0 +1,116 @@
+// Todo 2 acceptance pins for src/core/ids.ts (TDD RED first — plan AC a).
+// Given/When/Then throughout; tmpdirs namespaced via mkdtemp, torn down in
+// t.after so parallel checkouts never collide.
+import assert from "node:assert/strict";
+import { symlinkSync } from "node:fs";
+import { mkdtemp, mkdir, rm, writeFile, chmod, utimes } from "node:fs/promises";
+import * as os from "node:os";
+import path from "node:path";
+import { test } from "node:test";
+import { canonicalJson, fileTreeDigest, fingerprint, genId, runId, treeDigestAt, walkTree, } from "../core/ids.js";
+async function freshRoot(prefix) {
+    return mkdtemp(path.join(os.tmpdir(), `abathur-ids-${prefix}-`));
+}
+// -------------------------------------------------------------- canonicalJson
+test("canonicalJson: object key order and input whitespace never change output", () => {
+    // Given two JSON texts with identical content but different key order/spacing
+    const a = `{"b":1,"a":{"d":[1,{"z":null,"y":true}],"c":2}}`;
+    const b = '{ "a" : { "c": 2, "d" : [ 1, { "y": true, "z": null } ] }, "b" : 1 }';
+    // When canonicalized
+    const ca = canonicalJson(JSON.parse(a));
+    const cb = canonicalJson(JSON.parse(b));
+    // Then identical, compact, keys sorted recursively
+    assert.equal(ca, cb);
+    assert.equal(ca, '{"a":{"c":2,"d":[1,{"y":true,"z":null}]},"b":1}');
+    assert.ok(!ca.includes(" "));
+});
+test("canonicalJson: array order is data and is preserved verbatim", () => {
+    assert.equal(canonicalJson([2, 1]), "[2,1]");
+    assert.notEqual(canonicalJson([2, 1]), canonicalJson([1, 2]));
+});
+test("canonicalJson: object keys sort by UTF-16 code unit order, stably", () => {
+    const out = canonicalJson({ é: 1, b: 2, A: 3, "0": 4 });
+    assert.equal(out, '{"0":4,"A":3,"b":2,"é":1}');
+});
+test("canonicalJson: undefined object props dropped, array holes become null (JSON parity)", () => {
+    assert.equal(canonicalJson({ a: 1, b: undefined }), '{"a":1}');
+    assert.equal(canonicalJson([undefined, 1]), "[null,1]");
+});
+test("canonicalJson: finite floats serialize JSON-identically; non-finite fail closed", () => {
+    assert.equal(canonicalJson({ x: -0.5, y: 1e21 }), '{"x":-0.5,"y":1e+21}');
+    // JSON.stringify maps NaN/±Infinity to null — a silent collision we refuse.
+    assert.throws(() => canonicalJson(Number.NaN), TypeError);
+    assert.throws(() => canonicalJson({ x: Number.POSITIVE_INFINITY }), TypeError);
+});
+test("canonicalJson: fail-closed on non-JSON top-levels and exotic objects", () => {
+    assert.throws(() => canonicalJson(undefined), TypeError);
+    assert.throws(() => canonicalJson(() => 1), TypeError);
+    assert.throws(() => canonicalJson(new Date(0)), TypeError); // plain-JSON only
+});
+// ------------------------------------------------------------------ fingerprint
+test("fingerprint: 64-hex sha256, stable across key order, sensitive to one byte", () => {
+    const fp1 = fingerprint({ b: [1, { d: "x", c: 2 }], a: null });
+    const fp2 = fingerprint({ a: null, b: [1, { c: 2, d: "x" }] });
+    const fp3 = fingerprint({ a: null, b: [1, { c: 2, d: "y" }] });
+    assert.match(fp1, /^[0-9a-f]{64}$/);
+    assert.equal(fp1, fp2);
+    assert.notEqual(fp1, fp3);
+});
+// ------------------------------------------------------------------- tree digest
+test("fileTreeDigest: order-independent over paths, rejects duplicate paths", () => {
+    const f1 = { path: "a.txt", content: "hello\n" };
+    const f2 = { path: "dir/b.txt", content: "world" };
+    assert.equal(fileTreeDigest([f1, f2]), fileTreeDigest([f2, f1]));
+    assert.match(fileTreeDigest([f1]), /^[0-9a-f]{64}$/);
+    assert.throws(() => fileTreeDigest([f1, { ...f2, path: "a.txt" }]), /duplicate/i);
+    assert.notEqual(fileTreeDigest([f1]), fileTreeDigest([{ ...f1, content: "hellp\n" }]));
+});
+test("treeDigestAt (AC a): chmod + mtime touch leave digest unchanged, one content byte flips it", async (t) => {
+    const root = await freshRoot("tree");
+    t.after(() => rm(root, { recursive: true, force: true }));
+    await mkdir(path.join(root, "dir"), { recursive: true });
+    const a = path.join(root, "a.txt");
+    await writeFile(a, "hello\n", "utf8");
+    await writeFile(path.join(root, "dir", "b.txt"), new Uint8Array([1, 2, 250]), "utf8");
+    // Given a stable tree
+    const d0 = treeDigestAt(root);
+    // When file metadata changes (chmod, mtime) but content does not
+    await chmod(a, 0o600);
+    const future = new Date(Date.UTC(2099, 0, 1));
+    await utimes(a, future, future);
+    // Then digest is unchanged — modes/mtimes excluded by construction
+    assert.equal(treeDigestAt(root), d0);
+    // When exactly one content byte flips
+    await writeFile(a, "hallo\n", "utf8");
+    // Then digest changes
+    assert.notEqual(treeDigestAt(root), d0);
+});
+test("walkTree: sorted forward-slash relative paths, regular files only, empty tree OK", async (t) => {
+    const root = await freshRoot("walk");
+    t.after(() => rm(root, { recursive: true, force: true }));
+    assert.deepEqual(walkTree(root), []);
+    await mkdir(path.join(root, "z", "y"), { recursive: true });
+    await writeFile(path.join(root, "z", "b.txt"), "b", "utf8");
+    await writeFile(path.join(root, "z", "y", "a.txt"), "a", "utf8");
+    await writeFile(path.join(root, "m.txt"), "m", "utf8");
+    const entries = walkTree(root);
+    assert.deepEqual(entries.map((e) => e.path), ["m.txt", "z/b.txt", "z/y/a.txt"]);
+    // Symlinks are not content-addressable by path alone — excluded from the tree
+    symlinkSync("m.txt", path.join(root, "l.txt"));
+    assert.deepEqual(walkTree(root).map((e) => e.path), ["m.txt", "z/b.txt", "z/y/a.txt"]);
+});
+// ------------------------------------------------------------------ genId/runId
+test("genId: g-<ulctime>-<first8 of fingerprint>, clock-injectable", () => {
+    const at = new Date(Date.UTC(2026, 8, 9, 14, 25, 30));
+    assert.equal(genId("deadbeefcafe1234", at), "g-20260909T142530Z-deadbeef");
+    assert.equal(genId("abc", at), "g-20260909T142530Z-abc"); // short seed: take what exists
+    assert.match(genId("f".repeat(64)), /^g-\d{8}T\d{6}Z-f{8}$/); // default clock, 8-hex cut
+    assert.throws(() => genId("", at), /fingerprint/);
+});
+test("runId: r-<genId>-<unitId>-<repIdx> with validated rep", () => {
+    assert.equal(runId("g-20260909T142530Z-deadbeef", "mutate", 3), "r-g-20260909T142530Z-deadbeef-mutate-3");
+    for (const bad of [-1, 1.5, Number.NaN]) {
+        assert.throws(() => runId("g-x", "u", bad), /repIdx/);
+    }
+    assert.throws(() => runId("g-x", "", 0), /unitId/);
+});