@event4u/agent-config 12.1.0 → 14.0.0

package/src/scripts/ai_council/quorum_wiring.ts

@@ -0,0 +1,211 @@
+/**
+ * The quorum seam between `quorum.ts` and the council CLI.
+ *
+ * `quorum.ts` is pure arithmetic: given n, present and a setting, it answers
+ * whether a pass concluded. Everything here is the plumbing around that answer
+ * — reading the setting out of a possibly hand-built config dict, re-deriving
+ * presence from a round of responses, emitting the attendance event, and
+ * rendering the operator-facing banner.
+ *
+ * **Extracted for the same reason its sibling `qualification_wiring.ts` was,
+ * and the reason is worth stating rather than implying.** Adding provider
+ * qualification to `council_cli.ts` pushed that file from 4,058 to 4,311
+ * lines, and `check_source_size_budget` scores `Σ max(0, lines(f) − 1500)` —
+ * so every added line in a file already 2,500 over the ceiling counts against
+ * the ratchet, while the new modules beside it count zero. Moving the
+ * qualification seam out recovered 164 of those lines; the residual 89 was
+ * call-site wiring that cannot leave `council_cli.ts`. This module is the
+ * operator's answer to that residual: pull the quorum plumbing — the same
+ * layer, and the code the qualification change already reaches into — into a
+ * file whose subject it actually is.
+ *
+ * That makes the extraction a real boundary rather than budget accounting. The
+ * discriminator: every function here is about a k-of-n verdict and its
+ * reporting, and none of them is about parsing argv, constructing clients, or
+ * writing an output payload — which is what `council_cli.ts` is for.
+ *
+ * `Dict` is redeclared locally rather than imported: it is `Record<string,
+ * unknown>` in the CLI too, and importing a type alias that shallow would
+ * couple this module to the file it was just separated from.
+ */
+
+import type { CouncilResponse, ExternalAIClient } from './clients.js';
+import type { QuorumSetting } from './config.js';
+import {
+    appendQuorumEvent,
+    type QuorumAbsence,
+    type QuorumCommand,
+    type QuorumDispatch,
+    type QuorumEventPhase,
+} from './events_log.js';
+import { evaluateQuorum, SOLO_FLOOR_MIN_PRESENT, type QuorumResult } from './quorum.js';
+import { absentReasonFromCliFailure, classifyCliFailure } from './transport_resolver.js';
+
+type Dict = Record<string, unknown>;
+
+/**
+ * `ai['quorum']` as forwarded by `_synthesize_ai_council_block` (already
+ * validated by `config.ts::_build_quorum` on that path) — or, for a caller
+ * that hands `build_members` a hand-built dict bypassing the loader
+ * entirely, a defensive re-check that fails soft to `'majority'` rather
+ * than throwing. `build_members` is not the config-validation layer;
+ * `evaluateQuorum` degrades an unrecognisable setting toward
+ * `inconclusive`, never toward a false `concluded`, so failing soft here
+ * costs nothing on the safety side.
+ */
+export function _quorum_setting_from(ai: Dict): QuorumSetting {
+    const raw = ai['quorum'];
+    if (raw === 'majority') {
+        return 'majority';
+    }
+    if (typeof raw === 'number' && Number.isInteger(raw) && raw >= 1) {
+        return raw;
+    }
+    return 'majority';
+}
+
+/**
+ * `ai['quorum_min_present']` with the same fail-soft posture as
+ * `_quorum_setting_from`: the loader has already validated it on the normal
+ * path, and a hand-built dict that bypasses the loader falls back to the
+ * ADR-224 default rather than throwing.
+ *
+ * Failing soft costs nothing on the safety side here, and less than it does
+ * for `quorum`: this value feeds a counterfactual boolean that no gate reads,
+ * so the worst outcome of a wrong fallback is one mis-recorded telemetry line,
+ * never a pass that concluded when it should not have.
+ */
+export function _quorum_min_present_from(ai: Dict): number {
+    const raw = ai['quorum_min_present'];
+    if (typeof raw === 'number' && Number.isInteger(raw) && raw >= 1) {
+        return raw;
+    }
+    return SOLO_FLOOR_MIN_PRESENT;
+}
+
+/**
+ * Emit one `quorum_result` line for a resolved quorum.
+ *
+ * Both `evaluateQuorum` call sites route through here, tagged by `phase`, so
+ * a solo-concluded pass is distinguishable from a full-attendance one in the
+ * event log — the gap `road-to-always-on-orchestration`'s Risk 6 asserted was
+ * already closed and was not.
+ *
+ * The emit sits at the call sites rather than inside `_postRunQuorum` on
+ * purpose: that function is exported and unit-tested as a pure derivation,
+ * and a write buried in it would make every test of it a log writer.
+ *
+ * `absent` entries arrive as the CLI's own `{member, reason, detail}` dicts;
+ * `detail` is dropped by `appendQuorumEvent`'s input type, which cannot carry
+ * free-form text at all.
+ */
+export function _emitQuorumEvent(
+    phase: QuorumEventPhase,
+    quorum: QuorumResult,
+    absent: readonly Dict[],
+    ctx: {
+        command: QuorumCommand;
+        dispatch?: QuorumDispatch;
+        /** Enabled members before `--single` filtering; defaults to the roster that ran. */
+        configuredTotal?: number;
+        lens?: string;
+        invocation?: string;
+        /**
+         * The ADR-224 shadow floor for this pass. `gateClass` is deliberately
+         * NOT in this context object: no CLI path declares itself gate-class,
+         * so a parameter here would be one no caller ever sets, and its
+         * absence is what the `false` on every line honestly records.
+         */
+        minPresent?: number;
+    },
+): void {
+    appendQuorumEvent({
+        lens: ctx.lens ?? '',
+        invocation: ctx.invocation ?? '',
+        phase,
+        command: ctx.command,
+        dispatch: ctx.dispatch ?? 'full',
+        configuredTotal: ctx.configuredTotal ?? quorum.total,
+        result: quorum,
+        ...(ctx.minPresent !== undefined ? { minPresent: ctx.minPresent } : {}),
+        absent: absent.map(
+            (a): QuorumAbsence => ({
+                member: String(a['member'] ?? ''),
+                reason: (a['reason'] as QuorumAbsence['reason']) ?? 'unavailable',
+            }),
+        ),
+    });
+}
+
+/**
+ * Re-derive quorum AFTER the provider calls, over what was actually USABLE —
+ * never what merely CONSTRUCTED (M3, independent-review finding). `members`
+ * and `responses` must be index-aligned (`consult()`'s own contract: one
+ * `CouncilResponse` per member, from the final round); `members.length` is
+ * the `n` — deliberately the roster that actually ran (post `--single` /
+ * `--siblings` filtering), never the full config roster a filtered run
+ * never attempted. A response carrying `.error` (or a missing response
+ * entry altogether) counts as absent, classified through the same
+ * `AbsentReason` vocabulary a static (pre-call) resolution failure uses, so
+ * one artefact buckets every absence — construction-time and mid-flight —
+ * under one taxonomy.
+ */
+export function _postRunQuorum(
+    members: ExternalAIClient[],
+    responses: CouncilResponse[],
+    ai_cfg: Dict,
+): { quorum: QuorumResult; absent: Dict[] } {
+    const absent: Dict[] = [];
+    let present = 0;
+    for (let i = 0; i < members.length; i++) {
+        const m = members[i] as ExternalAIClient;
+        const r = responses[i];
+        // Round 7 § 5.2 — attendance is a NON-EMPTY answer, not the absence of an
+        // error. `!r.error` alone counted a member that returned zero bytes, and
+        // that is not hypothetical: a 290 s curl timeout returned an empty body
+        // with no error set in two sessions (`9fc9ba3e`, `4ac2f7ac`) and the
+        // banner printed `2/2 present` — a single-voice verdict presented as
+        // convergence, on a paid run. An empty answer contributes nothing to a
+        // quorum by definition, whatever the transport thought of it.
+        if (r !== undefined && !r.error && r.text.trim() !== '') {
+            present += 1;
+            continue;
+        }
+        const raw = r?.error ?? (r !== undefined && r.text.trim() === '' ? 'empty response body' : 'no response');
+        const failure = classifyCliFailure(raw);
+        absent.push({
+            member: m.name,
+            reason: absentReasonFromCliFailure(failure) ?? 'unavailable',
+            detail: raw,
+        });
+    }
+    return { quorum: evaluateQuorum(members.length, present, _quorum_setting_from(ai_cfg)), absent };
+}
+
+/**
+ * One-line k-of-n banner, mirrored from `orchestrator.ts::_render_quorum_line`
+ * but for the CLI's own stdout stream rather than the rendered report —
+ * "attendance is telemetry, never a silent drop" applies to the estimate
+ * preview too, not only to a completed pass.
+ */
+export function _format_quorum_line(q: QuorumResult, phase?: QuorumEventPhase): string {
+    // The phase tag is not decoration. A degraded run prints attendance TWICE —
+    // the pre-run reading before the estimate table, the post-run reading after
+    // the consult — and the two disagree by construction: `2/2 present …
+    // concluded` then `0/2 present … INCONCLUSIVE`. Same prefix, opposite
+    // content, and until 2026-08-12 neither line said which was which, so an
+    // operator skimming (or anything grepping `council:quorum ·`) could take the
+    // stale one. The event log had solved this from the start with an explicit
+    // `phase` field; stdout had not. Optional, because the estimate path prints
+    // exactly one line and a tag there would claim a distinction it does not make.
+    const tag = phase === undefined ? '' : `${phase === 'pre_run' ? 'before the run' : 'after the run'} · `;
+    const verdict = q.status === 'concluded' ? 'concluded' : 'INCONCLUSIVE — release gate holds';
+    // Round 7 § 5.3 — a degraded pass says so. `1/2 present, needed 1 —
+    // concluded` is literally true and reads as agreement; with a threshold of 1
+    // a solo answer concludes, and nothing in the line distinguishes "both
+    // members agreed" from "one member answered". The counts were always there;
+    // what was missing is the word that stops a reader inferring convergence.
+    const degraded =
+        q.present < q.total ? `  ⚠️  DEGRADED — ${String(q.total - q.present)} member(s) did not answer; this is not convergence.` : '';
+    return `council:quorum · ${tag}${q.present}/${q.total} present, needed ${q.threshold} — ${verdict}.${degraded}`;
+}

