@tachikomagundam/abathur 0.1.0

package/dist/test/config.test.js

@@ -0,0 +1,185 @@
+// Todo 1 acceptance pins for src/config.ts (TDD RED first — plan protocol).
+// Given/When/Then throughout; tmpdirs are namespaced per-run via mkdtemp and
+// torn down in t.after so parallel checkouts of this repo never collide.
+import assert from "node:assert/strict";
+import { mkdtemp, mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import * as os from "node:os";
+import path from "node:path";
+import { test } from "node:test";
+import { fileURLToPath } from "node:url";
+import { ConfigError, deepMerge, loadConfig, resolveConfigDir, resolveConfigPath, stripJsonc, } from "../config.js";
+/** Create a throwaway HOME whose ~/.config/abathur does not exist yet. */
+async function freshRoot() {
+    return mkdtemp(path.join(os.tmpdir(), "abathur-cfg-test-"));
+}
+function userConfigPath(home) {
+    return path.join(home, ".config", "abathur", "config.jsonc");
+}
+async function writeJsonc(filePath, text) {
+    await mkdir(path.dirname(filePath), { recursive: true });
+    await writeFile(filePath, text, "utf8");
+}
+const repoDefault = fileURLToPath(new URL("../../config/abathur.jsonc", import.meta.url));
+// ---------------------------------------------------------------- stripJsonc
+test("stripJsonc: removes line and block comments and trailing commas", () => {
+    const src = `{
+  // line comment
+  "a": 1, /* block
+             comment */
+  "b": [1, 2, 3,],
+  "c": {"d": true,},
+}`;
+    const out = stripJsonc(src);
+    assert.deepEqual(JSON.parse(out), { a: 1, b: [1, 2, 3], c: { d: true } });
+});
+test("stripJsonc: preserves comment-like text inside strings", () => {
+    const src = `{"url": "http://example.com//x", "note": "a /* b */ c"} // real comment`;
+    const out = stripJsonc(src);
+    assert.deepEqual(JSON.parse(out), {
+        url: "http://example.com//x",
+        note: "a /* b */ c",
+    });
+});
+// ----------------------------------------------------------------- deepMerge
+test("deepMerge: merges nested objects, replaces arrays and scalars, overlay wins", () => {
+    const base = { a: { x: 1, y: 2 }, arr: [1, 2], s: "base", keep: true };
+    const overlay = { a: { y: 9, z: 3 }, arr: [9], s: "local" };
+    assert.deepEqual(deepMerge(base, overlay), {
+        a: { x: 1, y: 9, z: 3 },
+        arr: [9],
+        s: "local",
+        keep: true,
+    });
+});
+// ------------------------------------------------- strict schema (AC-2 core)
+test("loadConfig: unknown key is rejected and named in the error", async (t) => {
+    const root = await freshRoot();
+    t.after(() => rm(root, { recursive: true, force: true }));
+    const cfg = path.join(root, "config.jsonc");
+    await writeJsonc(cfg, `{ "unknownField": 1 }`);
+    let caught;
+    try {
+        loadConfig({ ABATHUR_CONFIG: cfg, HOME: root });
+    }
+    catch (error) {
+        caught = error;
+    }
+    assert.ok(caught instanceof ConfigError, `expected ConfigError, got ${String(caught)}`);
+    assert.equal(caught.kind, "unknown-key");
+    assert.match(caught.message, /unknownField/);
+    assert.ok(caught.keys?.includes("unknownField"));
+    assert.equal(caught.filePath, cfg);
+});
+test("loadConfig: unknown key inside the local overlay is rejected too", async (t) => {
+    const root = await freshRoot();
+    t.after(() => rm(root, { recursive: true, force: true }));
+    const cfg = path.join(root, "config.jsonc");
+    await writeJsonc(cfg, `{ "opencodeBin": null }`);
+    await writeJsonc(path.join(root, "config.local.jsonc"), `{ "oops": true }`);
+    assert.throws(() => loadConfig({ ABATHUR_CONFIG: cfg, HOME: root }), (error) => error instanceof ConfigError &&
+        error.kind === "unknown-key" &&
+        error.keys?.includes("oops"));
+});
+// ------------------------------------------------------------ overlay merge
+test("loadConfig: *.local.jsonc deep-merges over the base file", async (t) => {
+    const root = await freshRoot();
+    t.after(() => rm(root, { recursive: true, force: true }));
+    const cfg = path.join(root, "config.jsonc");
+    await writeJsonc(cfg, `{ "opencodeBin": "/usr/bin/opencode", "stateDir": "/srv/state" }`);
+    await writeJsonc(cfg.replace(/\.jsonc$/, ".local.jsonc"), `{ "stateDir": "/scratch/state" }`);
+    const loaded = loadConfig({ ABATHUR_CONFIG: cfg, HOME: root });
+    assert.equal(loaded.config.opencodeBin, "/usr/bin/opencode"); // base survives
+    assert.equal(loaded.config.stateDir, "/scratch/state"); // overlay wins
+    assert.equal(loaded.path, cfg);
+    assert.equal(loaded.overlayPath, path.join(root, "config.local.jsonc"));
+});
+test("loadConfig: no overlay present leaves overlayPath null", async (t) => {
+    const root = await freshRoot();
+    t.after(() => rm(root, { recursive: true, force: true }));
+    const cfg = path.join(root, "config.jsonc");
+    await writeJsonc(cfg, `{ /* no overlay */ }`);
+    const loaded = loadConfig({ ABATHUR_CONFIG: cfg, HOME: root });
+    assert.equal(loaded.overlayPath, null);
+    assert.equal(loaded.config.opencodeBin, null); // schema default applied
+});
+// ------------------------------------------------- fallback resolution order
+test("resolveConfigPath: ABATHUR_CONFIG pointing at a missing file fails closed", async (t) => {
+    const root = await freshRoot();
+    t.after(() => rm(root, { recursive: true, force: true }));
+    const missing = path.join(root, "nope.jsonc");
+    assert.throws(() => resolveConfigPath({ ABATHUR_CONFIG: missing, HOME: root }), (error) => error instanceof ConfigError && error.kind === "unreadable" &&
+        error.message.includes(missing));
+    // loadConfig surfaces the same failure class (unreadable => exit 2 contract)
+    assert.throws(() => loadConfig({ ABATHUR_CONFIG: missing, HOME: root }), (error) => error instanceof ConfigError && error.kind === "unreadable");
+});
+test("resolveConfigPath: ~/.config/abathur beats the repo default", async (t) => {
+    const root = await freshRoot();
+    t.after(() => rm(root, { recursive: true, force: true }));
+    const user = userConfigPath(root);
+    await writeJsonc(user, `{ "stateDir": "/user/abathur-state" }`);
+    assert.equal(resolveConfigPath({ HOME: root }), user);
+    const loaded = loadConfig({ HOME: root });
+    assert.equal(loaded.path, user);
+    assert.equal(loaded.config.stateDir, "/user/abathur-state");
+});
+test("resolveConfigPath: falls back to repo config/abathur.jsonc when nothing else exists", async (t) => {
+    const root = await freshRoot();
+    t.after(() => rm(root, { recursive: true, force: true }));
+    assert.equal(resolveConfigPath({ HOME: root }), repoDefault);
+    const loaded = loadConfig({ HOME: root }); // must NOT crash — AC: fallback order
+    assert.equal(loaded.path, repoDefault);
+    assert.equal(loaded.config.opencodeBin, null);
+});
+test("resolveConfigDir: tracks the winner, canonical home when nothing exists", async (t) => {
+    const root = await freshRoot();
+    t.after(() => rm(root, { recursive: true, force: true }));
+    const cfg = path.join(root, "custom", "abathur.jsonc");
+    await writeJsonc(cfg, `{}`);
+    assert.equal(resolveConfigDir({ ABATHUR_CONFIG: cfg, HOME: root }), path.join(root, "custom"));
+    const user = userConfigPath(root);
+    await writeJsonc(user, `{}`);
+    assert.equal(resolveConfigDir({ HOME: root }), path.join(root, ".config", "abathur"));
+    const bare = await freshRoot();
+    t.after(() => rm(bare, { recursive: true, force: true }));
+    // repo default exists but is lower priority: with only HOME+no files, canonical home wins
+    assert.equal(resolveConfigDir({ ABATHUR_CONFIG: undefined, HOME: bare }), path.join(bare, ".config", "abathur"));
+});
+// ------------------------------------------------------------------ malformed
+test("loadConfig: broken syntax yields kind=malformed with the file path, not a raw crash", async (t) => {
+    const root = await freshRoot();
+    t.after(() => rm(root, { recursive: true, force: true }));
+    const cfg = path.join(root, "config.jsonc");
+    await writeJsonc(cfg, `{ "opencodeBin": }`); // JSON syntax error
+    let caught;
+    try {
+        loadConfig({ ABATHUR_CONFIG: cfg, HOME: root });
+    }
+    catch (error) {
+        caught = error;
+    }
+    assert.ok(caught instanceof ConfigError);
+    assert.equal(caught.kind, "malformed");
+    assert.ok(caught.message.includes(cfg), "error message must name the offending file");
+});
+test("loadConfig: wrong leaf type is kind=invalid-value", async (t) => {
+    const root = await freshRoot();
+    t.after(() => rm(root, { recursive: true, force: true }));
+    const cfg = path.join(root, "config.jsonc");
+    await writeJsonc(cfg, `{ "opencodeBin": 42 }`);
+    assert.throws(() => loadConfig({ ABATHUR_CONFIG: cfg, HOME: root }), (error) => error instanceof ConfigError && error.kind === "invalid-value");
+});
+// --------------------------------------------------------- readable artefacts
+test("loadConfig: full happy path reads JSONC comments and overlay from disk", async (t) => {
+    const root = await freshRoot();
+    t.after(() => rm(root, { recursive: true, force: true }));
+    const cfg = path.join(root, "config.jsonc");
+    await writeJsonc(cfg, `{
+       // machine values
+       "opencodeBin": "/opt/opencode/bin/opencode",
+       "stateDir": null, /* keep default home */
+     }`);
+    const loaded = loadConfig({ ABATHUR_CONFIG: cfg, HOME: root });
+    assert.equal(loaded.config.opencodeBin, "/opt/opencode/bin/opencode");
+    const rawOverlay = await readFile(cfg, "utf8"); // sanity: fixture really on disk
+    assert.ok(rawOverlay.includes("//"));
+});

package/dist/test/d7-gate.test.js

@@ -0,0 +1,56 @@
+// D7 grep gate (plan success criterion 7, line 217): shipped sources under src/
+// must never carry machine-bound absolute paths or vendor-specific literals.
+// The README's manual `grep -rnE ... src/` review is not enforcement — this test
+// IS the CI-style gate: it walks every TypeScript source file under src/, minus
+// the src/test/** carve-out the plan grants (fixtures legitimately name such
+// strings), and asserts each file contains neither "/home/lab" nor a
+// case-sensitive "historian". A violation fails naming EVERY offending file and
+// line. Repo sources resolve relative to this module (promote.test.ts pattern),
+// so the gate is robust to the cwd `node --test` runs from.
+import assert from "node:assert/strict";
+import { readdirSync, readFileSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import test from "node:test";
+/** src/ of the repo this compiled test belongs to: dist/test/*.js → ../../src. */
+const SRC_DIR = fileURLToPath(new URL("../../src", import.meta.url));
+/** The plan's carve-out: test sources may contain the very literals they ban. */
+const TEST_DIR = path.join(SRC_DIR, "test");
+const FORBIDDEN = [
+    { label: "absolute workspace path", needle: "/home/lab" },
+    { label: "vendor literal", needle: "historian" },
+];
+/** Recursive .ts walk; symlinks are never followed (they could escape src/). */
+function sourceFiles(dir) {
+    const found = [];
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+        if (entry.isSymbolicLink())
+            continue;
+        const full = path.join(dir, entry.name);
+        if (entry.isDirectory())
+            found.push(...sourceFiles(full));
+        else if (entry.isFile() && entry.name.endsWith(".ts"))
+            found.push(full);
+    }
+    return found;
+}
+test("D7 gate: src/** outside src/test/** is free of machine-bound literals", () => {
+    const violations = [];
+    let scanned = 0;
+    for (const file of sourceFiles(SRC_DIR)) {
+        if (file.startsWith(`${TEST_DIR}${path.sep}`))
+            continue;
+        scanned += 1;
+        const lines = readFileSync(file, "utf8").split("\n");
+        for (const [index, line] of lines.entries()) {
+            for (const { label, needle } of FORBIDDEN) {
+                if (line.includes(needle)) {
+                    violations.push(`${path.relative(SRC_DIR, file)}:${String(index + 1)} [${label}] ${line.trim()}`);
+                }
+            }
+        }
+    }
+    // a vacuous pass (bad path resolution) must be as loud as a violation
+    assert.ok(scanned > 20, `gate only scanned ${String(scanned)} sources under ${SRC_DIR} — path resolution broken`);
+    assert.equal(violations.length, 0, `D7 grep gate violated (${String(violations.length)} hit(s)):\n${violations.join("\n")}`);
+});

package/dist/test/fixture-loop.test.js

@@ -0,0 +1,267 @@
+// F1-fix2 loop-level regression pins for the val-split bench authority split
+// (plan lines 117-124 / 125-132 / SC4). Commit 3c6bbf9 wired `--include-val` at
+// the fixture adapter seam but left benchTarget iterating EVERY unit, so any
+// default `run` on a val-bearing fixture genome crashed mid-bench with
+//   ExitSignal(2) "fixture: unit 'v1' is a val-split scenario and requires the
+//   operator flag --include-val"
+// at the first val unit — the SC4/T7 flagship flows were unreachable without the
+// flag. Pins here:
+//  (1) default run (NO flag) completes: incumbent AND candidate benches carry
+//      scored val replicates (the nomination gate's required input);
+//  (2) --include-val stays the honest operator EXPOSURE switch: off, every
+//      sandbox manifest keeps val ids/paths opaque; on, they surface;
+//  (3) toy + flag fail-closed stays pinned in include-val.test.ts / run-loop.test.ts.
+// No model calls anywhere: fake opencodeBin bash stub + node grader table.
+import assert from "node:assert/strict";
+import { spawnSync } from "node:child_process";
+import { chmodSync, existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
+import { mkdtemp } from "node:fs/promises";
+import * as os from "node:os";
+import path from "node:path";
+import test, {} from "node:test";
+import { registerGenome, requireGenomesByLabel } from "../core/genome.js";
+import { Ledger } from "../core/ledger.js";
+import { decodeGenerationRecord } from "../core/evolve/run-bench.js";
+import { runEvolution } from "../core/evolve/run-loop.js";
+// --------------------------------------------------------------------- stubs
+const VAL_CANARY = "sval-canary-ZZHIDDEN";
+const VAL_PATH = `scenarios/${VAL_CANARY}.md`;
+// Fake opencode: `--version` semver line (probe), `run <path>` scenario echo +
+// final run-metadata JSON line (same contract as bench-fixture.test.ts BIN_GOOD).
+const FAKE_BIN = `#!/usr/bin/env bash
+set -euo pipefail
+if [ "\${1:-}" = "--version" ]; then echo "1.2.3"; exit 0; fi
+if [ -n "\${ABATHUR_TRANSCRIPT:-}" ]; then
+  mkdir -p "$(dirname "$ABATHUR_TRANSCRIPT")"
+  printf 'ran %s\\n' "\${2:-}" > "$ABATHUR_TRANSCRIPT"
+fi
+echo "ran \${2:-}"
+echo '{"tokensEst":10,"turns":1}'
+`;
+const GRADER = `const [unitId] = process.argv.slice(2);
+const table = {
+  t1: { score: 1, pass: true },
+  v1: { score: 0.75, pass: true },
+};
+const row = table[unitId];
+if (!row) { console.error("unknown unit " + unitId); process.exit(1); }
+console.log(JSON.stringify({ unit: unitId, score: row.score, pass: row.pass, metrics: { tokensEst: 4, turns: 1 } }));
+`;
+const RESET_SH = `#!/usr/bin/env bash
+set -euo pipefail
+rm -rf "\${1:?sandbox}"
+mkdir -p "\${1:?sandbox}"
+`;
+const SEED_SH = `#!/usr/bin/env bash
+set -euo pipefail
+here=$(cd "$(dirname "$0")" && pwd)
+sandbox="\${1:?sandbox}"
+mkdir -p "$sandbox/scenarios"
+cp "$here"/scenarios/*.md "$sandbox/scenarios/"
+cp "$here"/grader.mjs "$sandbox/grader.mjs"
+`;
+// Two modes: "garbage" delivers one syntactically invalid candidate (rejected at
+// parse, never benched — the loop exits after the incumbent bench); "touch"
+// delivers a valid non-improving diff against the train scenario so the CANDIDATE
+// bench (the second val-bearing seam) runs too and the gate culls it.
+const MUTATOR_STUB = `#!/usr/bin/env node
+import { readFileSync } from "node:fs";
+const args = process.argv.slice(2);
+const opt = (n) => { const i = args.indexOf(n); return i >= 0 ? args[i + 1] : undefined; };
+const mode = opt("--mode");
+const dir = opt("--dir");
+const out = (candidates) => process.stdout.write(JSON.stringify({ candidates }) + "\\n");
+if (mode === "garbage") {
+  out([{ id: "garbage-1", rationale: "not a real diff", diffs: ["this is not a unified diff\\n"] }]);
+} else if (mode === "touch") {
+  const file = "scenarios/t1.md";
+  const lines = readFileSync(dir + "/" + file, "utf8").split("\\n");
+  const i = lines.findIndex((l) => l.includes("train alpha"));
+  if (i < 0) { process.stderr.write("stub: no anchor in " + file + "\\n"); process.exit(1); }
+  const changed = lines[i].replace("train alpha", "train alpha (annotated)");
+  const diff = "--- a/" + file + "\\n+++ b/" + file +
+    "\\n@@ -" + String(i + 1) + ",1 +" + String(i + 1) + ",1 @@\\n-" + lines[i] + "\\n+" + changed + "\\n";
+  out([{ id: "touch-t1", rationale: "annotate the train scenario without changing scores", diffs: [diff] }]);
+} else {
+  process.stderr.write("stub: unknown mode\\n");
+  process.exit(2);
+}
+`;
+function git(repo, args) {
+    const run = spawnSync("git", args, { cwd: repo, encoding: "utf8" });
+    if (run.status !== 0)
+        throw new Error(`git ${args.join(" ")} failed: ${run.stderr}`);
+}
+/** Git-init'd fixture-scenario genome (train t1 + val v1) registered in a fresh config dir. */
+async function fixtureLoop(t) {
+    const root = await mkdtemp(path.join(os.tmpdir(), "abathur-fixloop-"));
+    t.after(() => spawnSync("rm", ["-rf", root], { encoding: "utf8" }));
+    const binDir = path.join(root, "bin");
+    mkdirSync(binDir, { recursive: true });
+    const binPath = path.join(binDir, "oc-fake");
+    writeFileSync(binPath, FAKE_BIN, "utf8");
+    chmodSync(binPath, 0o755);
+    const configDir = path.join(root, "config");
+    mkdirSync(configDir, { recursive: true });
+    // opencodeBin resolution flows loadConfig(env) with env = the loop's WorktreeEnv
+    // ({HOME, XDG_CACHE_HOME} only), so the fake HOME carries the user config file
+    // — the bench adapter then spawns the fake bin, never a real opencode.
+    const userConfigDir = path.join(root, "home", ".config", "abathur");
+    mkdirSync(userConfigDir, { recursive: true });
+    writeFileSync(path.join(userConfigDir, "config.jsonc"), `${JSON.stringify({ opencodeBin: binPath })}\n`, "utf8");
+    const repo = path.join(root, "germ");
+    mkdirSync(path.join(repo, "scenarios"), { recursive: true });
+    writeFileSync(path.join(repo, "scenarios", "t1.md"), "train alpha scenario\nsecond line\n", "utf8");
+    writeFileSync(path.join(repo, "scenarios", `${VAL_CANARY}.md`), "holdout val scenario ZZHIDDEN\n", "utf8");
+    writeFileSync(path.join(repo, "grader.mjs"), GRADER, "utf8");
+    for (const [name, body] of [
+        ["reset.sh", RESET_SH],
+        ["seed.sh", SEED_SH],
+    ]) {
+        const p = path.join(repo, name);
+        writeFileSync(p, body, "utf8");
+        chmodSync(p, 0o755);
+    }
+    const specDoc = {
+        label: "fixloop-germ",
+        repoPath: repo,
+        bench: {
+            type: "opencode-fixture-scenarios",
+            units: [
+                { id: "t1", path: "scenarios/t1.md", split: "train" },
+                { id: "v1", path: VAL_PATH, split: "val" },
+            ],
+            runCommand: `${binPath} run {unit.path}`,
+            seedCommand: `${repo}/seed.sh {sandbox}`,
+            resetCommand: `${repo}/reset.sh {sandbox}`,
+            graderCommand: "node grader.mjs {unit.id}",
+            agentModel: "test/agent",
+            timeoutS: 10,
+            stats: { halfWidth: 0.1, minEffect: 0.05, nReps: { initial: 2, max: 4 } },
+        },
+        budget: { maxCandidates: 2, maxModelCalls: 8, maxTokens: 100000, maxWallS: 300 },
+        kernel: { immutableGlobs: [] },
+        requires: [{ cmd: "node", args: ["--version"], probeExit: 0 }],
+        opencodeBinVersion: { minVersion: "1.0.0" },
+    };
+    const specPath = path.join(repo, "genome.jsonc");
+    writeFileSync(specPath, `${JSON.stringify(specDoc, null, 2)}\n`, "utf8");
+    git(repo, ["init", "-b", "main"]);
+    git(repo, ["add", "-A"]);
+    // identity pinned via -c BEFORE the subcommand (toy init.mjs convention)
+    git(repo, ["-c", "user.name=abathur", "-c", "user.email=abathur@harness.local", "commit", "-m", "fixloop seed"]);
+    registerGenome(configDir, specPath);
+    const entry = requireGenomesByLabel(configDir, "fixloop-germ").entries[0];
+    if (entry === undefined)
+        throw new Error("fixture: fixloop-germ registration vanished");
+    const stub = path.join(root, "stub.mjs");
+    writeFileSync(stub, MUTATOR_STUB, "utf8");
+    chmodSync(stub, 0o755);
+    return {
+        root,
+        configDir,
+        repo,
+        entry,
+        env: {
+            HOME: path.join(root, "home"),
+            XDG_CACHE_HOME: path.join(root, "xdg-cache"),
+        },
+        sandboxRoot: path.join(root, "sandboxes"),
+        stub,
+    };
+}
+function loopRun(f, opts) {
+    return runEvolution({
+        entry: f.entry,
+        configDir: f.configDir,
+        mutatorCommand: `node ${f.stub} --mode ${opts.mode} --dir {worktree} --brief {brief}`,
+        ...(opts.includeVal === undefined ? {} : { includeVal: opts.includeVal }),
+        env: f.env,
+        sandboxRoot: f.sandboxRoot,
+    });
+}
+function generations(repo) {
+    return Ledger.open(repo)
+        .readAll()
+        .filter((r) => r.kind === "generation_complete")
+        .map((r) => decodeGenerationRecord(r));
+}
+function manifestsUnder(dir) {
+    const found = [];
+    const walk = (d) => {
+        for (const e of readdirSync(d, { withFileTypes: true })) {
+            const p = path.join(d, e.name);
+            if (e.isDirectory())
+                walk(p);
+            else if (e.isFile() && e.name === "manifest.json")
+                found.push(p);
+        }
+    };
+    if (existsSync(dir))
+        walk(dir);
+    return found;
+}
+function valEntry(manifestFile) {
+    const doc = JSON.parse(readFileSync(manifestFile, "utf8"));
+    const entry = doc.scenarios.find((s) => s.split === "val");
+    assert.ok(entry !== undefined, `manifest ${manifestFile} must count the val scenario`);
+    return entry;
+}
+// ---------------------------------------------------------------- pin (1): RED at 3c6bbf9
+test("regression: default run (NO --include-val) benches val replicates and completes", async (t) => {
+    const f = await fixtureLoop(t);
+    const out = await loopRun(f, { mode: "garbage" });
+    assert.equal(out.exitCode, 0, `loop must complete, lines: ${out.lines.join("\n")}`);
+    assert.match(out.lines.join("\n"), /incumbent baseline: 2 units x 2 reps/);
+    const rows = generations(f.repo);
+    const incumbent = rows.filter((d) => d.source === "incumbent");
+    assert.equal(incumbent.length, 1, "exactly one incumbent baseline row");
+    const byId = new Map(incumbent[0]?.units.map((u) => [u.unitId, u]));
+    assert.deepEqual(byId.get("t1")?.scores, [1, 1], "train unit scored");
+    assert.equal(byId.get("v1")?.split, "val");
+    assert.deepEqual(byId.get("v1")?.scores, [0.75, 0.75], "val unit benched under loop authority");
+    assert.equal(incumbent[0]?.complete, true);
+    // exposure OFF: the val id/path stay opaque in every sandbox manifest the bench wrote
+    const manifests = manifestsUnder(f.sandboxRoot);
+    assert.ok(manifests.length >= 2, `expected per-unit bench manifests, found ${String(manifests.length)}`);
+    for (const m of manifests) {
+        const raw = readFileSync(m, "utf8");
+        assert.ok(!raw.includes(VAL_CANARY), `val path leaked into ${m} without the operator flag`);
+        const val = valEntry(m);
+        assert.equal(val.id, undefined, "val id must stay hidden without the operator flag");
+        assert.equal(val.path, undefined, "val path must stay hidden without the operator flag");
+    }
+});
+// --------------------------------------------------- pin (2): --include-val is real
+test("--include-val completes the run AND exposes val ids/paths in this run's manifests", async (t) => {
+    const f = await fixtureLoop(t);
+    const out = await loopRun(f, { mode: "garbage", includeVal: true });
+    assert.equal(out.exitCode, 0, out.lines.join("\n"));
+    const rows = generations(f.repo);
+    const incumbent = rows.find((d) => d.source === "incumbent");
+    assert.equal(incumbent?.units.find((u) => u.unitId === "v1")?.scores.length, 2, "val benched with the flag too");
+    const manifests = manifestsUnder(f.sandboxRoot);
+    assert.ok(manifests.length >= 2);
+    for (const m of manifests) {
+        assert.ok(readFileSync(m, "utf8").includes(VAL_CANARY), `operator asked for exposure: ${m} still hides the val path`);
+        const val = valEntry(m);
+        assert.equal(val.id, "v1");
+        assert.equal(val.path, VAL_PATH);
+    }
+});
+// ------------------------------------------- pin (1b): candidate bench seam, no flag
+test("regression: candidate bench (second seam) also carries val replicates without the flag", async (t) => {
+    const f = await fixtureLoop(t);
+    const out = await loopRun(f, { mode: "touch" });
+    // the touch candidate is valid but score-identical ⇒ culled ⇒ run exit 1 (BLOCKED)
+    assert.equal(out.exitCode, 1, out.lines.join("\n"));
+    const candidate = generations(f.repo)
+        .filter((d) => d.source === "candidate")
+        .find((d) => d.candidateId === "touch-t1");
+    assert.ok(candidate !== undefined, `candidate benched, lines: ${out.lines.join("\n")}`);
+    assert.equal(candidate.complete, true);
+    const byId = new Map(candidate.units.map((u) => [u.unitId, u]));
+    assert.deepEqual(byId.get("v1")?.scores, [0.75, 0.75], "candidate bench carries val replicates for the gate");
+    assert.equal(candidate.verdict, "culled");
+    assert.ok((candidate.gateFailures ?? []).some((msg) => /minEffect|gain/.test(msg)), `cull reason: ${String(candidate.gateFailures)}`);
+});

package/dist/test/fixtures/friction-writer.js

@@ -0,0 +1,16 @@
+// Child-process entrypoint for the concurrent friction-append test (AC f).
+// Stands in for two genomes running `abathur` at once — the one place under
+// src/test where touching `process` is legitimate.
+import { appendFriction } from "../../core/ledger.js";
+const [configDir, source, countRaw] = process.argv.slice(2);
+const count = Number(countRaw);
+if (configDir === undefined || source === undefined || !Number.isInteger(count) || count < 0) {
+    process.stderr.write("usage: friction-writer <configDir> <source> <count>\n");
+    process.exit(2);
+}
+// 200 back-to-back acquisitions in one process; production appends one event
+// per call on the default 15s budget, so the loop raises its own deadline.
+for (let seq = 0; seq < count; seq += 1) {
+    appendFriction(configDir, { kind: "friction", data: { source, seq } }, { waitMs: 60_000 });
+}
+process.exit(0);

package/dist/test/fixtures-historian.js

@@ -0,0 +1,82 @@
+// Shared recorded fixtures for the historian grader tests (task 14). NOT a test
+// file — importing this module registers no tests (unlike importing a .test.js).
+export const FIXTURE5_PATHS = [
+    "_sandbox/index",
+    "_sandbox/llm-inference/rocm-tuning",
+    "_sandbox/mess/untitled",
+    "_sandbox/mess/gpu-notes",
+    "_sandbox/mess/gpu-stuff",
+];
+export const GOOD_PAGE = `# Qwen 27B Threading Findings
+
+> Status: Active | Updated: 2026-09-10 | Scope: llama.cpp decode tuning on the rocm host
+
+This page answers: which settings moved qwen-27b decode throughput.
+
+## Findings
+
+- \`HSA_OVERRIDE_GFX_VERSION=11.0.0\` plus 8 threads lifted decode from 47.4 to 53.7 tok/s.
+
+## Method
+
+Run under test: \`./llama-server -m qwen-27b.gguf --threads 8 --ctx-size 8192\`
+
+## Related Pages
+
+- [ROCm tuning](/_sandbox/llm-inference/rocm-tuning)
+`;
+export const GOOD_INCIDENT_PAGE = `# Wiki ES OOM 2026-08-28
+
+> Status: Active | Updated: 2026-09-10 | Scope: 502/OOM incident on the wiki host
+
+This page answers: what happened, why, and how it is prevented.
+
+## Symptoms
+
+- Wiki.js returned HTTP 502 for 19 minutes; users saw spinning search boxes.
+
+## Root Cause
+
+- Elasticsearch JVM heap was unbounded after the host RAM upgrade.
+
+## Fix
+
+- Capped the heap with \`ES_JAVA_OPTS=-Xms4g -Xmx4g\`; added a restart policy.
+
+## Prevention
+
+- Review heap caps after host-memory changes; alert on repeated restarts.
+
+## Related Pages
+
+- [ROCm tuning](/_sandbox/llm-inference/rocm-tuning)
+`;
+export const GOOD_FINAL = "已在 _sandbox/llm-inference/qwen27b-threading 创建调优结论页,链接到 _sandbox/llm-inference/rocm-tuning," +
+    "并更新了 _sandbox/index 的 LLM Inference 小节;首 token 没有正式测量,按要求不作为结论写入。";
+export function goodCreated(over = {}) {
+    return {
+        path: "_sandbox/llm-inference/qwen27b-threading",
+        locale: "en",
+        title: "Qwen 27B Threading Findings",
+        content: GOOD_PAGE,
+        ...over,
+    };
+}
+export function obs(over = {}) {
+    return {
+        scenarioNo: 1,
+        created: [goodCreated()],
+        updated: [],
+        moved: [],
+        deletedFixturePaths: [],
+        outside: { created: [], updated: [], deleted: [] },
+        indexUpdated: true,
+        indexContent: `## LLM Inference\n- [Qwen 27B Threading Findings](/_sandbox/llm-inference/qwen27b-threading) (Active)\n- [ROCm tuning](/_sandbox/llm-inference/rocm-tuning) (Active)`,
+        livePaths: [...FIXTURE5_PATHS, "_sandbox/llm-inference/qwen27b-threading"],
+        allPaths: [...FIXTURE5_PATHS, "_sandbox/llm-inference/qwen27b-threading", "infra/network"],
+        backlinkBodies: [],
+        finalMessage: GOOD_FINAL,
+        urlChecks: [],
+        ...over,
+    };
+}