@event4u/agent-config 9.4.0 → 9.5.0

package/.claude-plugin/marketplace.json

@@ -6,7 +6,7 @@
   },
   "metadata": {
     "description": "Bootstrap shim for the event4u agent-config suite. This plugin ships ONLY the dispatcher hooks plus one install-pointer skill — ALL content (skills, rules, commands) is installed via `npx -y @event4u/agent-config init`, which writes the file projection AND registers the same hooks in ~/.claude/settings.json. DEPRECATED as a content channel; kept so the marketplace listing stays discoverable and existing installs keep working hooks.",
-    "version": "9.4.0",
+    "version": "9.5.0",
     "keywords": [
       "agent-config",
       "skills",

package/CHANGELOG.md

@@ -1056,6 +1056,20 @@ our recommendation order, not its support status.
 > that forces a new era split (`# Era: 9.3.x`, etc.) — see
 > [`docs/contracts/CHANGELOG-conventions.md § Era splits`](docs/contracts/CHANGELOG-conventions.md).
 
+## [9.5.0](https://github.com/event4u-app/agent-config/compare/9.4.0...9.5.0) (2026-07-20)
+
+### Features
+
+* **bench:** defect-finding runner + results (team-mode Phase 5 Steps 2-4) ([aca13fd](https://github.com/event4u-app/agent-config/commit/aca13fd0c212a1af31c0715bf56db1972d819d0b))
+* **bench:** pre-registered defect-finding corpus (team-mode Phase 5 Step 1) ([e7b5300](https://github.com/event4u-app/agent-config/commit/e7b5300d39fa6f2e9ac4fb0d42934cb08d8a9382))
+
+### Documentation
+
+* **roadmap:** close team-mode Phase 5 on the honest-null verdict ([2ff25dd](https://github.com/event4u-app/agent-config/commit/2ff25dd2837872f2ff36139839abc9211d7e7305))
+* **proof:** record the team-mode defect-finding honest null (Phase 5 Step 4-5) ([908284a](https://github.com/event4u-app/agent-config/commit/908284a9dc20d067aaaf1305b3c352f260c88e82))
+
+Tests: 7833 (+0 since 9.4.0)
+
 ## [9.4.0](https://github.com/event4u-app/agent-config/compare/9.3.0...9.4.0) (2026-07-20)
 
 ### Features

package/dist/agent-src/templates/agents/agent-project-settings.example.yml

@@ -39,7 +39,7 @@ schema_version: 1
 # CI guard: a release bump of `package.json` must update this value
 # in lockstep — see scripts/check_template_pin_drift.ts (road-to-
 # portable-runtime-and-update-check P3.3).
-agent_config_version: "9.4.0"
+agent_config_version: "9.5.0"
 
 # --- Project identity ---
 project:

package/dist/discovery/deprecation-report.md

@@ -1,6 +1,6 @@
 # Discovery — Deprecation Report
 
-- Generated: `2026-07-20T09:32:39Z`
+- Generated: `2026-07-20T14:45:21Z`
 - Deprecated artefacts: **0**
 
 _None. Tree is clean._

package/dist/discovery/discovery-manifest.json

@@ -13924,7 +13924,7 @@
       "reason": "scaffold template for ticket-bundle tickets (ADR-101); carries no runtime frontmatter — emit-tickets fills it in per ticket"
     }
   ],
-  "generated_at": "2026-07-20T09:32:39Z",
+  "generated_at": "2026-07-20T14:45:21Z",
   "packs": [
     {
       "artefact_count": 109,

package/dist/discovery/discovery-manifest.json.sha256

@@ -1 +1 @@
-a59f1fc1e9fccbdf2e6b8b99257e83439d96bb9b0c2ad694f2cfece80671657c  discovery-manifest.json
+598c2a96c3ab8210a9c9b23eb4e4292c1ccd9a190179b8172a10a7eb11180f8a  discovery-manifest.json

package/dist/discovery/discovery-manifest.summary.md

@@ -1,6 +1,6 @@
 # Discovery Manifest — Summary
 
-- Generated: `2026-07-20T09:32:39Z`
+- Generated: `2026-07-20T14:45:21Z`
 - Scanner: `c24312e116f8`
 - Artefacts: **575**
 - Unassigned: **0**

package/dist/discovery/orphan-report.md

@@ -1,6 +1,6 @@
 # Discovery — Orphan Report
 
-- Generated: `2026-07-20T09:32:39Z`
+- Generated: `2026-07-20T14:45:21Z`
 - Orphan artefacts: **0**
 
 > An orphan is an artefact whose declared pack has no other members.

package/dist/discovery/packs.json

@@ -1,6 +1,6 @@
 {
   "checksum": "sha256:16d037e41d10dcc83bb73c58b96e6aa3377ce5feb56a8d23aee0ef58e8a97c5c",
-  "generated_at": "2026-07-20T09:32:39Z",
+  "generated_at": "2026-07-20T14:45:21Z",
   "packs": [
     {
       "always_on": false,

package/dist/discovery/trust-report.md

@@ -1,6 +1,6 @@
 # Discovery — Trust Report
 
-- Generated: `2026-07-20T09:32:39Z`
+- Generated: `2026-07-20T14:45:21Z`
 - Workspaces tracked: **10**
 - Human-review-required artefacts: **3**
 

package/dist/discovery/workspaces.json

@@ -1,6 +1,6 @@
 {
   "checksum": "sha256:16d037e41d10dcc83bb73c58b96e6aa3377ce5feb56a8d23aee0ef58e8a97c5c",
-  "generated_at": "2026-07-20T09:32:39Z",
+  "generated_at": "2026-07-20T14:45:21Z",
   "scanner_version": "c24312e116f8",
   "workspaces": [
     {

package/dist/mcp/registry-manifest.json

@@ -9,7 +9,7 @@
     "homepage": "https://event4u-app.github.io/agent-config",
     "name": "@event4u/agent-config",
     "repository": "https://github.com/event4u-app/agent-config",
-    "version": "9.4.0"
+    "version": "9.5.0"
   },
   "registries": [
     {

package/docs/CLAIMS.md

@@ -245,6 +245,13 @@ visible, not hidden.
 - status: backed
 - last_verified: 2026-07-12
 
+### claim: team-defect-finding-null
+- claim: On the pre-registered 12-fixture defect-finding corpus (three arms, deterministic file-level recall, codex reviewer gpt-5.5), the cross-model team-review arm produced NO recall lift over single-model self-review — all three arms recalled every planted defect (Δ = 0, H1 not met). Honest null, ceiling-limited (recall 1.00 everywhere: the seeded defects are too obvious to discriminate the arms on recall); the only non-null signal is a single self-review false positive on the controversial-but-correct control vs 0 for team/council. No cross-model quality/lift claim binds; team mode stays workflow-value-only. Re-open: a judge-survivable-subtlety corpus or a new model generation.
+- kind: quant
+- evidence: internal/bench/reports/defect-finding.json#honest_null
+- status: backed
+- last_verified: 2026-07-20
+
 ### claim: adversarial-council-finding-coverage
 - claim: On the residual defect pool (planted defects that survive a single strong cross-model judge), an adversarial panel of >=2 distinct-vendor skeptics finds materially more residual defects than that single judge — relative residual-recall lift >= +25% AND absolute >= +8 percentage points — at a false-positive rate on a controversial-but-correct control no worse than the single-judge baseline (within noise). Scope: finding coverage, NOT decision quality (the separate, unbacked council-vs-solo-baseline question). Pre-registered; honest-null (either threshold missed or FP worse) keeps the surface off by default permanently.
 - kind: quant

package/docs/benchmark.md

@@ -582,3 +582,43 @@ controversial-but-correct control.
   judge-survivable-subtlety corpus with a published distribution, then (2) a
   maintainer-gated paid cross-vendor run. Honest-null on that run keeps the
   surface default-off permanently, like recursive-verification.
+
+
+## Defect-finding: team vs self-review vs council (2026-07-20) — HONEST NULL (ceiling-limited) {#honest-null-defect}
+
+Pre-registered 12-fixture corpus (`internal/bench/corpora/defect-finding.yaml`:
+10 seeded-defect diffs across logic / off-by-one / race / missing-empty-state /
+security-smell, + 2 controls), three arms, deterministic file-level recall
+against ground truth (blind rubric judge deferred — the primary metric is
+deterministic). Codex reviewer pinned `gpt-5.5`. Total billable $0.083 (arm b
+codex = ChatGPT subscription, $0).
+
+| arm | recall | correctness | design | false-positives |
+|---|--:|--:|--:|--:|
+| self-review (single model) | 1.00 | 1.00 | 1.00 | 1 |
+| team (cross-model, codex) | 1.00 | 1.00 | 1.00 | 0 |
+| council (neutral breadth)  | 1.00 | 1.00 | 1.00 | 0 |
+
+**Verdict: HONEST NULL.** H1 (cross-model team > single-model self-review on
+correctness recall, Δ ≥ +0.20) is **not met** — Δ = 0: all three arms recalled
+every planted defect. H2 (council ≈ team on design, within 0.10) is met (Δ = 0).
+H3 (≤ 1 false positive/arm) is met.
+
+**Corpus-validity caveat (the honest bound):** recall 1.00 across every arm is a
+**ceiling effect** — these seeded defects are catchable by any strong model, so
+the corpus cannot discriminate the arms on recall. This is the same limitation
+the adversarial-verification-council section names: a corpus of obvious,
+model-differentiating defects measures parity, not the judge-survivable
+subtleties where a cross-model lens might actually differ. The one non-null
+signal is precision, not recall: single-model self-review produced 1 false
+positive on the controversial-but-correct control (`df-ctl-01`, a
+behaviour-preserving `clamp` refactor) where team and council produced 0 — a
+hint of a multi-arm precision edge, within the pre-registered H3 bound, too
+small to claim.
+
+**Disposition (Phase 5 Step 5): evidence-closed as NULL.** No cross-model
+defect-finding *quality/lift* claim binds; team mode stays documented as
+**workflow value only**. Re-open conditions: (a) a curated
+judge-survivable-subtlety corpus that breaks the recall ceiling, or (b) a new
+model generation. The worker-via-bundle delegate (roadmap Phase 3 Step 4) stays
+deferred — it re-opened only on a measured review lift, which did not occur.

package/docs/proof.md

@@ -48,9 +48,10 @@ evidence pointer, or `task check-claims` fails the build.
 | Every artifact the package ships — source AND the condensed projection that reaches consumers — is machine-scanned in CI for hidden-Unicode, mixed-script-confusable, and instruction-smuggling payloads (the rules-file-backdoor class); a finding blocks the release before `npm publish`, not just the merge. | qual | `.github/workflows/publish-npm.yml#lint_agent_security` | ✅ |
 | 278 skills. | quant | `src/scripts/check_artefact_count_messaging.ts#Artefact-count messaging gate` | ✅ |
 | Removes only its own keys from a shared host config (matched by JSON-pointer + SHA-256), never a neighbour tool's entries. | qual | `docs/contracts/install-layout.md#JSON-pointer` | ✅ |
+| On the pre-registered 12-fixture defect-finding corpus (three arms, deterministic file-level recall, codex reviewer gpt-5.5), the cross-model team-review arm produced NO recall lift over single-model self-review — all three arms recalled every planted defect (Δ = 0, H1 not met). Honest null, ceiling-limited (recall 1.00 everywhere: the seeded defects are too obvious to discriminate the arms on recall); the only non-null signal is a single self-review false positive on the controversial-but-correct control vs 0 for team/council. No cross-model quality/lift claim binds; team mode stays workflow-value-only. Re-open: a judge-survivable-subtlety corpus or a new model generation. | quant | `internal/bench/reports/defect-finding.json#honest_null` | ✅ |
 | On the A3 orchestration eval (deterministic verify, measured token deltas), the production-validator subagent returned the correct verdict on both fixtures — NOT READY with the exact `file:line` citation on a planted hollow implementation, READY with zero spurious findings on the clean control — while consuming ~45k fewer tokens than the inline-host baseline on each task. Scope: two planted fixtures on a Claude Code host, not a broad hit-rate. | quant | `internal/bench/orchestration/pv-a3-results.md#token_delta_provenance: measured` | ✅ |
 
-**23 backed claim(s)** — all evidence pointers resolve in CI.
+**24 backed claim(s)** — all evidence pointers resolve in CI.
 
 Artefact counts in public prose (skills, commands, governed rules,
 guidelines, personas) are **generated from source and CI-drift-checked**:

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@event4u/agent-config",
-    "version": "9.4.0",
+    "version": "9.5.0",
     "description": "Universal AI Agent OS — audited skills, governance rules, commands, and templates for AI coding tools (Claude Code, Cursor, Windsurf, Copilot).",
     "license": "MIT",
     "private": false,

package/src/scripts/bench_defect_finding.ts

@@ -0,0 +1,348 @@
+#!/usr/bin/env tsx
+/**
+ * Defect-finding benchmark runner (road-to-team-mode Phase 5, Steps 2-4).
+ *
+ * Three arms over the pre-registered corpus (internal/bench/corpora/defect-finding.yaml):
+ *   (a) self-review  — single strong model (Anthropic) + the adversarial-review frame
+ *   (b) team         — codex exec (subscription; reviewer pinned via --codex-model)
+ *   (c) council      — the neutral breadth arm: Anthropic + OpenAI independent reviews, union
+ *
+ * Every arm gets the SAME strict output contract so scoring is fair + objective:
+ * a review must end with `VERDICT: <n>` and one `DEFECT: <file>:<line> — <why>`
+ * line per defect. Recall + false-positives are then scored DETERMINISTICALLY
+ * against the corpus ground truth (no LLM judge for the PRIMARY metric — the
+ * blind rubric judge is the SECONDARY metric and is deferred this pass).
+ *
+ * Spend: arm (a) + arm (c) are billable API calls; arm (b) is the ChatGPT
+ * subscription (non-billable through this process). `--max-usd` is a HARD cap:
+ * the run aborts before a call that would cross it. `--dry-run` makes zero calls.
+ *
+ * Exit 0 ok · 1 aborted-on-cap / error · 2 usage.
+ */
+import { execFileSync } from 'node:child_process';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+import { load as yamlLoad } from 'js-yaml';
+
+import {
+    AnthropicClient,
+    OpenAIClient,
+    load_anthropic_key,
+    load_openai_key,
+} from './ai_council/clients.js';
+
+const HERE = path.dirname(fileURLToPath(import.meta.url));
+const ROOT = path.resolve(HERE, '..', '..');
+const CORPUS = path.join(ROOT, 'internal', 'bench', 'corpora', 'defect-finding.yaml');
+const OUT_JSON = path.join(ROOT, 'internal', 'bench', 'reports', 'defect-finding.json');
+const OUT_MD = path.join(ROOT, 'internal', 'bench', 'reports', 'defect-finding.md');
+
+const OUTPUT_CONTRACT =
+    '\n\nReport STRICTLY in this format, nothing after it:\n' +
+    'DEFECT: <file>:<line> — <one-line why>   (one line per real defect; omit if none)\n' +
+    'VERDICT: <integer count of defects>';
+
+interface Fixture {
+    id: string;
+    defect_class: string;
+    prompt: string;
+    ground_truth: string;
+    rubric: string;
+    negative_control?: boolean;
+}
+
+type ArmId = 'self-review' | 'team' | 'council';
+
+interface ArmResult {
+    arm: ArmId;
+    text: string;
+    calls: number;
+    input_tokens: number;
+    output_tokens: number;
+    usd: number;
+    ms: number;
+    error: string | null;
+}
+
+/** Ground-truth FILENAME for a fixture, or null for a control. Each planted
+ * fixture touches exactly ONE unique file, so "a DEFECT line names this file"
+ * is the honest, line-number-robust recall signal (diff line numbering is
+ * ambiguous and models cite lines inconsistently — matching the exact
+ * file:line token systematically under-counts real finds). */
+function groundTruthFile(gt: string): string | null {
+    if (/^\s*NONE\b/i.test(gt)) return null;
+    const head = gt.split('—')[0] ?? gt;
+    const m = /([\w./-]+\.\w+):[\d,]+/.exec(head);
+    return m ? (m[1] as string) : null;
+}
+/** Basename of a path token (find.ts from src/search/find.ts). */
+function basename(p: string): string { return p.split('/').pop() ?? p; }
+
+/** Parse the DEFECT lines an arm emitted (file:line tokens it claims). */
+function parseClaimedDefects(text: string): { count: number; files: string[] } {
+    const files: string[] = [];
+    for (const line of text.split('\n')) {
+        // DEFECT: <file>[:line] — ... ; capture the file token (line optional).
+        const m = /^\s*DEFECT:\s*([\w./-]+\.\w+)/.exec(line);
+        if (m) files.push(m[1] as string);
+    }
+    const vm = /VERDICT:\s*(\d+)/i.exec(text);
+    const count = vm ? Number(vm[1]) : files.length;
+    return { count, files };
+}
+
+/** Deterministic recall/FP for one arm on one fixture. */
+function score(
+    fx: Fixture,
+    arm: ArmResult,
+): { recall_hit: boolean; false_positive: boolean; claimed: number } {
+    const gtFile = groundTruthFile(fx.ground_truth);
+    const claimed = parseClaimedDefects(arm.text);
+    if (gtFile === null || fx.negative_control === true) {
+        // Control: any claimed defect is a false positive.
+        return { recall_hit: false, false_positive: claimed.count > 0, claimed: claimed.count };
+    }
+    // Recall: a DEFECT line names the planted file (by basename — robust to the
+    // model prefixing or omitting the dir). Line-agnostic on purpose.
+    const target = basename(gtFile);
+    const hit = claimed.files.some((f) => basename(f) === target) || arm.text.includes(target);
+    return { recall_hit: hit, false_positive: false, claimed: claimed.count };
+}
+
+function usd(inTok: number, outTok: number, inRate: number, outRate: number): number {
+    return (inTok / 1_000_000) * inRate + (outTok / 1_000_000) * outRate;
+}
+
+// Conservative published-tier rates (per 1M tokens) for the estimate + tally.
+const RATES = {
+    anthropic: { in: 3, out: 15 }, // claude-sonnet class
+    openai: { in: 2.5, out: 10 }, // gpt-4o class
+};
+
+interface Budget {
+    cap: number;
+    spent: number;
+}
+
+function guard(b: Budget, next: number): void {
+    if (b.cap > 0 && b.spent + next > b.cap) {
+        throw new Error(`hard cap $${b.cap} would be crossed (spent $${b.spent.toFixed(4)}, next ~$${next.toFixed(4)})`);
+    }
+}
+
+function armSelfReview(fx: Fixture, key: string, b: Budget): ArmResult {
+    const t0 = Date.now();
+    guard(b, 0.05);
+    const client = new AnthropicClient({ api_key: key });
+    const sys =
+        'You are a single-model adversarial code reviewer (Attack-Defend-Revise). ' +
+        'Find real defects in the diff; do not invent problems in correct code.';
+    const r = client.ask(sys, fx.prompt + OUTPUT_CONTRACT, 1024);
+    const cost = usd(r.input_tokens, r.output_tokens, RATES.anthropic.in, RATES.anthropic.out);
+    b.spent += cost;
+    return {
+        arm: 'self-review', text: r.text, calls: 1,
+        input_tokens: r.input_tokens, output_tokens: r.output_tokens,
+        usd: cost, ms: Date.now() - t0, error: r.error,
+    };
+}
+
+function armTeam(fx: Fixture, model: string, _b: Budget): ArmResult {
+    const t0 = Date.now();
+    // codex = ChatGPT subscription: non-billable through this process. `--json`
+    // streams events; the review is the LAST agent_message item's text (the
+    // interactive mode without --json blocks/hangs — must use --json here).
+    let text = '';
+    let error: string | null = null;
+    try {
+        const raw = execFileSync('codex', ['exec', '--json', '-m', model, fx.prompt + OUTPUT_CONTRACT], {
+            encoding: 'utf8', maxBuffer: 16 * 1024 * 1024, timeout: 180_000,
+        });
+        for (const line of raw.split('\n')) {
+            const s = line.trim();
+            if (!s.startsWith('{')) continue;
+            try {
+                const ev = JSON.parse(s) as { item?: { type?: string; text?: string } };
+                if (ev.item?.type === 'agent_message' && typeof ev.item.text === 'string') {
+                    text = ev.item.text; // keep the last agent_message
+                }
+            } catch { /* skip non-JSON / partial lines */ }
+        }
+        if (!text) error = 'no agent_message in codex --json stream';
+    } catch (e) {
+        error = e instanceof Error ? e.message.slice(0, 300) : String(e);
+    }
+    return { arm: 'team', text, calls: 1, input_tokens: 0, output_tokens: 0, usd: 0, ms: Date.now() - t0, error };
+}
+
+function armCouncil(fx: Fixture, aKey: string, oKey: string, b: Budget): ArmResult {
+    const t0 = Date.now();
+    const sys =
+        'You are a neutral code reviewer. Review ONLY the supplied diff for real ' +
+        'defects; never invent problems in correct code.';
+    guard(b, 0.05);
+    const a = new AnthropicClient({ api_key: aKey }).ask(sys, fx.prompt + OUTPUT_CONTRACT, 1024);
+    let cost = usd(a.input_tokens, a.output_tokens, RATES.anthropic.in, RATES.anthropic.out);
+    b.spent += cost;
+    guard(b, 0.05);
+    const o = new OpenAIClient({ api_key: oKey }).ask(sys, fx.prompt + OUTPUT_CONTRACT, 1024);
+    const oc = usd(o.input_tokens, o.output_tokens, RATES.openai.in, RATES.openai.out);
+    b.spent += oc;
+    cost += oc;
+    // Council = breadth: union the two independent reviews.
+    const text = `# reviewer A\n${a.text}\n\n# reviewer B\n${o.text}`;
+    return {
+        arm: 'council', text, calls: 2,
+        input_tokens: a.input_tokens + o.input_tokens,
+        output_tokens: a.output_tokens + o.output_tokens,
+        usd: cost, ms: Date.now() - t0, error: a.error ?? o.error,
+    };
+}
+
+const CORRECTNESS = new Set(['logic-bug', 'off-by-one', 'race']);
+const DESIGN = new Set(['missing-empty-state', 'security-smell']);
+
+export function main(argv: string[]): 0 | 1 | 2 {
+    const dryRun = argv.includes('--dry-run');
+    const capIdx = argv.indexOf('--max-usd');
+    const cap = capIdx >= 0 ? Number(argv[capIdx + 1]) : 1.2;
+    const modelIdx = argv.indexOf('--codex-model');
+    const codexModel = (modelIdx >= 0 ? argv[modelIdx + 1] : undefined) ?? 'gpt-5.5';
+
+    const doc = yamlLoad(fs.readFileSync(CORPUS, 'utf8')) as { fixtures: Fixture[] };
+    const fixtures = doc.fixtures;
+
+    if (dryRun) {
+        const planted = fixtures.filter((f) => !f.negative_control).length;
+        process.stdout.write(
+            `defect-finding (dry-run — no calls):\n` +
+                `  fixtures: ${fixtures.length} (${planted} planted, ${fixtures.length - planted} control)\n` +
+                `  arms: self-review (anthropic, ${fixtures.length} calls) · team (codex ${codexModel}, ${fixtures.length} calls, subscription) · council (anthropic+openai, ${fixtures.length * 2} calls)\n` +
+                `  billable estimate: arm a ~$${(fixtures.length * 0.02).toFixed(2)} + arm c ~$${(fixtures.length * 0.04).toFixed(2)} ≈ $${(fixtures.length * 0.06).toFixed(2)} (hard cap $${cap})\n` +
+                `  arm b (codex): 0 billable (ChatGPT subscription quota)\n`,
+        );
+        return 0;
+    }
+
+    const aKey = load_anthropic_key();
+    const oKey = load_openai_key();
+    const budget: Budget = { cap, spent: 0 };
+    const rows: Array<{ fx: Fixture; arms: Record<ArmId, ArmResult> }> = [];
+
+    try {
+        for (const fx of fixtures) {
+            process.stdout.write(`· ${fx.id} (${fx.defect_class})\n`);
+            const arms = {
+                'self-review': armSelfReview(fx, aKey, budget),
+                team: armTeam(fx, codexModel, budget),
+                council: armCouncil(fx, aKey, oKey, budget),
+            } as Record<ArmId, ArmResult>;
+            rows.push({ fx, arms });
+        }
+    } catch (e) {
+        process.stderr.write(`ABORTED: ${e instanceof Error ? e.message : String(e)}\n`);
+        // fall through to write a partial report
+    }
+
+    // ── aggregate ──
+    const ARMS: ArmId[] = ['self-review', 'team', 'council'];
+    const agg: Record<string, unknown> = {};
+    const perArm: Record<ArmId, { recall: number; planted: number; fp: number; usd: number; ms: number; calls: number; byClass: Record<string, { hit: number; n: number }> }> =
+        Object.fromEntries(ARMS.map((a) => [a, { recall: 0, planted: 0, fp: 0, usd: 0, ms: 0, calls: 0, byClass: {} }])) as never;
+
+    const detail: unknown[] = [];
+    for (const { fx, arms } of rows) {
+        const d: Record<string, unknown> = { id: fx.id, defect_class: fx.defect_class, control: !!fx.negative_control };
+        for (const a of ARMS) {
+            const ar = arms[a];
+            const sc = score(fx, ar);
+            const pa = perArm[a];
+            pa.usd += ar.usd; pa.ms += ar.ms; pa.calls += ar.calls;
+            if (!fx.negative_control) {
+                pa.planted += 1;
+                if (sc.recall_hit) pa.recall += 1;
+                const c = (pa.byClass[fx.defect_class] ??= { hit: 0, n: 0 });
+                c.n += 1; if (sc.recall_hit) c.hit += 1;
+            } else if (sc.false_positive) {
+                pa.fp += 1;
+            }
+            d[a] = { recall_hit: sc.recall_hit, false_positive: sc.false_positive, claimed: sc.claimed, usd: Number(ar.usd.toFixed(4)), ms: ar.ms, error: ar.error, review: ar.text.slice(0, 1200) };
+        }
+        detail.push(d);
+    }
+
+    const recallRate = (a: ArmId): number => (perArm[a].planted ? perArm[a].recall / perArm[a].planted : 0);
+    const classRecall = (a: ArmId, classes: Set<string>): { hit: number; n: number } => {
+        let hit = 0, n = 0;
+        for (const [cls, c] of Object.entries(perArm[a].byClass)) if (classes.has(cls)) { hit += c.hit; n += c.n; }
+        return { hit, n };
+    };
+    const rr = (x: { hit: number; n: number }): number => (x.n ? x.hit / x.n : 0);
+
+    // Hypotheses (pre-registered thresholds).
+    const aCorr = classRecall('self-review', CORRECTNESS), bCorr = classRecall('team', CORRECTNESS);
+    const bDes = classRecall('team', DESIGN), cDes = classRecall('council', DESIGN);
+    const h1 = rr(bCorr) - rr(aCorr); // team - self on correctness; predict >= +0.20
+    const h2 = Math.abs(rr(cDes) - rr(bDes)); // council vs team on design; predict within 0.10
+    const h3ok = ARMS.every((a) => perArm[a].fp <= 1);
+
+    agg['preregistered'] = {
+        roadmap: 'road-to-team-mode Phase 5', authored: '2026-07-20',
+        primary: ['recall', 'false_positives', 'cost/time/calls'],
+        secondary: 'blind rubric judge — DEFERRED this pass (primary recall is deterministic)',
+        hypotheses: { H1: 'team>self on correctness, Δrecall>=+0.20', H2: 'council≈team on design, within 0.10', H3: 'FP<=1/arm on controls' },
+        codex_model: codexModel, models_cache_fetched: '2026-07-20T12:21Z',
+    };
+    agg['arms'] = Object.fromEntries(ARMS.map((a) => [a, {
+        recall_rate: Number(recallRate(a).toFixed(3)), recall: perArm[a].recall, planted: perArm[a].planted,
+        false_positives: perArm[a].fp, usd: Number(perArm[a].usd.toFixed(4)), ms: perArm[a].ms, calls: perArm[a].calls,
+        correctness_recall: Number(rr(classRecall(a, CORRECTNESS)).toFixed(3)),
+        design_recall: Number(rr(classRecall(a, DESIGN)).toFixed(3)),
+    }]));
+    const nullish = Math.abs(h1) <= 0.1 && h2 <= 0.1;
+    agg['verdict'] = {
+        H1_team_minus_self_correctness: Number(h1.toFixed(3)), H1_met: h1 >= 0.2,
+        H2_council_vs_team_design_absdelta: Number(h2.toFixed(3)), H2_met: h2 <= 0.1,
+        H3_fp_within_bound: h3ok,
+        honest_null: nullish,
+        disposition: nullish
+            ? 'HONEST NULL — arms indistinguishable within pre-registered thresholds; no lift claim binds.'
+            : h1 >= 0.2
+                ? 'LIFT on correctness-class — H1 met; a team-lift CLAIM may bind (maintainer decision).'
+                : 'MIXED — see per-class rates; no blanket lift claim.',
+    };
+    agg['total_billable_usd'] = Number((perArm['self-review'].usd + perArm.council.usd).toFixed(4));
+    agg['detail'] = detail;
+
+    fs.mkdirSync(path.dirname(OUT_JSON), { recursive: true });
+    fs.writeFileSync(OUT_JSON, JSON.stringify(agg, null, 2) + '\n');
+
+    const v = agg['verdict'] as Record<string, unknown>;
+    const md = [
+        '# Defect-finding benchmark — results (road-to-team-mode Phase 5)',
+        '', `> Run 2026-07-20. Codex reviewer: \`${codexModel}\`. Primary metric = deterministic`,
+        '> recall against corpus ground truth; blind rubric judge (secondary) deferred.',
+        '', '## Per-arm', '', '| arm | recall | correctness | design | false-pos | calls | $ |', '|---|--:|--:|--:|--:|--:|--:|',
+        ...ARMS.map((a) => {
+            const x = (agg['arms'] as Record<string, Record<string, number>>)[a] as Record<string, number>;
+            return `| ${a} | ${x.recall_rate} | ${x.correctness_recall} | ${x.design_recall} | ${x.false_positives} | ${x.calls} | ${x.usd} |`;
+        }),
+        '', '## Verdict', '',
+        `- H1 (team − self, correctness recall Δ): **${v.H1_team_minus_self_correctness}** — met: ${v.H1_met}`,
+        `- H2 (council vs team, design recall |Δ|): **${v.H2_council_vs_team_design_absdelta}** — met: ${v.H2_met}`,
+        `- H3 (false positives ≤ 1/arm): ${v.H3_fp_within_bound}`,
+        '', `**Disposition:** ${v.disposition}`,
+        '', `Total billable: $${agg['total_billable_usd']} (arm b codex = subscription, $0 billable).`,
+        '',
+    ].join('\n');
+    fs.writeFileSync(OUT_MD, md);
+    process.stdout.write(`\nwrote ${path.relative(ROOT, OUT_JSON)} + ${path.relative(ROOT, OUT_MD)}\n`);
+    process.stdout.write(`spent ~$${budget.spent.toFixed(4)} (cap $${cap})\n`);
+    return 0;
+}
+
+if (fs.existsSync(process.argv[1] ?? '') && import.meta.url === `file://${process.argv[1]}`) {
+    process.exit(main(process.argv.slice(2)));
+}