package/src/scripts/ai_team/team_dispatch.ts

@@ -43,9 +43,11 @@ import * as path from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 
 import {
+    CLI_CONSUMER_TEAM,
     type CouncilResponse,
     load_cli_call_counts,
     OpenAICliClient,
+    QUOTA_SOURCE_PROVIDER,
 } from '../ai_council/clients.js';
 import {
     checkCodexAvailability,
@@ -361,7 +363,9 @@ export interface TeamReviewFinding {
 }
 
 export interface TeamReviewQuota {
-    /** Today's openai-bucket call count AFTER this run. */
+    /** The shared-bucket key this run books into — read from the client, not assumed. */
+    readonly provider: string;
+    /** Today's call count in that bucket AFTER this run. */
     readonly used: number;
     /** `ai_team.max_calls_per_day` — the team-side ceiling on the shared bucket. */
     readonly ceiling: number;
@@ -549,9 +553,23 @@ export interface RunTeamReviewOptions {
     halted?: boolean;
 }
 
-function _quota_snapshot(config: AiTeamConfig, cli_calls_path: string | null): TeamReviewQuota {
+/**
+ * Read the bucket this run actually books into.
+ *
+ * `provider` comes from the CLIENT (`client.name`), never from a literal. It was
+ * hardcoded to `'openai'`, which happened to be correct because
+ * `TeamReviewCliClient extends OpenAICliClient` — and would have gone silently
+ * wrong the moment the team transport moved, reporting a bucket nobody was
+ * booking while the real one filled up. A report that names its own subject
+ * cannot drift away from it.
+ */
+function _quota_snapshot(
+    config: AiTeamConfig,
+    cli_calls_path: string | null,
+    provider: string,
+): TeamReviewQuota {
     const counts = load_cli_call_counts(cli_calls_path);
-    return { used: counts['openai'] ?? 0, ceiling: config.max_calls_per_day };
+    return { provider, used: counts[provider] ?? 0, ceiling: config.max_calls_per_day };
 }
 
 function _envelope_from_response(
@@ -571,9 +589,19 @@ function _envelope_from_response(
                 'codex CLI auth failed (auth_expired) — run `codex login`, then retry. ' +
                 'No review was produced.';
         } else if (response.error === 'cli_quota_exhausted') {
+            // `cli_quota_exhausted` covers two events with opposite remedies, so
+            // the message must not assert one of them unconditionally. "Resets at
+            // UTC midnight" is true only of OUR counter; when the vendor refused
+            // us, their window governs and we do not know it.
             blocking_reason =
-                `daily cli-call quota exhausted for the shared openai bucket ` +
-                `(${quota.used}/${quota.ceiling}) — resets at UTC midnight. No review was produced.`;
+                response.metadata?.['quota_source'] === QUOTA_SOURCE_PROVIDER
+                    ? `the ${quota.provider} CLI refused the call as over its own quota ` +
+                      `(local bucket ${quota.used}/${quota.ceiling}) — the provider's window ` +
+                      'governs, not ours. No review was produced.'
+                    : `daily cli-call quota exhausted for the shared ${quota.provider} bucket ` +
+                      `(${quota.used}/${quota.ceiling}) — resets at UTC midnight, or clear it with ` +
+                      '`agent-config council:quota --reset <provider> --confirm`. ' +
+                      'No review was produced.';
         } else {
             blocking_reason = `codex CLI transport failed: ${response.error}. No review was produced.`;
         }
@@ -649,10 +677,16 @@ export function run_team_review(opts: RunTeamReviewOptions = {}): TeamReviewRunR
                   model: config.model,
                   max_calls_per_day: config.max_calls_per_day,
                   cli_calls_path,
+                  // The team half of the two enumerated consumers of the shared
+                  // counter. Declared here because the client cannot know its
+                  // caller — the bucket standing at 171 calls with zero recorded
+                  // council exchanges is precisely what an unattributed counter
+                  // cannot explain.
+                  consumer: CLI_CONSUMER_TEAM,
               });
 
     const response = client.ask(TEAM_REVIEW_SYSTEM_PROMPT, render_review_user_prompt(bundle));
-    const quota = _quota_snapshot(config, cli_calls_path);
+    const quota = _quota_snapshot(config, cli_calls_path, client.name);
     const envelope = _envelope_from_response(response, bundle, quota);
     out(JSON.stringify(envelope, null, 2));
     return { mode: 'call', header, bundle, envelope };

package/src/scripts/bench_ab_v2_complexity.ts

@@ -0,0 +1,252 @@
+#!/usr/bin/env -S npx tsx
+/**
+ * Offline re-scorer for the Phase-3 metric pair — S0.3 delta #11.
+ *
+ * Reads a finished `ab-v2` report, walks every trial's **preserved workspace**
+ * (delta #7 keyed `task|arm|seed`), and writes two endpoints into each trial's
+ * `metrics`:
+ *
+ *   - `added_lines` — T1's endpoint. Added only, not added+removed: the
+ *     discipline oracle's `max_lines_changed` wants the sum, the size claim
+ *     wants what the run *wrote*.
+ *   - `median_cognitive_complexity` — T2's endpoint, over the functions in the
+ *     files that trial actually changed.
+ *
+ * WHY OFFLINE RATHER THAN IN THE RUNNER. Three reasons, in order of weight.
+ * The metric is **retro-fittable**: the workspaces from every completed sweep
+ * are on disk, so a run that already cost money can gain the endpoint without
+ * being re-run — which is what makes the anti-golfing gate nearly free, and what
+ * the roadmap's own text promises. It is **deterministic and model-free**, so
+ * re-scoring the same workspace twice cannot produce two numbers. And the
+ * grammar load is **async** while `trajectory_metrics` is synchronous and called
+ * from four places — threading async through the live path would be a larger
+ * diff than the endpoint itself, for no measurement it does not already get.
+ *
+ * The report is rewritten in place only with `--write`; the default prints the
+ * table and touches nothing, because silently rewriting a pinned artefact is how
+ * a report stops matching the numbers already quoted from it.
+ *
+ * Usage:
+ *   bench_ab_v2_complexity.ts <report.json> [--write] [--json]
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+import { parse as parseYaml } from 'yaml';
+
+import { medianComplexityPerChangedFunction } from './_lib/bench_ab_complexity.js';
+import { changed_files, diff_line_counts } from './_lib/bench_ab_scoring_v2.js';
+
+const _HERE = fileURLToPath(import.meta.url);
+const REPO_ROOT = path.resolve(path.dirname(_HERE), '..', '..');
+const FIXTURES_ROOT = path.join(REPO_ROOT, 'internal', 'bench', 'ab');
+const CORPUS_PATH = path.join(REPO_ROOT, 'internal', 'bench', 'corpora', 'ab-trackb-v2.yaml');
+
+type Dict = Record<string, unknown>;
+
+function _dictOr(v: unknown): Dict {
+    return v && typeof v === 'object' && !Array.isArray(v) ? (v as Dict) : {};
+}
+
+/**
+ * task id → fixture path. The corpus is the ONLY resolver, deliberately.
+ *
+ * An earlier draft also had the runner stamp a `fixture` key onto each record so
+ * reports would be self-describing, and this function read it first. That is two
+ * mechanisms for one fact: the corpus lookup already covers every report,
+ * including every one written before the key would have existed. The extra field
+ * was dropped rather than kept as a fallback — a reader with no producer is the
+ * shape this branch's own completion review flagged elsewhere.
+ *
+ * A missing or unreadable corpus is not an error: it degrades every affected
+ * trial to `skipped_reason: 'task id not in the corpus'`, which is a reportable
+ * state, rather than aborting a re-score that may still cover most of the report.
+ */
+function loadCorpusFixtures(corpusPath: string | null): Map<string, string> {
+    const byId = new Map<string, string>();
+    if (!corpusPath || !fs.existsSync(corpusPath)) return byId;
+    try {
+        const corpus = _dictOr(parseYaml(fs.readFileSync(corpusPath, 'utf8'), { version: '1.1' }));
+        const tasks = Array.isArray(corpus['tasks']) ? (corpus['tasks'] as Dict[]) : [];
+        for (const t of tasks) {
+            if (t['id'] !== undefined && t['fixture'] !== undefined) {
+                byId.set(String(t['id']), String(t['fixture']));
+            }
+        }
+    } catch {
+        return byId;
+    }
+    return byId;
+}
+
+export interface TrialRescore {
+    task: string;
+    arm: string;
+    seed: unknown;
+    /** `null` when the workspace or the fixture is no longer on disk. */
+    added_lines: number | null;
+    median_cognitive_complexity: number | null;
+    n_functions: number;
+    unsupported_files: string[];
+    skipped_reason: string | null;
+}
+
+/**
+ * Re-score one report payload. Pure apart from the filesystem reads it needs;
+ * mutates `payload` only when `write` is true. The fixture each trial is diffed
+ * against is resolved from the corpus by task id — see `loadCorpusFixtures`.
+ */
+export async function rescoreReport(
+    payload: Dict,
+    opts: { fixturesRoot?: string; write?: boolean; corpusPath?: string | null } = {},
+): Promise<TrialRescore[]> {
+    const fixturesRoot = opts.fixturesRoot ?? FIXTURES_ROOT;
+    let wrote = 0;
+    const byId = loadCorpusFixtures(opts.corpusPath === undefined ? CORPUS_PATH : opts.corpusPath);
+    const out: TrialRescore[] = [];
+    const records = Array.isArray(payload['records']) ? (payload['records'] as Dict[]) : [];
+
+    for (const rec of records) {
+        const taskId = String(rec['id'] ?? '<unknown>');
+        const fixtureRel = byId.get(taskId) ?? null;
+        const arms = _dictOr(rec['arms']);
+        for (const [arm, runsRaw] of Object.entries(arms)) {
+            const runs = Array.isArray(runsRaw) ? (runsRaw as Dict[]) : [];
+            for (const run of runs) {
+                const row: TrialRescore = {
+                    task: taskId,
+                    arm,
+                    seed: run['seed'] ?? null,
+                    added_lines: null,
+                    median_cognitive_complexity: null,
+                    n_functions: 0,
+                    unsupported_files: [],
+                    skipped_reason: null,
+                };
+
+                const workspace = run['workspace'] !== undefined ? String(run['workspace']) : '';
+                if (!workspace || !fs.existsSync(workspace)) {
+                    // Not a zero — a trial whose workspace was pruned is
+                    // unmeasurable, and `compare()` reads a missing metric as
+                    // "not measured on this pair" rather than as a value.
+                    row.skipped_reason = workspace ? 'workspace missing on disk' : 'no workspace recorded';
+                    out.push(row);
+                    continue;
+                }
+                if (fixtureRel === null) {
+                    row.skipped_reason = 'task id not in the corpus';
+                    out.push(row);
+                    continue;
+                }
+                const fixture = path.join(fixturesRoot, fixtureRel);
+                if (!fs.existsSync(fixture)) {
+                    row.skipped_reason = 'fixture missing on disk';
+                    out.push(row);
+                    continue;
+                }
+
+                const changed = changed_files(fixture, workspace);
+                row.added_lines = diff_line_counts(fixture, workspace, changed).added;
+                const rollup = await medianComplexityPerChangedFunction(workspace, changed);
+                row.median_cognitive_complexity = rollup.median;
+                row.n_functions = rollup.n_functions;
+                row.unsupported_files = rollup.unsupported_files;
+
+                if (opts.write) {
+                    const metrics = _dictOr(run['metrics']);
+                    metrics['added_lines'] = row.added_lines;
+                    // `median` is null when the diff contained no scorable
+                    // function, and null is written on purpose: `compare()` reads
+                    // a null as "not measured on this pair", while a 0 would claim
+                    // the run produced maximally simple code. The count sits
+                    // beside it so a reader can tell "nothing to score" from
+                    // "scored, and it was trivial".
+                    metrics['median_cognitive_complexity'] = row.median_cognitive_complexity;
+                    metrics['complexity_n_functions'] = row.n_functions;
+                    run['metrics'] = metrics;
+                    wrote += 1;
+                }
+                out.push(row);
+            }
+        }
+    }
+    if (opts.write) lastWriteCount = wrote;
+    return out;
+}
+
+/**
+ * How many trials the last `rescoreReport({ write: true })` actually touched.
+ *
+ * The CLI uses it to skip rewriting the report when nothing was measured:
+ * re-serialising a pinned artefact for a zero-row pass changes its bytes (and
+ * its formatting) without changing a single number, which is exactly the kind of
+ * silent churn that makes a report stop matching the figures quoted from it.
+ */
+let lastWriteCount = 0;
+export function trialsWrittenByLastRescore(): number {
+    return lastWriteCount;
+}
+
+function renderTable(rows: TrialRescore[]): string {
+    const L: string[] = [];
+    L.push('task | arm | seed | added | median cc | fns | note');
+    L.push('-----|-----|------|-------|-----------|-----|-----');
+    for (const r of rows) {
+        L.push(
+            [
+                r.task,
+                r.arm,
+                String(r.seed ?? ''),
+                r.added_lines === null ? '-' : String(r.added_lines),
+                r.median_cognitive_complexity === null ? '-' : String(r.median_cognitive_complexity),
+                String(r.n_functions),
+                r.skipped_reason ??
+                    (r.unsupported_files.length > 0
+                        ? `unsupported: ${r.unsupported_files.join(',')}`
+                        : ''),
+            ].join(' | '),
+        );
+    }
+    const measured = rows.filter((r) => r.median_cognitive_complexity !== null).length;
+    L.push('');
+    L.push(`${measured}/${rows.length} trials carry a complexity observation.`);
+    return L.join('\n');
+}
+
+async function main(argv: string[]): Promise<number> {
+    const args = argv.filter((a) => !a.startsWith('--'));
+    const write = argv.includes('--write');
+    const asJson = argv.includes('--json');
+    const reportPath = args[0];
+    if (!reportPath) {
+        process.stderr.write(
+            'usage: bench_ab_v2_complexity.ts <report.json> [--write] [--json]\n',
+        );
+        return 1;
+    }
+    if (!fs.existsSync(reportPath)) {
+        process.stderr.write(`report not found: ${reportPath}\n`);
+        return 1;
+    }
+    const payload = JSON.parse(fs.readFileSync(reportPath, 'utf8')) as Dict;
+    const rows = await rescoreReport(payload, { write });
+    const written = trialsWrittenByLastRescore();
+    if (write && written > 0) {
+        fs.writeFileSync(reportPath, `${JSON.stringify(payload, null, 2)}\n`, 'utf8');
+    } else if (write) {
+        process.stderr.write('no trial could be measured — report left untouched\n');
+    }
+    process.stdout.write(asJson ? `${JSON.stringify(rows, null, 2)}\n` : `${renderTable(rows)}\n`);
+    return 0;
+}
+
+if (process.argv[1] && path.resolve(process.argv[1]) === path.resolve(_HERE)) {
+    main(process.argv.slice(2)).then(
+        (code) => process.exit(code),
+        (err: unknown) => {
+            process.stderr.write(`${String(err)}\n`);
+            process.exit(1);
+        },
+    );
+}

package/src/scripts/bench_ab_v2_run.ts

@@ -45,7 +45,6 @@
 import { spawnSync } from 'node:child_process';
 import { createHash } from 'node:crypto';
 import * as fs from 'node:fs';
-import * as os from 'node:os';
 import * as path from 'node:path';
 import process from 'node:process';
 import { fileURLToPath, pathToFileURL } from 'node:url';
@@ -53,6 +52,7 @@ import { parse as parseYaml } from 'yaml';
 
 import * as v1 from './bench_ab_task_runner.js';
 import * as scoring from './_lib/bench_ab_scoring_v2.js';
+import { preserve_transcript, reset_fixture } from './_lib/bench_ab_workspace.js';
 import {
     SweepBudget,
     activation_verdict,
@@ -75,7 +75,6 @@ const REPO_ROOT = path.resolve(path.dirname(_HERE), '..', '..');
 const ROUTER_PATH = path.join(REPO_ROOT, 'dist', 'router.json');
 const RULES_DIR = path.join(REPO_ROOT, 'dist', 'agent-src', 'rules');
 const CORPUS_PATH = path.join(REPO_ROOT, 'internal', 'bench', 'corpora', 'ab-trackb-v2.yaml');
-const FIXTURES_ROOT = path.join(REPO_ROOT, 'internal', 'bench', 'ab');
 const REPORTS_DIR = path.join(REPO_ROOT, 'internal', 'bench', 'reports', 'ab-v2');
 const CHECKPOINTS_DIR = path.join(REPORTS_DIR, 'checkpoints');
 const PRICING_PATH = path.join(REPO_ROOT, 'internal', 'bench', 'pricing.yaml');
@@ -87,7 +86,6 @@ const PRICING_PATH = path.join(REPO_ROOT, 'internal', 'bench', 'pricing.yaml');
 // vanilla ≈ package and invalidated every prior null. A /tmp clone has no
 // agent-config ancestor → vanilla is truly plain; `package` still activates via
 // the USER-scope global plugin regardless of cwd.
-const WORK_ROOT = path.join(os.tmpdir(), 'agent-config-bench-v2-clones');
 
 type Dict = Record<string, unknown>;
 
@@ -329,45 +327,6 @@ export function injected_text(inject: string | null, placebo_chars: number): str
     return null;
 }
 
-/**
- * Workspace directory for one trial — delta #7 of the S0.3 spike.
- *
- * Keyed by `task|arm|seed`, not by task alone. The old task-only key meant every
- * arm and every seed of a task reused ONE directory that the next trial deleted,
- * so at the end of a sweep exactly one workspace survived per task — the last one
- * written, with no record of which arm or seed it belonged to.
- *
- * That is not a tidiness problem. Phase 3's anti-golfing gate is specified as
- * retro-fittable onto already-completed runs by offline re-scoring, and the
- * roadmap calls that gate cheap *because* the workspaces are preserved. Under the
- * old key there was nothing to re-score, so the claim was false. A distinct
- * directory per trial is what makes it true.
- *
- * `arm` is sanitised because arm names are used verbatim as a path segment and
- * one of them would otherwise be free to escape the root.
- */
-export function workspace_dir(task_id: string, arm: string, seed: number): string {
-    const safe_arm = arm.replace(/[^A-Za-z0-9._-]/g, '_');
-    return path.join(WORK_ROOT, `${task_id}__${safe_arm}__seed${seed}`);
-}
-
-/**
- * Copy the task's pristine fixture into this trial's own working clone.
- *
- * The clone is re-created from the fixture on every call, so a resumed or
- * repeated trial still starts pristine — the per-trial key changes *which*
- * directory that is, never whether it is clean.
- */
-export function reset_fixture(task: Dict, arm: string, seed: number): [string, string] {
-    const fixture = path.join(FIXTURES_ROOT, String(task['fixture']));
-    const dest = workspace_dir(String(task['id']), arm, seed);
-    if (fs.existsSync(dest)) {
-        fs.rmSync(dest, { recursive: true, force: true });
-    }
-    fs.mkdirSync(path.dirname(dest), { recursive: true });
-    fs.cpSync(fixture, dest, { recursive: true });
-    return [dest, fixture];
-}
 
 /** Map a run outcome to an AgentBench-style trajectory bucket. */
 export function status_bucket(run: Dict): string {
@@ -689,6 +648,7 @@ export function run_one(task: Dict, arm: string, opts: RunOneOpts): Dict {
         // rather than recomputed later, so an offline re-scorer reads the path the
         // sweep actually used instead of re-deriving a key that may have changed.
         workspace: clone,
+        transcript_path: preserve_transcript(clone, String(run['transcript'] ?? '')),
         ...integrity_fields(run, spec, sp_text ? sp_text.length : 0, opts.model),
     };
 }
@@ -803,6 +763,7 @@ export function selftest_run(
         metrics: trajectory_metrics(run, score),
         injected_chars: sp_text ? sp_text.length : 0,
         workspace: clone,
+        // No transcript_path — a synthetic transcript would give T5 a score of the harness.
         ...integrity_fields(run, spec, sp_text ? sp_text.length : 0, opts.model),
     };
 }