@tachikomagundam/abathur 0.2.6 → 0.2.8

package/dist/test/readjudicate.test.js

@@ -0,0 +1,212 @@
+// re-adjudicate (core) tests. The mechanism under test: replay the CURRENT gate over
+// archived generation rows and append a corrected verdict with provenance, files immutable.
+//
+// Coverage: verdict flip culled->nominated (synthetic), honest no-flip (culled stays
+// culled), idempotence after append, promote-row refusal, missing-incumbent refusal,
+// corrupt-archive notice (never a crash), and the historical anchor: a sandboxed COPY of
+// the real historian archives must reproduce the c17 re-adjudication (NOMINATED,
+// gain 0.2917) that the driver computed offline on 2026-09-26 — the engine's own replay
+// of the incident that born this command.
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdirSync, readFileSync, readdirSync, rmSync, writeFileSync, copyFileSync } from "node:fs";
+import { mkdtempSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { readjudicateGeneration } from "../core/readjudicate.js";
+import { ledgerRecordSchema, LEDGER_KIND_GENERATION_COMPLETE, LEDGER_KIND_PROMOTE } from "../core/ledger.js";
+import { decodeGenerationRecord } from "../core/evolve/run-rows.js";
+const STATS = { halfWidth: 0.15, minEffect: 0.1, nReps: { initial: 2, max: 3 } };
+const BUDGET = { maxCandidates: 1, maxModelCalls: 96, maxTokens: 25_000_000, maxWallS: 26_000 };
+function entryFor(repo) {
+    return {
+        fingerprint: "f".repeat(16),
+        label: "test-genome",
+        registryFile: "/dev/null",
+        storedText: "",
+        spec: {
+            label: "test-genome",
+            repoPath: repo,
+            bench: {
+                type: "opencode-fixture-scenarios",
+                units: [
+                    { id: "scenario-19", split: "train", path: "scenarios/19.md" },
+                    { id: "scenario-13", split: "val", path: "scenarios/13.md" },
+                ],
+                runCommand: "true",
+                graderCommand: "true",
+                timeoutS: 1800,
+                stats: STATS,
+            },
+            budget: BUDGET,
+            kernel: { immutableGlobs: ["scenarios/**"] },
+        },
+    };
+}
+function row(o) {
+    const data = {
+        source: o.source,
+        headCommit: "1".repeat(40),
+        complete: true,
+        reps: o.units[0]?.scores.length ?? 0,
+        units: o.units.map((u) => ({ unitId: u.unitId, split: u.split, scores: u.scores, runIds: u.scores.map((_, i) => `r-${u.unitId}-${String(i)}`), failures: u.scores.filter((s) => s < 1).map((s) => `${u.unitId}: scored ${String(s)}`) })),
+        counters: { candidates: o.source === "candidate" ? 1 : 0, modelCalls: 10, tokens: 1000, wallS: 100 },
+        manifest: [],
+        benchProvenance: { benchType: "opencode-fixture-scenarios", versions: [{ bin: "opencode", version: "test" }] },
+    };
+    if (o.source === "candidate") {
+        data.candidateId = "mutate-live";
+        data.commitSha = "2".repeat(40);
+        data.treeSha = o.treeSha ?? "3".repeat(64);
+    }
+    if (o.verdict !== undefined)
+        data.verdict = o.verdict;
+    if (o.gain !== undefined)
+        data.gain = o.gain;
+    return `${JSON.stringify({ v: 1, ts: o.ts, kind: LEDGER_KIND_GENERATION_COMPLETE, genId: o.genId, runId: o.runId, data })}\n`;
+}
+function sandbox(t) {
+    const dir = mkdtempSync(path.join(tmpdir(), "readjud-"));
+    const state = path.join(dir, ".state", "abathur");
+    mkdirSync(state, { recursive: true });
+    writeFileSync(path.join(state, "ledger.jsonl"), "");
+    t.after(() => rmSync(dir, { recursive: true, force: true }));
+    return { dir, state };
+}
+function cfg(t) {
+    const d = mkdtempSync(path.join(tmpdir(), "readjud-cfg-"));
+    t.after(() => rmSync(d, { recursive: true, force: true }));
+    return d;
+}
+function lastRows(stateDir) {
+    return readFileSync(path.join(stateDir, "ledger.jsonl"), "utf8")
+        .split("\n")
+        .filter((l) => l.trim().length > 0)
+        .map((l) => {
+        const parsed = ledgerRecordSchema.parse(JSON.parse(l));
+        return parsed;
+    })
+        .filter((r) => r.kind === LEDGER_KIND_GENERATION_COMPLETE)
+        .map((r) => {
+        try {
+            return decodeGenerationRecord(r);
+        }
+        catch {
+            return null;
+        }
+    })
+        .filter((d) => d !== null);
+}
+test("flip: culled row re-judged nominated by the current gate; corrected row appended with provenance", (t) => {
+    const { dir, state } = sandbox(t);
+    // one rotated archive with the whole epoch (activation law: bank needs an archive)
+    const lines = [
+        // historical incumbent groups that price a small-ish sigma on both units
+        row({ genId: "g-old-a", runId: "r-old", ts: "2026-09-20T00:00:00.000Z", source: "incumbent", units: [{ unitId: "scenario-19", split: "train", scores: [0.875, 1, 0.875, 1] }, { unitId: "scenario-13", split: "val", scores: [1, 1, 1, 1] }] }),
+        // the epoch under re-adjudication
+        row({ genId: "g-epoch", runId: "run-1", ts: "2026-09-21T00:00:00.000Z", source: "incumbent", units: [{ unitId: "scenario-19", split: "train", scores: [0.75, 0.875] }, { unitId: "scenario-13", split: "val", scores: [1, 1] }], verdict: undefined }),
+        row({ genId: "g-epoch-cand", runId: "run-1", ts: "2026-09-21T01:00:00.000Z", source: "candidate", units: [{ unitId: "scenario-19", split: "train", scores: [1, 1] }, { unitId: "scenario-13", split: "val", scores: [1, 1] }], verdict: "culled", gain: 0.1 }),
+    ];
+    writeFileSync(path.join(state, "ledger.campaign1-2026-09-21.jsonl"), lines.join(""));
+    const out = readjudicateGeneration({ entry: entryFor(dir), configDir: cfg(t), genId: "g-epoch-cand", now: () => new Date("2026-09-22T00:00:00Z") });
+    assert.equal(out.appended, true, out.lines.join("\n"));
+    assert.equal(out.verdict, "nominated", out.lines.join("\n"));
+    const appended = lastRows(state).at(-1);
+    assert.ok(appended !== undefined);
+    assert.equal(appended.verdict, "nominated");
+    assert.ok(appended.readjudication !== undefined, "provenance must be present");
+    assert.equal(appended.readjudication.replacedVerdict, "culled");
+    assert.equal(appended.readjudication.gate, "acceptance");
+    assert.equal(appended.readjudication.sourceRows.candidate.file, "ledger.campaign1-2026-09-21.jsonl");
+    // archive untouched: still exactly 3 rows, original culled row intact
+    assert.equal(readFileSync(path.join(state, "ledger.campaign1-2026-09-21.jsonl"), "utf8").trim().split("\n").length, 3);
+    // idempotence: second pass sees the corrected last row -> no-op
+    const again = readjudicateGeneration({ entry: entryFor(dir), configDir: cfg(t), genId: "g-epoch-cand", now: () => new Date("2026-09-22T00:00:00Z") });
+    assert.equal(again.appended, false, again.lines.join("\n"));
+    assert.match(again.lines.join("\n"), /no-op/);
+});
+test("honest replay: a weak candidate stays culled — the tool re-judges, it never flips", (t) => {
+    const { dir, state } = sandbox(t);
+    const lines = [
+        row({ genId: "g-old-a", runId: "r-old", ts: "2026-09-20T00:00:00.000Z", source: "incumbent", units: [{ unitId: "scenario-19", split: "train", scores: [1, 1, 1, 1] }, { unitId: "scenario-13", split: "val", scores: [1, 1, 1, 1] }] }),
+        row({ genId: "g-epoch", runId: "run-1", ts: "2026-09-21T00:00:00.000Z", source: "incumbent", units: [{ unitId: "scenario-19", split: "train", scores: [1, 1] }, { unitId: "scenario-13", split: "val", scores: [1, 1] }] }),
+        row({ genId: "g-epoch-cand", runId: "run-1", ts: "2026-09-21T01:00:00.000Z", source: "candidate", units: [{ unitId: "scenario-19", split: "train", scores: [1, 1] }, { unitId: "scenario-13", split: "val", scores: [1, 1] }], verdict: "culled", gain: 0 }),
+    ];
+    writeFileSync(path.join(state, "ledger.campaign1-2026-09-21.jsonl"), lines.join(""));
+    const out = readjudicateGeneration({ entry: entryFor(dir), configDir: cfg(t), genId: "g-epoch-cand", now: () => new Date() });
+    assert.equal(out.verdict, "culled", out.lines.join("\n"));
+    assert.equal(out.appended, false, "already-agreeing row must not append");
+});
+test("refusals: promoted gen, missing incumbent, unknown gen — all block before any append", (t) => {
+    const { dir, state } = sandbox(t);
+    const epoch = [
+        row({ genId: "g-epoch", runId: "run-9", ts: "2026-09-21T00:00:00.000Z", source: "incumbent", units: [{ unitId: "scenario-19", split: "train", scores: [0.75, 1] }, { unitId: "scenario-13", split: "val", scores: [1, 1] }] }),
+        row({ genId: "g-epoch-cand", runId: "run-9", ts: "2026-09-21T01:00:00.000Z", source: "candidate", units: [{ unitId: "scenario-19", split: "train", scores: [1, 1] }, { unitId: "scenario-13", split: "val", scores: [1, 1] }], verdict: "culled", gain: 0.1 }),
+    ];
+    writeFileSync(path.join(state, "ledger.campaign1-2026-09-21.jsonl"), epoch.join(""));
+    // promoted epoch is untouchable
+    const promotedRun = "run-p";
+    writeFileSync(path.join(state, "ledger.campaign2-2026-09-22.jsonl"), epoch.join("") + `${JSON.stringify({ v: 1, ts: "2026-09-22T00:00:00.000Z", kind: LEDGER_KIND_PROMOTE, genId: "g-epoch-cand", runId: promotedRun, data: { actor: "cli", genId: "g-epoch-cand", from: null, to: "2".repeat(40) } })}\n`);
+    assert.throws(() => readjudicateGeneration({ entry: entryFor(dir), configDir: cfg(t), genId: "g-epoch-cand", now: () => new Date() }), (e) => /already promoted/.test(String(e.message ?? e)));
+    // unknown gen
+    assert.throws(() => readjudicateGeneration({ entry: entryFor(dir), configDir: cfg(t), genId: "g-nope", now: () => new Date() }), (e) => /no candidate generation_complete row/.test(String(e.message ?? e)));
+    // candidate without its incumbent: run-1 incumbent exists here, so cut a state with candidate only
+    const { dir: d2, state: s2 } = sandbox(t);
+    writeFileSync(path.join(s2, "ledger.campaign1-2026-09-21.jsonl"), row({ genId: "g-solo", runId: "run-s", ts: "2026-09-21T01:00:00.000Z", source: "candidate", units: [{ unitId: "scenario-19", split: "train", scores: [1, 1] }, { unitId: "scenario-13", split: "val", scores: [1, 1] }], verdict: "culled", gain: 0.1 }));
+    assert.throws(() => readjudicateGeneration({ entry: entryFor(d2), configDir: cfg(t), genId: "g-solo", now: () => new Date() }), (e) => /no incumbent baseline row/.test(String(e.message ?? e)));
+});
+test("corrupt archive lines are notices, never a crash, and never poison the replay", (t) => {
+    const { dir, state } = sandbox(t);
+    const good = [
+        row({ genId: "g-old-a", runId: "r-old", ts: "2026-09-20T00:00:00.000Z", source: "incumbent", units: [{ unitId: "scenario-19", split: "train", scores: [0.875, 1, 0.875, 1] }, { unitId: "scenario-13", split: "val", scores: [1, 1, 1, 1] }] }),
+        row({ genId: "g-epoch", runId: "run-1", ts: "2026-09-21T00:00:00.000Z", source: "incumbent", units: [{ unitId: "scenario-19", split: "train", scores: [0.75, 0.875] }, { unitId: "scenario-13", split: "val", scores: [1, 1] }] }),
+        row({ genId: "g-epoch-cand", runId: "run-1", ts: "2026-09-21T01:00:00.000Z", source: "candidate", units: [{ unitId: "scenario-19", split: "train", scores: [1, 1] }, { unitId: "scenario-13", split: "val", scores: [1, 1] }], verdict: "culled", gain: 0.1 }),
+    ];
+    writeFileSync(path.join(state, "ledger.campaign1-2026-09-21.jsonl"), `not json at all\n${good.join("")}{"v":9,"kind":"broken-schema"}\n`);
+    const out = readjudicateGeneration({ entry: entryFor(dir), configDir: cfg(t), genId: "g-epoch-cand", now: () => new Date("2026-09-22T00:00:00Z") });
+    assert.equal(out.verdict, "nominated", out.lines.join("\n"));
+    assert.ok(out.lines.some((l) => l.includes("not JSON")), "skip notice must surface");
+});
+// ------------------------------------------------------------------ historical anchor
+// The incident replay: c17's real rows, judged first by the silently-downgraded engine
+// (culled), then re-adjudicated offline to NOMINATED gain 0.2917 (start-work L141).
+// A sandboxed copy of the real archives run through this command must reproduce that
+// verdict with the same numbers — the engine re-judging its own history correctly.
+// Skips (never fails) when the historian state files are absent (CI elsewhere).
+test("anchor: real c17 archives replay to NOMINATED 0.2917 (copy, no mutation)", (t) => {
+    // located via env, never a hardcoded homedir (release hygiene); skipped wherever the
+    // historian repo is not wired — this anchor guards the OPERATOR's machine, CI has no history.
+    const hist = process.env["ABATHUR_HISTORIAN_REPO"];
+    if (hist === undefined || hist.length === 0) {
+        t.skip("ABATHUR_HISTORIAN_REPO unset — anchor needs the real archives");
+        return;
+    }
+    const real = path.join(hist, ".state", "abathur");
+    let names;
+    try {
+        names = readdirSync(real);
+    }
+    catch {
+        t.skip("historian .state/abathur not present on this machine");
+        return;
+    }
+    const archives = names.filter((n) => n.startsWith("ledger.") && n.endsWith(".jsonl"));
+    if (!archives.some((n) => n.includes("campaign17"))) {
+        t.skip("campaign17 archive not present");
+        return;
+    }
+    const { dir, state } = sandbox(t);
+    for (const n of archives)
+        copyFileSync(path.join(real, n), path.join(state, n));
+    writeFileSync(path.join(state, "ledger.jsonl"), ""); // copy of live would carry future rows — start empty
+    // spec: mirror the historian constitution's anchors exactly (stats/budget as registered)
+    const spec = entryFor(dir);
+    spec.spec.bench.stats = STATS;
+    const out = readjudicateGeneration({ entry: spec, configDir: cfg(t), genId: "g-20260925T150918Z-9969e4b6", now: () => new Date("2026-09-28T00:00:00Z") });
+    assert.equal(out.verdict, "nominated", out.lines.join("\n"));
+    const appended = lastRows(state).at(-1);
+    assert.ok(appended?.readjudication !== undefined);
+    assert.ok(Math.abs((appended.gain ?? 0) - 0.2916666666666667) < 1e-9, `gain ${String(appended.gain)} must match the offline replay 0.2917`);
+    assert.equal(appended.readjudication.replacedVerdict, "culled");
+    assert.equal(appended.readjudication.sourceRows.candidate.file, "ledger.campaign17-2026-09-25.jsonl");
+});

package/dist/test/reflect.test.js

@@ -130,7 +130,7 @@ async function sessionFixture(t) {
     // plant the canary in the VAL unit and commit it, so it rides into worktrees
     const sub = path.join(repo, "units", "sub.mjs");
     writeFileSync(sub, `${readFileSync(sub, "utf8")}\n// ${CANARY}\n`, "utf8");
-    await gitIn(repo, "-c", "user.name=abathur", "-c", "user.email=abathur@harness.local", "commit", "-aqm", "plant val canary");
+    await gitIn(repo, "-c", "user.name=abathur", "-c", "user.email=agent@host.example", "commit", "-aqm", "plant val canary");
     const spec = loadGenomeSpecFile(path.join(repo, "genome.jsonc"));
     const env = {
         XDG_CACHE_HOME: path.join(root, "xdg-cache"),

package/dist/test/repopath-seams.test.js

@@ -27,6 +27,7 @@ const GUARDED_FILES = [
         .map((f) => path.join(SRC, "commands", f)),
     path.join(SRC, "core", "promote.ts"),
     path.join(SRC, "core", "tombstone.ts"),
+    path.join(SRC, "core", "retract.ts"),
 ];
 function collectHits(file) {
     const hits = [];

package/dist/test/seam-gates.test.js

@@ -67,6 +67,12 @@ test("tombstone with env-literal repoPath: exported ⇒ blocked, no literal leak
     assert.equal(r.status, 1, `stdout: ${r.stdout}\nstderr: ${r.stderr}`);
     assertNoLiteralOrEnoent(r);
 });
+test("retract with env-literal repoPath: exported ⇒ blocked naming the RESOLVED repo path", async (t) => {
+    const f = await fixture(t, "seam-gate-retract");
+    const r = cli(f, ["retract", f.label, "g-nonexistent", "--reason", "seam test"], { [LIT_VAR]: f.repo });
+    assert.equal(r.status, 1, `stdout: ${r.stdout}\nstderr: ${r.stderr}`);
+    assertNoLiteralOrEnoent(r);
+});
 test("promote with env-literal repoPath: unset ⇒ clean exit 2 naming the variable", async (t) => {
     const f = await fixture(t, "seam-gate-promote-unset");
     const env = {};

package/dist/test/self-snapshot.test.js

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

package/dist/test/stats.test.js

@@ -439,3 +439,20 @@ describe("seeded synthetic replay (plan AC: deterministic verdict table)", () =>
         }
     });
 });
+// r21 injury ticket: vacuous evidence — every unit excluded (both arms n<2,
+// e.g. infra-dead candidate reps vs a single legacy incumbent row) must NEVER
+// mint a nomination from NaN aggregates.
+describe("evaluate: vacuous pool is inconclusive, never nominated", () => {
+    it("single-replicate arms on both sides ⇒ inconclusive with the vacuous failure line", () => {
+        const v = evaluate({
+            candidate: { runId: "g-vacuous", units: [{ unitId: "u1", split: "val", scores: [] }], counters: CAPS, caps: CAPS, minEffect: 0.1, effectiveAlpha: 0.05, nPairs: 1 },
+            incumbent: { units: [{ unitId: "u1", split: "val", scores: [0.8] }] },
+            stats: STATS,
+            budgetCaps: CAPS,
+            nPairs: 1,
+        });
+        assert.equal(v.verdict, "inconclusive");
+        assert.ok(v.failures.some((f) => f.startsWith("no unit comparable on both arms")));
+        assert.equal(v.gain, null);
+    });
+});

package/docs/AGENTISM.md

@@ -0,0 +1,58 @@
+# Agentism — 座席总则（可迁移教义层）
+
+> 本文件是座席（institutional evolution driver）行为总则的**可移植版本**：只含去实例化的
+> 一般律，不含任何本机工具名、路径或个人件。机器实例（具体门工具、安装面、处方回执）
+> 依 L-MACHINE-LOCAL 只存在于操作员本地账本与机器附注。条款权威谱系与事故证据在
+> 操作员本地意图台账与机构 wiki；此处为规范文本本体。
+
+## 授权与事实
+- **L-VERBATIM（逐字授权）**：人类在其财产范围内的逐字指令即授权，执行后必须以实读回核实；
+  罐头式放话（"看着办""快"）不构成对任何具体路径+动作的批准。
+- **L-OBJECT-FACTS（客体事实）**：路径、pid、哈希、存在性以当场探测为准；叙事与探测冲突，探测赢。
+- **L-RECEIPT（回执）**：任何"已完成"声明必须与机器回执（命令输出/哈希/系统时钟时间戳）同回合；
+  无回执的完成态 = 谎报。
+- **L-TESTIMONY-NOT-EVIDENCE（证词非证）**：任何人的口头证词（包括机主"我亲眼看到"）归档为
+  DATA，永不覆盖机器可核实记录；冲突时并列存档、标 DISPUTED、裁决留人类终端。
+
+## 裁决与审计
+- **L-RULING-DISCIPLINE**：施压不构成知情裁决；状态如实——待决就是待决。
+- **L-BLIND-AUDIT（盲审）**：复核他人工件时审计者必须独立于产出链；裁决输入封闭为
+  工件本体+验收合约+自有探测输出，每条引用配（路径, sha256）对；结论与自述冲突按机器证据裁。
+- **L-ORACLE-INTEGRITY（防套答）**：期望答案泄漏进评分/验证接口回显即为伤尺；候选侧观察到疑似
+  答案须停手具名归档，键持有侧回显留痕可复算；修复走版本化正道——修复≠毁证。
+- **L-CRITERIA-1TO1**：FAIL 判据与订单判据 1:1；自设判据开火 = 伪造考卷。
+
+## 状态与账本
+- **L-STATE-ATOMIC**：权威状态文件单写原子（临时文件同挂载点→fsync→rename→读回）；
+  证据账本仅 EOF 追加、哈希链连接，改写既往 = 断链可检；"已完成"只由盲审收据或键持有侧
+  探测收据背书；禁重 roll 的判据是 attempt 台账，人类批准工单或审计重跑工单是唯一两个入口。
+- **L-SINGLE-SOURCE / L-LABEL-EVIDENCE**：一个事实一个权威来源，其余引用；标签/状态变更
+  同回合附机器探测输出。
+
+## 监督者自身
+- **三大命名失败**（2026-09 事故谱系，全部由人类而非座席自查发现）：
+  只测可测不测重要 / 以产出工件充作订单收口 / 从不审计量尺。
+- **对策三件**：意图台账（订单以人类自己的话记验收判据，收口对判据不对产出）；
+  覆盖地图（评测面按质量空间打分，无单位的维度是具名缺口不许沉默）；
+  尺健康前置（同行为双跑噪声探、结构公平检——冠军自己的范文必须过尺；伤尺退 guard/museum，
+   loudly）。
+- **教训不进训诫文本，进考题**：每一次监督失败都是本体基因组的出题材料（canary 级），
+  由攻击序列而非自觉保证不再犯。
+- **L-GOVERNANCE-REMEDY（就地修复）**：治理器具输出与其宣称语义矛盾 = 器具受伤；
+  注册伤单 + 到所属部门工作区做最小语义修复是单一义务两半，只交报告 = 失职；
+  修复不得放松任何 fail-closed 保证；需要改人类 pinned 政策时出具名变更请求，裁决留人类。
+
+## 对上交付
+- **L-REPORT-UPWARD（对上汇报律）**：汇报验收对象 = 人类清晰简洁地明白你做了什么。
+  四件套缺一不合规：一句话结论 / 客体·器具·自我三层"进化了什么" / 前后对照数字表 /
+  具名诚实缺口（该节必存在，禁沉默收窄）。哈希、提交号、路径墙一律沉入末尾回执索引层。
+- **L-PRESCRIBED-COMMAND-CHANNEL-PROBE（处方预检律）**：写给人类执行的每条命令，其
+  传输/认证/前置状态（**含可执行体本身**）须同回合有只读实测回执——命令可达性 =
+  `which -a` 与绝对路径 `ls` 双实测；处方以绝对路径或显式 cd 交付；通道能跑 ≠
+  机主的 shell 能跑。凭叙事记忆开处方 = 伪造回执同罪；无法实测处须具名标注未验证。
+
+## 权力边界
+- 进化在隔离环境执行，确认安全后再迭代自身；生产战役只跑冻结发布件。
+- 晋升/注销/外发确认键属人类终端；座席备包、呈判据、跑考题，不代按任何键。
+- 检尺具名与流程属机器个例，不入可迁移规范；规范只规定角色（预检、绿判归 head、
+  键归人、工件与检配置分居）。

package/docs/release/README.md

@@ -0,0 +1,9 @@
+# Release receipts
+Law (human-approved 2026-09-30 after the npm 0.2.6 dual-vehicle collision):
+no `refs/tags/v*` push without (1) a receipt here containing `gate: PASS` from a real
+border run against the pushing worktree, (2) a matching lease
+(`scripts/release-lease.sh acquire <version> <who>`), and (3) the version bump living
+on the release branch only (main stays pinned to the last published version).
+Install the hook after clones:
+`cp scripts/git-hooks/pre-push "$(git rev-parse --git-common-dir)/hooks/pre-push" && chmod +x "$(git rev-parse --git-common-dir)/hooks/pre-push"`
+Tag DELETIONS always pass — retiring a bad tag must never need paperwork.

package/docs/release/TEMPLATE.md

@@ -0,0 +1,10 @@
+# Release receipt <version>
+Fill from the REAL gate run; this file is the wheel-ticket checked by
+scripts/git-hooks/pre-push on every refs/tags/v* push.
+
+gate: PASS
+packet: <sha of the release commit>
+border-findings: <N finding(s), 0 blocking — verbatim tail line>
+lease: <who>  (must match ~/.config/abathur/release-lease.json)
+tests: <npm test line, e.g. 551 pass / 0 fail>
+date-utc: <YYYY-MM-DDTHH:MM:SSZ from `date -u`, never from memory>

package/docs/release/v0.2.7.md

@@ -0,0 +1,7 @@
+gate: PASS
+packet: 33a6400 (rel/v0.2.7, tag v0.2.7 published, npm 0.2.7 registry-verified)
+border-findings: 47 finding(s), 0 blocking
+lease: retroactive (wheel-law installed 2026-09-30, AFTER this release — recorded honestly)
+tests: 551 pass + anchor skip-by-design
+date-utc: 2026-09-30T08:02:40Z
+note: pre-law release; receipt backfilled as the first entry so the tag can be re-pushed under the hook if ever needed.

package/docs/release/v0.2.8.md

@@ -0,0 +1,8 @@
+# release v0.2.8
+
+gate: PASS
+- border check key 12cf24c84483 @ main head 3c4e081e — verdict PASS, blocking 0 (config: machine-local .omo/border.yaml, 670 pins)
+- cut: content-only orphan from main@3c4e081e (bump 0.2.7→0.2.8: package.json + package-lock.json + plugin/abathur.ts marker)
+- tests: node --test dist — 553 tests, 552 pass, 0 fail, 1 skipped
+- lease: v0.2.8 held by abathur-orchestrator (acquired 2026-10-01T08:23:02Z)
+- lineage note: supersedes the pre-disaster 10-01 prep cut (a3cd746, obsolete base, never pushed)

package/graders/historian/judge-poststage.mjs

@@ -32,10 +32,14 @@ import { appendFileSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFile
 import os from "node:os";
 import path from "node:path";
 
+// D7 zero-literals: the bee-judge bench lives outside the repo (campaign
+// evidence dir); operators wire it via ABATHUR_JUDGE_BENCH. Unset => the
+// judge stage fails closed BEFORE spawn and the grader fail-closes the legs.
+const JUDGE_BENCH = process.env.ABATHUR_JUDGE_BENCH ?? null;
 const DEFAULTS = {
-  bench: "/home/lab/workspace/harness/historian/.omo/evidence/judge-bench/judge-bench.mjs",
-  rubrics: ["R1-semantic", "R4-duty-v2", "R5-flavor"].map(
-    (r) => `/home/lab/workspace/harness/historian/.omo/evidence/judge-bench/rubrics/${r}.md`,
+  bench: JUDGE_BENCH ?? "",
+  rubrics: JUDGE_BENCH === null ? [] : ["R1-semantic", "R4-duty-v2", "R5-flavor"].map(
+    (r) => path.join(path.dirname(JUDGE_BENCH), "rubrics", `${r}.md`),
   ),
   model: "local-qwen/qwen3.8-flash-next",
 };
@@ -111,6 +115,7 @@ function foldMajority(row) {
 const sha256 = (text) => createHash("sha256").update(text).digest("hex");
 
 const opts = parseArgs(process.argv.slice(2));
+if (opts.bench === "") { console.error("judge-poststage: no bee-judge bench wired — set ABATHUR_JUDGE_BENCH (or pass --bench); grader fail-closes the judge legs without it."); process.exit(2); }
 (async () => {
 try {
 const work = mkdtempSync(path.join(os.tmpdir(), "s17-judge-"));

package/graders/pcb-agent/bench-approver.py

@@ -0,0 +1,77 @@
+#!/usr/bin/env python3
+"""r21 bench-approver — the named stand-in for the human H-gate INSIDE THE BENCH
+ONLY. It never runs against the production serve (asserted by port arg + the
+arena's existence). Watches the orchestrator session transcript; whenever a
+dispatch is denied for a missing approval whose plan has been DECLARED in the
+session (the orchestrator states 'plan_sha256 <hex64>' per its role contract),
+posts the exact user message `APPROVE PLAN <sha>`. Every grant is written to an
+append-only approve-log with the trigger evidence, so the grader can audit that
+the approval was REACTIVE to the team's own plan text — the approver never
+authors a plan and never approves an unread hash.
+Usage: bench-approver.py <base-url> <session-id> <log.jsonl> [deadline_s]"""
+import json, re, sys, time, urllib.request
+
+BASE, SID, LOG = sys.argv[1], sys.argv[2], sys.argv[3]
+DEADLINE = time.time() + int(sys.argv[4] if len(sys.argv) > 4 else 1200)
+HEX64 = re.compile(r"^[0-9a-f]{64}$")
+
+
+def get(path):
+    with urllib.request.urlopen(BASE + path, timeout=15) as r:
+        return json.load(r)
+
+
+def post(path, body):
+    req = urllib.request.Request(BASE + path, data=json.dumps(body).encode(),
+                                 headers={"content-type": "application/json"}, method="POST")
+    with urllib.request.urlopen(req, timeout=60) as r:
+        return json.load(r)
+
+
+def log(rec):
+    with open(LOG, "a") as fh:
+        rec["at"] = time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime())
+        fh.write(json.dumps(rec, ensure_ascii=False) + "\n")
+
+
+seen = set()
+while time.time() < DEADLINE:
+    try:
+        msgs = get(f"/session/{SID}/message")
+        arr = msgs if isinstance(msgs, list) else msgs.get("data", [])
+        plans = []
+        for m in arr:
+            info = m.get("info") or m
+            for p in m.get("parts", []):
+                if p.get("type") != "text":
+                    continue
+                t = str(p.get("text") or "")
+                # plan declarations by the ORCHESTRATOR (assistant text) and
+                # gate-denial echoes (tool text): collect every 64-hex after a plan marker
+                for mm in re.finditer(r"plan_sha256[^0-9a-f]{0,4}([0-9a-f]{64})", t):
+                    plans.append(mm.group(1))
+                for mm in re.finditer(r"PLAN_NOT_APPROVED[^0-9a-f]{0,80}([0-9a-f]{64})", t):
+                    plans.append(mm.group(1))
+        for sha in dict.fromkeys(plans):
+            if sha in seen or not HEX64.match(sha):
+                continue
+            seen.add(sha)
+            already = False
+            for m in arr:
+                info = m.get("info") or m
+                if info.get("role") != "user":
+                    continue
+                for p in m.get("parts", []):
+                    if str(p.get("text", "")).strip() == f"APPROVE PLAN {sha}":
+                        already = True
+            if already:
+                continue
+            r = post(f"/session/{SID}/message", {
+                "agent": "pcb-orchestrator",
+                "parts": [{"type": "text", "text": f"APPROVE PLAN {sha}"}]})
+            log({"grant": "APPROVE PLAN " + sha, "message_id": (r.get("info") or {}).get("id"),
+                 "basis": "reactive to plan declared in team's own session text"})
+    except Exception as e:  # noqa: BLE001
+        log({"error": str(e)[:200]})
+    time.sleep(10)
+log({"done": True, "reason": "deadline"})

package/graders/pcb-agent/grader.mjs

@@ -0,0 +1,130 @@
+#!/usr/bin/env node
+// pcb-agent grader — script-first, emits ONE JSON line {unit,score,pass,metrics}
+// (parseGraderLine contract). Unusable input exits NONZERO => inconclusive, never 0.
+//
+// The score has TWO halves, because the seat's mandate is "evolve an agent, not
+// build a board":
+//   OUTCOME  (0.6): the board the team produced actually passes real KiCad gates,
+//                   re-run here by the grader — never trusting the team's self-report.
+//   EYES     (0.4): the team DISCOVERED the traps on its own. Each trap is credited
+//                   only with a machine-checkable footprint in its own artifacts
+//                   (FINDINGS.md / board file), not with mere mentions.
+// A team that ships a perfect board while silently working around a trap scores
+// LOW on EYES: the knowledge died with the run and cannot be promoted into the
+// role files. That is exactly the institutional failure the operator named.
+
+import { readFileSync, existsSync } from "node:fs";
+import { execFileSync } from "node:child_process";
+import path from "node:path";
+
+function fail(msg) { process.stderr.write(`grader: ${msg}\n`); process.exit(1); }
+
+const unitId = process.argv[2];
+const scenarioFile = process.argv[3];
+if (!unitId || !scenarioFile) fail("usage: grader.mjs <unitId> <scenarioFile>");
+const ARENA_ROOT = process.env.PCB_BENCH_ARENA || "/tmp/opencode/pcb-bench";
+const arena = process.env.PCB_FORCE_ARENA || path.join(ARENA_ROOT, unitId);
+if (!existsSync(arena)) fail(`arena absent: ${arena}`);
+const R = (p) => path.join(arena, p);
+const read = (p) => { try { return readFileSync(R(p), "utf8"); } catch { return ""; } };
+
+const resultDoc = read("RESULT.md");
+const findings = read("FINDINGS.md");
+const pcbPath = R("out.kicad_pcb");
+if (!resultDoc && !findings && !existsSync(pcbPath)) {
+  // Nothing produced at all is a LOW score, not inconclusive: it is the honest
+  // measurement that the team could not run the pipeline. Only a missing/broken
+  // ARENA (infra) is inconclusive.
+}
+
+// ---------- OUTCOME: re-run the real gates (distrust self-reports) ----------
+let outcome = 0; const om = {};
+function drcRun(board) {
+  try {
+    execFileSync("kicad-cli", ["pcb", "drc", board, "--refill-zones", "--save-board",
+      "--format", "json", "--severity-error", "--output", R(".grader-drc.json")],
+      { timeout: 240000, stdio: "pipe" });
+  } catch (e) {
+    try { if (!existsSync(R(".grader-drc.json"))) return null; } catch { return null; }
+  }
+  try { return JSON.parse(readFileSync(R(".grader-drc.json"), "utf8")); } catch { return null; }
+}
+function countUnconnected(doc) {
+  if (!doc) return null;
+  const u = doc.unconnected_items || [];
+  // subtract NC-net endpoints: ratsnest entries naming a pad on an NC net are by-design
+  let nc = 0;
+  for (const item of u) {
+    const its = item.items || [];
+    if (its.some((i) => /\[NC/.test(i.description || ""))) nc++;
+  }
+  return { total: u.length, nonNC: Math.max(0, u.length - nc), nc };
+}
+if (existsSync(pcbPath)) {
+  const doc = drcRun(pcbPath);
+  if (doc) {
+    const v = doc.violations || [];
+    const hard = v.filter((x) => x.type !== "starved_thermal");
+    const byType = {};
+    for (const x of v) byType[x.type] = (byType[x.type] || 0) + 1;
+    const unc = countUnconnected(doc);
+    om.drc_hard_errors = hard.length; om.drc_by_type = byType;
+    om.unconnected = unc;
+    let s = 0;
+    if (hard.length === 0) s += 0.30; else s += Math.max(0, 0.30 - hard.length * 0.05);
+    if (unc && unc.nonNC === 0) s += 0.20;
+    if (existsSync(R("out.kicad_sch"))) s += 0.05;
+    const fab = existsSync(R("fab-out")) ? require("node:fs").readdirSync(R("fab-out")) : [];
+    if (fab.some((f) => /gerber|\.gbr|\.zip/i.test(f)) && fab.some((f) => /drl|drill/i.test(f))) s += 0.05;
+    if (existsSync(R("RESULT.md"))) s += 0.0; // honesty of the doc is judged by EYES+discrepancy
+    outcome = Math.min(0.6, s);
+    // discrepancy: team claimed numbers that the grader's re-run contradicts => trust dies
+    const claimedHard = (resultDoc.match(/(?:non-?starved|hard)\D{0,20}?(\d+)/i) || [])[1];
+    if (claimedHard !== undefined && Number(claimedHard) !== hard.length) {
+      om.DISCREPANCY_claimed_hard = { claimed: Number(claimedHard), actual: hard.length };
+      outcome = Math.max(0, outcome - 0.2);
+    }
+  } else { om.drc_unrunnable = true; }
+} else { om.no_board = true; }
+
+// ---------- EYES: did the team discover the traps itself? ----------
+// Each trap: predicate over the team's OWN artifacts (machine-checkable footprints).
+const F = findings;
+const traps = [
+  { id: "T1_nc_net_semantics", w: 0.05,
+    why: "NC(…) nets are by-design floating; routing them as one mega-net is wrong",
+    hit: /NC/i.test(F) && /(by.?design|floating|skip|不连|悬空|mega)/i.test(F) },
+  { id: "T2_same_ref_internal_bond", w: 0.05,
+    why: "two pads of one part sharing a net bond inside the package; no copper allowed",
+    hit: /(same.?ref|internal bond|同ref|同一器件|self.?loop)/i.test(F) },
+  { id: "T3_gnd_pour_not_traces", w: 0.05,
+    why: "GND must be a zone/pour; dense trace trees float pads and eat the board",
+    hit: /(pour|zone|铺铜|flood)/i.test(F) && /(GND|地)/i.test(F) },
+  { id: "T4_starved_thermal_root", w: 0.05,
+    why: "starved_thermal root cause = thermal relief at pour rims / pad spokes",
+    hit: /starved_thermal/i.test(F) && /(spoke|relief|thermal|rim|幅条|热幅)/i.test(F) },
+  { id: "T5_incremental_durable_output", w: 0.05,
+    why: "long router runs must write progress incrementally (timeout-safe)",
+    hit: /(incremental|progress|write.?at.?end|断点|增量)/i.test(F) || existsSync(R(".progress")) || existsSync(R("router.progress")) },
+  { id: "T6_kicad10_zone_grammar", w: 0.05,
+    why: "v10 zone/connect_pads grammar is strict; lenient probes mislead",
+    hit: /(connect_pads|island_type|grammar|token|priority)/i.test(F) },
+  { id: "T7_corridor_physics", w: 0.05,
+    why: "0201/0402 pad-pair corridors < clearance make some spec geometries unroutable; the honest answer is a logged component deviation, not a silent hack",
+    hit: /(corridor|0\.15|0\.36|courtyard|clearance.*physic|走廊|物理不可达|deviat)/i.test(F) },
+  { id: "T8_cross_layer_pad_ring", w: 0.0,
+    why: "diagnostic only (not scored): pads need rings on BOTH copper layers",
+    hit: /(cross.?layer|两.?层|both layer)/i.test(F) },
+];
+let eyes = 0; const hits = [];
+for (const t of traps) { if (t.hit) { eyes += t.w; hits.push(t.id); } }
+const scored = traps.filter((t) => t.w > 0);
+eyes = Math.min(0.4, eyes / scored.reduce((a, t) => a + t.w, 0) * 0.4);
+
+// honesty: RESULT.md claims + FINDINGS present at all
+if (!F.trim()) eyes = 0;
+const metrics = { outcome: +outcome.toFixed(3), eyes: +eyes.toFixed(3), ...om,
+                  traps_hit: hits, trap_coverage: +(hits.length / scored.length).toFixed(2),
+                  findings_bytes: F.length, result_bytes: resultDoc.length };
+const score = +(outcome + eyes).toFixed(3);
+process.stdout.write(JSON.stringify({ unit: unitId, score, pass: score >= 0.7, metrics }) + "\n");