@tachikomagundam/abathur 0.2.7 → 0.2.8

package/dist/core/evolve/run-bench.js

@@ -138,7 +138,13 @@ export async function benchTarget(o) {
                     continue;
                 }
                 const score = await bundle.adapter.score(unit);
-                if (score.kind === "scored") {
+                if (score.kind === "scored" && !Number.isFinite(score.result.score)) {
+                    // r21 injury ticket: a NaN/Inf score is a BROKEN RULER, not a number —
+                    // it must never become a replicate (vacuous aggregates minted bogus
+                    // nominations: stats saw finite-looking rows and judged on nothing).
+                    row.failures.push(`${unit.id} rep ${String(rep)}: grader score not finite (${String(score.result.score)}) — ruler failure, never counts as evidence`);
+                }
+                else if (score.kind === "scored") {
                     row.scores.push(score.result.score);
                     row.runIds.push(runId(o.genId, unit.id, rep));
                     if (!score.result.pass) {

package/dist/core/stats.js

@@ -188,6 +188,13 @@ export function evaluate(input) {
     }
     const candKept = candidate.units.filter((u) => !excluded.has(u.unitId));
     const incKept = incumbent.units.filter((u) => !excluded.has(u.unitId));
+    // Vacuous-evidence guard (r21 postmortem): every unit symmetrically excluded
+    // (both arms n<2 — infra death or missing replicates) leaves an empty pool;
+    // downstream means of empty arrays are NaN, and a NaN gain must never reach
+    // a nomination. This is a bench-health event, not a candidate verdict.
+    if (candKept.length === 0 && incKept.length === 0) {
+        return { ...base, verdict: "inconclusive", exitCode: needsExit("inconclusive"), gain: null, unitComparisons: [], failures: ["no unit comparable on both arms (all excluded: infrastructure failures or missing replicates) — vacuous evidence, never nominated"] };
+    }
     const candByUnitKept = new Map(candKept.map((u) => [u.unitId, u]));
     // 3) Per-val-unit comparisons + the two precision gates. With a bank that
     //    knows the unit, acceptance semantics (see module header) replace the

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/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");

package/graders/pcb-agent/mutate.sh

@@ -0,0 +1,165 @@
+#!/usr/bin/env bash
+# Mutator wrapper for the historian live run (task 14). Invoked by the run-loop
+# as `bash mutate.sh <brief-file> <worktree> <model>` with cwd = the throwaway
+# launch worktree (reflect.ts contract). The REAL candidate source is a headless
+# `opencode run` child: it reads the reflection brief and proposes exactly one
+# mutation — a new RUN CARD under abathur-notes/ (never a sealed path;
+# kernel.immutableGlobs is enforced independently by the driver's PathPolicy).
+# Run cards are the delivery seam (S4): run-scenario.sh appends them VERBATIM to
+# every scenario brief under a `## Run card` heading, so a candidate tree's
+# mutation genuinely steers the benched agent and score deltas are attributable.
+# The wrapper deterministically packages the model's run card as a unified CREATE
+# diff (creation diffs have no context to drift) and appends a genome.jsonc
+# create-diff carrying the resolved spec bytes (plan 184: every sealed tree
+# must contain genome.jsonc so bundle export self-describes; plan 181 requires
+# it for the lineage). On unparseable model output the wrapper degrades to a
+# packaging-only candidate — honest, logged, never a fabricated mutation.
+set -uo pipefail
+brief_file="${1:?usage: mutate.sh <brief-file> <worktree> <model>}"
+worktree="${2:?usage: mutate.sh <brief-file> <worktree> <model>}"
+model="${3:?usage: mutate.sh <brief-file> <worktree> <model>}"
+# the published engine does not export ABATHUR_GENOME_CANONICAL; derive from the
+# launch worktree's own genome.jsonc (written by the engine each round). Env wins
+# when present; missing-both still fail-closes on the [ -f "$canonical" ] guard.
+canonical="${ABATHUR_GENOME_CANONICAL:-$worktree/genome.jsonc}"
+[ -f "$brief_file" ] || { echo "mutate: missing brief $brief_file" >&2; exit 1; }
+cp -f "$brief_file" "${ABATHUR_MUTATOR_RAW:-/tmp/abathur-mutate-raw.jsonl}.brief" 2>/dev/null || true
+[ -f "$canonical" ] || { echo "mutate: missing canonical spec $canonical" >&2; exit 1; }
+bin="${ABATHUR_OPENCODE_BIN:-opencode}"
+
+ptfile="$(mktemp /tmp/abathur-mutate-prompt.XXXXXX)"
+cat > "$ptfile" <<'PROMPT_EOF'
+You are the genome mutator of the Abathur evolution harness, PCB-agent lane. Read the reflection brief below (evidence from the incumbent bench of the pcb-agent genome: the PCB team run log, FINDINGS.md, and the grader OUTCOME/EYES metrics). Propose exactly ONE improvement: create a NEW RUN CARD under abathur-notes/ (slug .md). The run card is appended VERBATIM to the team task brief at bench time — write direct, actionable engineering guidance the PCB orchestrator team can follow. TARGET THE EYES GAP: if the grader shows traps the team hit but never NAMED (trap_coverage low while outcome partial), the card must teach the DISCOVERY PROCEDURE (how to notice this class of defect yourself), not the pasted answer — an answer scores once and dies; a discovery method evolves the team. Prefer converting one observed failure into a check the team can run itself. Output ONLY a single JSON object, no prose, shape:
+{"rationale": "<one sentence, <=400 chars>", "path": "abathur-notes/<slug>.md", "content": "<full markdown file contents>"}
+Do not modify any other path. Scenarios/, README.md and genome.jsonc are immutable; board tooling lives in the arena, not the genome tree.
+
+BRIEF:
+PROMPT_EOF
+cat "$brief_file" >> "$ptfile"
+prompt="$(cat "$ptfile")"
+rm -f "$ptfile"
+
+raw="${ABATHUR_MUTATOR_RAW:-/tmp/abathur-mutate-raw.jsonl}"
+"$bin" run --model "$model" --format json -- "$prompt" >"$raw" 2>/dev/null
+rc=$?
+echo "mutate: opencode rc=$rc raw=$raw" >&2
+
+python3 - "$raw" "$canonical" "$rc" "$worktree" <<'PY'
+import json, os, re, sys
+
+raw, canonical_path, rc, worktree = sys.argv[1], sys.argv[2], int(sys.argv[3]), sys.argv[4]
+
+def create_diff(path, text):
+    lines = text.split("\n")
+    if lines and lines[-1] == "":
+        lines.pop()
+    body = "".join("+" + ln + "\n" for ln in lines)
+    return f"--- /dev/null\n+++ b/{path}\n@@ -0,0 +1,{len(lines)} @@\n{body}"
+
+def last_text_events(path):
+    texts = []
+    try:
+        with open(path, encoding="utf-8", errors="replace") as fh:
+            for line in fh:
+                line = line.strip()
+                if not line:
+                    continue
+                try:
+                    ev = json.loads(line)
+                except ValueError:
+                    continue
+                part = ev.get("part") or {}
+                if ev.get("type") == "text" and isinstance(part.get("text"), str):
+                    texts.append(part["text"])
+    except FileNotFoundError:
+        pass
+    return texts
+
+proposal = None
+for text in reversed(last_text_events(raw)):
+    candidate = text.strip()
+    fence = re.search(r"```(?:json)?\s*(\{.*\})\s*```", candidate, re.S)
+    if fence:
+        candidate = fence.group(1)
+    end = candidate.rfind("}")
+    if end < 0:
+        continue
+    # prose preambles can contain set-notation braces like {症状/Symptoms, ...} —
+    # the first '{' is not necessarily JSON; try every open brace from the LAST
+    # backwards so the outermost-to-last-close object wins when one parses.
+    opens = [i for i, ch in enumerate(candidate) if ch == "{" and i < end]
+    doc = None
+    for start in reversed(opens):
+        try:
+            parsed = json.loads(candidate[start : end + 1])
+        except ValueError:
+            continue
+        if isinstance(parsed, dict):
+            doc = parsed
+            break
+    if doc is not None:
+        proposal = doc
+        break
+
+spec_text = open(canonical_path, encoding="utf-8").read()
+if not spec_text.endswith("\n"):
+    spec_text += "\n"
+# genome.jsonc in the base tree was written by this wrapper's own prior round,
+# so a replace-all modify hunk always anchors deterministically at line 1.
+# A CREATE here would break apply the moment the file lands in the base (udiff
+# refuses create-over-existing and discards the WHOLE candidate).
+gen_path = os.path.join(worktree, "genome.jsonc")
+try:
+    with open(gen_path, encoding="utf-8") as fh:
+        base_text = fh.read()
+except FileNotFoundError:
+    packaging = create_diff("genome.jsonc", spec_text)
+except OSError as err:
+    sys.stderr.write("mutate: genome.jsonc unreadable: %s\n" % err)
+    sys.exit(3)
+else:
+    if base_text == spec_text:
+        packaging = None
+    else:
+        base_body = base_text.split("\n")
+        if base_body and base_body[-1] == "":
+            base_body.pop()
+        old_h = "".join("-" + ln + "\n" for ln in base_body)
+        new_h = "".join("+" + ln + "\n" for ln in spec_text.split("\n")[:-1])
+        packaging = (
+            "--- a/genome.jsonc\n+++ b/genome.jsonc\n"
+            "@@ -1,%d +1,%d @@\n%s%s" % (len(base_body), len(spec_text.split("\n")) - 1, old_h, new_h)
+        )
+
+if isinstance(proposal, dict):
+    path = proposal.get("path")
+    content = proposal.get("content")
+    rationale = proposal.get("rationale")
+    if (
+        isinstance(path, str)
+        and re.fullmatch(r"abathur-notes/[a-z0-9][a-z0-9._-]{0,63}\.md", path)
+        and isinstance(content, str)
+        and 0 < len(content) < 200000
+        and isinstance(rationale, str)
+        and 0 < len(rationale) <= 4000
+        and "\x00" not in content
+    ):
+        content = content.replace("\r", "")
+        if not content.endswith("\n"):
+            content += "\n"
+        diffs = [create_diff(path, content)] + ([packaging] if packaging else [])
+        candidate = {"id": "mutate-live", "rationale": rationale, "diffs": diffs}
+        print(json.dumps({"candidates": [candidate]}))
+        sys.exit(0)
+
+if packaging:
+    print(json.dumps({
+        "candidates": [{
+            "id": "mutate-package-only",
+            "rationale": "packaging-only candidate: model output unparseable or path rejected (opencode rc=%d); lineage genome.jsonc added, no skill mutation proposed" % rc,
+            "diffs": [packaging],
+        }]
+    }))
+else:
+    print(json.dumps({"candidates": []}))
+PY

package/graders/pcb-agent/r20-bench.sh

@@ -0,0 +1,27 @@
+#!/usr/bin/env bash
+# r20 production-topology bench sandbox: runs a command INSIDE bwrap where the
+# arena is bind-mounted AT the control literal, with host-vendored dirs re-bound
+# over the arena's excluded gaps (bind-mounts stack: later wins).
+# Usage: r20-bench.sh <arena> -- <inner command...>
+set -euo pipefail
+ARENA="${1:?arena}"; shift; [ "${1:-}" = "--" ] && shift
+SRC=/home/lab/workspace/pcb-control
+LIT=$SRC   # the literal path the control plane believes itself to be
+# v8 netns ABANDONED: lo cannot be raised in this unprivileged userns (EPERM).
+# Isolation strategy instead: arena bind at the literal (fs) + PCB_PRODUCTION_SERVE_PORT
+# exported to a FREE host port (net coexistence; data dirs are the arena's, so the
+# bench serve cannot touch the real lane state; verified by G5 record tuple).
+PORT=$(python3 -c "import socket;s=socket.socket();s.bind((\"127.0.0.1\",0));print(s.getsockname()[1]);s.close()")
+ARGS=(--ro-bind / / --dev-bind /dev /dev --proc /proc --bind /tmp /tmp
+      --bind "$ARENA" "$LIT" --unshare-pid --setenv PCB_PRODUCTION_SERVE_PORT "$PORT")
+# vendored opencode binary (excluded from arena tar; must appear AT the literal)
+ARGS+=(--ro-bind "$SRC/profiles/production/bin" "$LIT/profiles/production/bin")
+# every vendored node_modules under the control tree (typescript for the loader,
+# production-home caches carrying OMO/ACP/HR packages) — ro at their literals
+while IFS= read -r -d '' d; do
+  rel="${d#$SRC}"
+  [ -d "$ARENA$rel" ] && continue   # arena copy exists: leave it (candidate-owned)
+  mkdir -p "$ARENA$(dirname "$rel")" 2>/dev/null || true
+  ARGS+=(--ro-bind "$d" "$LIT$rel")
+done < <(find "$SRC" -maxdepth 6 -name node_modules -type d -print0)
+exec bwrap "${ARGS[@]}" -- /bin/bash -c "$*"

package/graders/pcb-agent/reset-sandbox.sh

@@ -0,0 +1,7 @@
+#!/usr/bin/env bash
+# Reset hook (pcb-agent): honest no-op. Freshness is guaranteed at run time —
+# run-scenario.sh re-seeds the arena (rm -rf + copy pristine starter kit) at the
+# top of EVERY rep, so back-to-back generations are state-equal without a
+# separate wipe. Kept as an explicit file so the contract is visible, not empty.
+set -euo pipefail
+echo "RESET-NOOP (per-rep reseed happens in run-scenario.sh)"

package/graders/pcb-agent/run-scenario-r20.sh

@@ -0,0 +1,77 @@
+#!/usr/bin/env bash
+# r20 run-scenario v2 — PRODUCTION-TOPOLOGY bench (user ruling 2026-09-30:
+# "我工作环境里是要用PCB-Orchestrator这个角色来执行的"). One rep = fresh arena
+# (per-rep reseed is the L2 reset AND the pollution guard: smoke runs mutate the
+# copied opencode.db/config and can drift G1), bwrap quarantine at the control
+# literal, launcher-gated serve on a free port (netns impossible: lo EPERM),
+# scenario driven as a REAL pcb-orchestrator session over REST, transcript +
+# control-plane ledger harvested with literal->arena path mapping for the grader.
+# Usage: run-scenario-r20.sh <unit-id> <scenario-file> <genome-repo> [arena-root]
+set -uo pipefail
+UNIT="$1"; SCENARIO="$2"; GENOME_REPO="$3"; ARENA="${4:-/tmp/r20-arena-$UNIT}"
+GRAD=/home/lab/workspace/harness/Abathur/graders/pcb-agent
+LIT=/home/lab/workspace/pcb-control
+OUT="$GENOME_REPO/.omo/run-artifacts/$UNIT"; mkdir -p "$OUT"
+BRIEF_FILE="$OUT/brief.md"; cp "$SCENARIO" "$BRIEF_FILE"
+
+bash "$GRAD/seed-r20-arena.sh" "$ARENA" "$GENOME_REPO" > "$OUT/seed.log" 2>&1 || { echo "SEED_FAIL" > "$OUT/infra.fail"; exit 1; }
+
+# candidate role files: seed copied $GENOME_REPO/agents/*.md over all three trees (v4 seam)
+
+cat > "$OUT/inner.sh" <<'INNER'
+set -x
+L=/home/lab/workspace/pcb-control
+OUTD=__OUT__
+PORT=${PCB_PRODUCTION_SERVE_PORT}
+cd $L/production-console
+export HOME=$L/production-home
+timeout ${PCB_REP_TIMEOUT:-1500} $L/tools/start_production_orchestrator_ui.sh --serve $PORT > $OUTD/serve.log 2>&1 &
+SPID=$!
+OK=0
+for i in $(seq 1 150); do sleep 3
+  curl -s --max-time 2 http://127.0.0.1:$PORT/session >/dev/null 2>&1 && { OK=1; break; }
+  kill -0 $SPID 2>/dev/null || break
+done
+[ "$OK" = 1 ] || { echo "SERVE_UP=0" > $OUTD/infra.fail; kill $SPID 2>/dev/null; exit 1; }
+$L/tools/start_production_orchestrator_ui.sh --probe $PORT 2>&1 | tail -1 > $OUTD/probe.txt
+SID=$(curl -s --max-time 10 -X POST http://127.0.0.1:$PORT/session -H 'content-type: application/json' -d "{\"title\":\"bench-$UNIT\"}" | python3 -c "import json,sys;print(json.load(sys.stdin).get('id',''))")
+# r21: named bench-approver arm (reactive H-gate stand-in, append-only audit log)
+setsid nohup python3 /home/lab/workspace/harness/Abathur/graders/pcb-agent/bench-approver.py \
+  http://127.0.0.1:$PORT "$SID" $OUTD/approve-log.jsonl ${PCB_TURN_TIMEOUT:-1200} >/dev/null 2>&1 &
+APPR=$!
+python3 - "$OUTD" "$BRIEF_FILE" <<'PYMSG' > $OUTD/payload.json
+import json, sys
+outd, brief = sys.argv[1], sys.argv[2]
+msg = open(brief).read()
+json.dump({"agent": "pcb-orchestrator",
+           "model": {"providerID": "local-qwen", "modelID": "qwen3.8-flash-next"},
+           "parts": [{"type": "text", "text": msg}]}, open(outd + "/payload_body.json", "w"))
+PYMSG
+timeout ${PCB_TURN_TIMEOUT:-1200} curl -s --max-time ${PCB_TURN_TIMEOUT:-1200} -X POST "http://127.0.0.1:$PORT/session/$SID/message" -H 'content-type: application/json' -d @$OUTD/payload_body.json > $OUTD/transcript.json
+echo "$SID" > $OUTD/session-id
+kill $SPID $APPR 2>/dev/null
+[ -s $OUTD/transcript.json ] || { echo "EMPTY_TRANSCRIPT" > $OUTD/infra.fail; exit 1; }
+INNER
+sed -i "s#__OUT__#/tmp/r20-out-$UNIT#g" "$OUT/inner.sh"  # sandbox-writable; harvested after
+mkdir -p /tmp/r20-out-$UNIT && rm -f /tmp/r20-out-$UNIT/*
+
+# r20-bench.sh builds the full mount table (bin + every vendored node_modules
+# literal-stack + free-port env). inner.sh reads $PCB_PRODUCTION_SERVE_PORT.
+timeout $(( ${PCB_REP_TIMEOUT:-1500} + 900 )) bash "$GRAD/r20-bench.sh" "$ARENA" -- \
+  "BRIEF_FILE=$BRIEF_FILE bash $OUT/inner.sh" > "$OUT/inner.log" 2>&1
+RC=$?
+cp -f /tmp/r20-out-$UNIT/* "$OUT/" 2>/dev/null || true
+# node_modules literal-stack binds (arena lacks them by design)
+# harvest: map the control literal back to the arena for the grader
+python3 - "$OUT" "$ARENA" "$LIT" <<'PYH' 2>/dev/null || true
+import json, os, re, sys
+out, arena, lit = sys.argv[1:4]
+t = os.path.join(out, "transcript.json")
+if os.path.exists(t):
+    s = open(t, errors="replace").read().replace(lit, arena)
+    open(t, "w").write(s)
+PYH
+cp -f "$ARENA"/state/capabilities/*.json "$OUT/" 2>/dev/null || true
+find "$ARENA/state" -name 'denied-*' -newer "$OUT/seed.log" 2>/dev/null | head -20 > "$OUT/ledger-rows.txt"
+echo "r20-rep rc=$RC unit=$UNIT arena=$ARENA out=$OUT"
+exit $RC