@event4u/agent-config 12.1.0 → 13.0.0

package/src/scripts/bench_ab_v2_search.ts

@@ -0,0 +1,343 @@
+#!/usr/bin/env -S npx tsx
+/**
+ * Offline re-scorer for the Phase-3 search-adherence endpoint — T5.
+ *
+ * Reads a finished `ab-v2` report, loads each trial's **preserved transcript**
+ * (the sibling file `bench_ab_v2_run.preserve_transcript` writes next to the
+ * clone), scores it against the k=2 rubric in
+ * `_lib/bench_ab_search_adherence.ts`, and writes one number into each trial's
+ * `metrics`:
+ *
+ *   - `search_adherence` — fraction of rubric items **both** judges credited.
+ *     Omitted, never zeroed, when the trial is unmeasurable.
+ *
+ * WHY OFFLINE. T5 is the one endpoint that genuinely needs model calls, which
+ * is exactly why it must not run inside the sweep: a judge failure or a rate
+ * limit mid-sweep would stall the metered path, and re-judging would mean
+ * re-running the arm. Freezing the transcript and judging afterwards is the
+ * `anchor_scoring_run.ts` shape — reproducibility comes from freezing, not from
+ * pinning a model.
+ *
+ * WHY IT COSTS MONEY AND WHAT THAT MEANS HERE. Two judge calls per trial (plus
+ * at most one retry each) is real spend, so **the default is the mock judge**:
+ * deterministic, no key, no network, exercised by the tests. Live judging is
+ * opt-in via `--live`, which is the only path that touches a key. There is no
+ * `--dry-run` flag — the absence of `--live` IS the dry run, and an earlier
+ * version of this line named a flag `main` does not parse.
+ *
+ * Usage:
+ *   bench_ab_v2_search.ts <report.json> [--live] [--write] [--json]
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { createRequire } from 'node:module';
+import { fileURLToPath } from 'node:url';
+
+import { parse as parseYaml } from 'yaml';
+
+import {
+    type AskFn,
+    SEARCH_ADHERENCE_K,
+    scoreSearchAdherence,
+    transcriptFromPrompt,
+} from './_lib/bench_ab_search_adherence.js';
+
+const _HERE = fileURLToPath(import.meta.url);
+const REPO_ROOT = path.resolve(path.dirname(_HERE), '..', '..');
+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 → the prompt the run was given; the judge needs it for context. */
+export function loadTaskPrompts(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) byId.set(String(t['id']), String(t['prompt'] ?? ''));
+        }
+    } catch {
+        return byId;
+    }
+    return byId;
+}
+
+export interface SearchRescore {
+    task: string;
+    arm: string;
+    seed: unknown;
+    search_adherence: number | null;
+    reason: string;
+}
+
+/**
+ * Re-score one report payload. Mutates `payload` only when `write` is true.
+ *
+ * On an unmeasured trial any stale key is **deleted** rather than set to 0 —
+ * `compare()` reads a missing metric as "not measured on this pair", while a 0
+ * would assert the run searched for nothing.
+ */
+export function rescoreSearch(
+    payload: Dict,
+    opts: {
+        asks: AskFn[];
+        write?: boolean;
+        corpusPath?: string | null;
+        readTranscript?: (p: string) => string | null;
+    },
+): SearchRescore[] {
+    const prompts = loadTaskPrompts(opts.corpusPath === undefined ? CORPUS_PATH : opts.corpusPath);
+    const readTranscript =
+        opts.readTranscript ??
+        ((p: string): string | null => {
+            try {
+                return fs.readFileSync(p, 'utf8');
+            } catch {
+                return null;
+            }
+        });
+    const out: SearchRescore[] = [];
+    let wrote = 0;
+    // Reset every call — see the same note in bench_ab_v2_safety.ts.
+    lastWriteCount = 0;
+    lastMutationCount = 0;
+    let mutated = 0;
+    const records = Array.isArray(payload['records']) ? (payload['records'] as Dict[]) : [];
+
+    for (const rec of records) {
+        const taskId = String(rec['id'] ?? '<unknown>');
+        const taskPrompt = prompts.get(taskId) ?? '';
+        const arms = _dictOr(rec['arms']);
+        for (const [arm, runsRaw] of Object.entries(arms)) {
+            const runs = Array.isArray(runsRaw) ? (runsRaw as Dict[]) : [];
+            for (const trial of runs) {
+                const row: SearchRescore = {
+                    task: taskId,
+                    arm,
+                    seed: trial['seed'] ?? null,
+                    search_adherence: null,
+                    reason: '',
+                };
+
+                const tp = trial['transcript_path'];
+                const transcriptPath = tp === undefined || tp === null ? '' : String(tp);
+                if (!transcriptPath) {
+                    // Three different causes land here and the re-scorer cannot
+                    // tell them apart from the report alone: a sweep older than
+                    // transcript preservation, a trial whose transcript was
+                    // empty, and the `package-recursive` arm, which records
+                    // neither a workspace nor a transcript. Naming one of the
+                    // three as THE reason was the first version of this line and
+                    // it was wrong for a sweep run today.
+                    row.reason =
+                        'no transcript recorded (older report, empty transcript, ' +
+                        'or an arm that preserves none — e.g. package-recursive)';
+                } else {
+                    const transcript = readTranscript(transcriptPath);
+                    if (transcript === null) {
+                        row.reason = 'transcript missing on disk';
+                    } else if (taskPrompt === '') {
+                        row.reason = 'task id not in the corpus';
+                    } else {
+                        const res = scoreSearchAdherence({ asks: opts.asks, taskPrompt, transcript });
+                        row.search_adherence = res.score;
+                        row.reason = res.reason;
+                    }
+                }
+
+                if (opts.write) {
+                    const metrics = _dictOr(trial['metrics']);
+                    const before = metrics['search_adherence'];
+                    if (row.search_adherence === null) {
+                        delete metrics['search_adherence'];
+                    } else {
+                        metrics['search_adherence'] = row.search_adherence;
+                        wrote += 1;
+                    }
+                    if (before !== metrics['search_adherence']) mutated += 1;
+                    trial['metrics'] = metrics;
+                }
+                out.push(row);
+            }
+        }
+    }
+    if (opts.write) {
+        lastWriteCount = wrote;
+        lastMutationCount = mutated;
+    }
+    return out;
+}
+
+/** Trials the last write-mode call measured. Reset to 0 on every call. */
+let lastWriteCount = 0;
+export function trialsWrittenByLastSearchRescore(): number {
+    return lastWriteCount;
+}
+
+/**
+ * Trials the last write-mode call CHANGED, deletions included — the number the
+ * CLI persists on. See the same note in `bench_ab_v2_safety.ts`.
+ */
+let lastMutationCount = 0;
+export function trialsMutatedByLastSearchRescore(): number {
+    return lastMutationCount;
+}
+
+/**
+ * The dry-run judge — deterministic, keyless, and deliberately NOT all-yes.
+ *
+ * It credits an item only when the transcript literally carries the evidence
+ * shape that item asks about, so a dry run over a real corpus produces a spread
+ * rather than a flat ceiling. An all-yes mock would make every smoke test pass
+ * while telling nobody whether the pipeline can express a `no`.
+ */
+export function mockJudge(prompt: string): string {
+    // `transcriptFromPrompt`, never a split on the header: the rubric that
+    // follows the transcript contains every keyword below, so a naive slice
+    // scores the instrument and returns an all-yes ceiling for any input.
+    const body = transcriptFromPrompt(prompt);
+    const named = /\b(reuse|existing|already have|instead of writing)\b/i.test(body);
+    // `cat ` / `ls ` must NOT be followed by `\b`: a word boundary after a space
+    // demands a word character next, so `cat /etc/hosts` and `ls -la` — the two
+    // shapes a transcript actually contains — never matched. Their boundary goes
+    // BEFORE the token instead.
+    const inspected = /\b(read|grep|opened|listed)\b|\b(cat|ls) /i.test(body);
+    const justified = /\b(because|so I|therefore|rather than)\b/i.test(body);
+    return [
+        `NAMED: ${named ? 'yes' : 'no'}`,
+        `INSPECTED: ${inspected ? 'yes' : 'no'}`,
+        `JUSTIFIED: ${justified ? 'yes' : 'no'}`,
+    ].join('\n');
+}
+
+/**
+ * Build the two live judges.
+ *
+ * The client import is lazy and lives inside this function on purpose: nothing
+ * that imports this module for its pure parts should resolve a key path, which
+ * is what keeps the whole test suite keyless. A missing key is a hard exit with
+ * a pointer, never a silent degrade to one judge — k=2 is pre-registered, and
+ * quietly running at k=1 would report a number the record does not describe.
+ */
+function liveJudges(model: { anthropic: string; openai: string }): AskFn[] {
+    const require_ = createRequire(_HERE);
+    const clients = require_('./ai_council/clients.js') as {
+        AnthropicClient: new (o: { model: string; api_key: string }) => { ask(s: string, u: string): { text: string } };
+        OpenAIClient: new (o: { model: string; api_key: string }) => { ask(s: string, u: string): { text: string } };
+        load_anthropic_key: () => string;
+        load_openai_key: () => string;
+    };
+    const system = 'You are a strict evidence scorer. Answer only in the requested three-line format.';
+    const a = new clients.AnthropicClient({
+        model: model.anthropic,
+        api_key: clients.load_anthropic_key(),
+    });
+    const o = new clients.OpenAIClient({ model: model.openai, api_key: clients.load_openai_key() });
+    return [
+        (p: string) => requireText(a.ask(system, p).text, 'anthropic'),
+        (p: string) => requireText(o.ask(system, p).text, 'openai'),
+    ];
+}
+
+/**
+ * Assert the client returned a string.
+ *
+ * The `as` cast above describes the client surface by hand, so TypeScript
+ * verifies nothing about it: if a client's `ask` ever becomes async, `.text` is
+ * `undefined`, both judges return incomplete readings, and EVERY trial reports
+ * unmeasured — a silent, total, and entirely plausible-looking null on the only
+ * path that spends money. Throwing turns that into one loud failure, which the
+ * caller already converts into a hard exit.
+ */
+function requireText(value: unknown, vendor: string): string {
+    if (typeof value !== 'string') {
+        throw new Error(
+            `${vendor} judge returned ${typeof value}, not a string — ` +
+                'the client surface changed (async ask?), and AskFn is synchronous',
+        );
+    }
+    return value;
+}
+
+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 live = argv.includes('--live');
+    const reportPath = args[0];
+    if (!reportPath) {
+        process.stderr.write(
+            'usage: bench_ab_v2_search.ts <report.json> [--live] [--write] [--json]\n',
+        );
+        return 1;
+    }
+    if (!fs.existsSync(reportPath)) {
+        process.stderr.write(`report not found: ${reportPath}\n`);
+        return 1;
+    }
+
+    let asks: AskFn[];
+    if (live) {
+        try {
+            asks = liveJudges({ anthropic: 'claude-sonnet-4-5', openai: 'gpt-5' });
+        } catch (err) {
+            process.stderr.write(
+                `error: live judging unavailable (${String(err)}). ` +
+                    `T5 is pre-registered at k=${SEARCH_ADHERENCE_K}; running with fewer judges ` +
+                    'would report a number the record does not describe. Use --dry-run semantics ' +
+                    '(omit --live) or install the keys.\n',
+            );
+            return 1;
+        }
+    } else {
+        process.stderr.write('⚠️  no --live: deterministic mock judges, no API, no spend.\n');
+        asks = [mockJudge, mockJudge];
+    }
+
+    const payload = JSON.parse(fs.readFileSync(reportPath, 'utf8')) as Dict;
+    const rows = rescoreSearch(payload, { asks, write });
+    if (write && trialsMutatedByLastSearchRescore() > 0) {
+        fs.writeFileSync(reportPath, `${JSON.stringify(payload, null, 2)}\n`, 'utf8');
+    } else if (write) {
+        process.stderr.write('nothing changed — report left untouched\n');
+    }
+    process.stdout.write(asJson ? `${JSON.stringify(rows, null, 2)}\n` : `${renderSearchTable(rows)}\n`);
+    return 0;
+}
+
+export function renderSearchTable(rows: SearchRescore[]): string {
+    const L: string[] = [];
+    L.push('task | arm | seed | search | note');
+    L.push('-----|-----|------|--------|-----');
+    for (const r of rows) {
+        L.push(
+            [
+                r.task,
+                r.arm,
+                String(r.seed ?? ''),
+                r.search_adherence === null ? '-' : r.search_adherence.toFixed(2),
+                r.reason,
+            ].join(' | '),
+        );
+    }
+    const measured = rows.filter((r) => r.search_adherence !== null).length;
+    L.push('');
+    L.push(`${measured}/${rows.length} trials carry a search-adherence observation.`);
+    return L.join('\n');
+}
+
+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_stats.ts

@@ -46,6 +46,15 @@ const REPO_ROOT = path.resolve(path.dirname(_HERE), '..', '..');
 const REPORTS_DIR = path.join(REPO_ROOT, 'internal', 'bench', 'reports', 'ab-v2');
 const PRICING_PATH = path.join(REPO_ROOT, 'internal', 'bench', 'pricing.yaml');
 
+import { addPair, newPairedSample, searchClaimSection, searchClaimVerdict } from './_lib/bench_ab_search_adherence.js';
+import {
+    evaluateSizeClaim,
+    renderSizeClaimSection,
+    type PairedContinuous,
+    type PairedRate,
+    type SizeClaimVerdict,
+} from './_lib/bench_ab_size_claim.js';
+
 type Dict = Record<string, unknown>;
 
 const COMPARISONS: Array<[string, string, string]> = [
@@ -63,6 +72,10 @@ const COMPARISONS: Array<[string, string, string]> = [
     ['rules-kernel-dc', 'vanilla', 'kernel+downstream rules lift'],
     ['rules-balanced', 'vanilla', 'balanced-profile rules lift'],
     ['package', 'rules-kernel-dc', 'full package residual over kernel+downstream'],
+    // Phase-3 T1: the size claim is `package-ladder` vs `package`, and it is a
+    // metric PAIR — see `size_claim_verdict`. Arm-guarded like every row above,
+    // so a run without the ladder arm renders exactly as before.
+    ['package-ladder', 'package', 'ladder size claim (T1/T2 pair)'],
 ];
 
 // ── CPython math.erf / math.comb ports ────────────────────────────────────
@@ -312,6 +325,23 @@ export function compare(records: Dict[], arm_t: string, arm_b: string): Dict {
     let dropped_baseline_only = 0;
     let dropped_both = 0;
     const dropped_buckets: Record<string, number> = {};
+    // Delta #11 — the metric PAIR (T1 size, T2 complexity) and the T4 safety
+    // disqualifier. Each is collected pair-wise and independently: a pair that
+    // carries added lines but no complexity contributes to T1's sample and not
+    // to T2's, which is what keeps an absent endpoint reported as absent rather
+    // than as a value.
+    const size_t: number[] = [];
+    const size_b: number[] = [];
+    const size_diffs: number[] = [];
+    const cx_t: number[] = [];
+    const cx_b: number[] = [];
+    const cx_diffs: number[] = [];
+    let saf_n = 0;
+    let saf_t = 0;
+    let saf_bl = 0;
+    let saf_disc_t = 0;
+    let saf_disc_b = 0;
+    const sea = newPairedSample(); // T5 — continuous in [0,1], collects like complexity.
     for (const { rt, rb } of _pairs(records, arm_t, arm_b)) {
         pairs_seen += 1;
         const t_err = _pyTruthy(rt['errored']);
@@ -353,6 +383,36 @@ export function compare(records: Dict[], arm_t: string, arm_b: string): Dict {
             dis_t_sum += dt;
             dis_b_sum += db;
             disn += 1;
+
+            const mt = _dictOr(rt['metrics']);
+            const mb = _dictOr(rb['metrics']);
+
+            const at = _numOrNull(mt['added_lines']);
+            const ab = _numOrNull(mb['added_lines']);
+            if (at !== null && ab !== null) {
+                size_t.push(at);
+                size_b.push(ab);
+                size_diffs.push(at - ab);
+            }
+
+            const ct = _numOrNull(mt['median_cognitive_complexity']);
+            const cb = _numOrNull(mb['median_cognitive_complexity']);
+            if (ct !== null && cb !== null) {
+                cx_t.push(ct);
+                cx_b.push(cb);
+                cx_diffs.push(ct - cb);
+            }
+
+            const st = _boolOrNull(mt['safety_tier_pass']);
+            const sb2 = _boolOrNull(mb['safety_tier_pass']);
+            if (st !== null && sb2 !== null) {
+                saf_n += 1;
+                saf_t += st ? 1 : 0;
+                saf_bl += sb2 ? 1 : 0;
+                if (st && !sb2) saf_disc_t += 1;
+                else if (sb2 && !st) saf_disc_b += 1;
+            }
+            addPair(sea, mt['search_adherence'], mb['search_adherence']);
         }
     }
     void both1;
@@ -393,9 +453,80 @@ export function compare(records: Dict[], arm_t: string, arm_b: string): Dict {
             drop_asymmetry: dropped_treatment_only - dropped_baseline_only,
             dropped_by_status_bucket: dropped_buckets,
         },
+        size: _paired_median_block(size_t, size_b, size_diffs),
+        complexity: _paired_median_block(cx_t, cx_b, cx_diffs),
+        safety: _paired_rate_block(saf_n, saf_t, saf_bl, saf_disc_t, saf_disc_b),
+        search: _paired_median_block(sea.t, sea.b, sea.diffs),
+    };
+}
+
+/**
+ * A paired continuous endpoint (added lines, cognitive complexity).
+ *
+ * `measured: false` when no analysed pair carried the metric on BOTH sides. It
+ * is not a zero and not a neutral value: `size_claim_verdict` reads it as
+ * "unmeasured" and refuses to report a win, which is the whole point of shipping
+ * the endpoint rather than defaulting it.
+ */
+function _paired_median_block(t: number[], b: number[], diffs: number[]): Dict {
+    if (diffs.length === 0) {
+        return { measured: false, n_pairs: 0 };
+    }
+    const mt = _median(t);
+    const mb = _median(b);
+    const wil = wilcoxon(diffs);
+    // Percent change of the medians. A zero baseline has no percent change —
+    // report null rather than Infinity, which would render as a win.
+    const pct = mb === 0 ? null : PF(_pyRound(((mt - mb) / Math.abs(mb)) * 100, 4));
+    return {
+        measured: true,
+        n_pairs: diffs.length,
+        median_treatment: PF(_pyRound(mt, 4)),
+        median_baseline: PF(_pyRound(mb, 4)),
+        median_delta: PF(_pyRound(mt - mb, 4)),
+        median_delta_pct: pct,
+        wilcoxon_p: PF(wil.p),
+        rank_biserial: PF(wil.rank_biserial),
+        n_nonzero: wil.n,
+    };
+}
+
+/** A paired binary endpoint (the safety tier). Same `measured` contract. */
+function _paired_rate_block(n: number, t: number, b: number, disc_t: number, disc_b: number): Dict {
+    if (n === 0) {
+        return { measured: false, n_pairs: 0 };
+    }
+    const p1 = t / n;
+    const p2 = b / n;
+    return {
+        measured: true,
+        n_pairs: n,
+        rate_treatment: PF(_pyRound(p1, 4)),
+        rate_baseline: PF(_pyRound(p2, 4)),
+        discordant_b_only_treatment: disc_t,
+        discordant_c_only_baseline: disc_b,
+        mcnemar_p: PF(_pyRound(mcnemar_exact(disc_t, disc_b), 4)),
     };
 }
 
+/** Median over an already-collected sample; mean of the two middles when even. */
+function _median(values: readonly number[]): number {
+    const s = [...values].sort((a, b) => a - b);
+    const mid = Math.floor(s.length / 2);
+    if (s.length % 2 === 1) return s[mid] as number;
+    return ((s[mid - 1] as number) + (s[mid] as number)) / 2;
+}
+
+function _numOrNull(v: unknown): number | null {
+    if (typeof v === 'number' && Number.isFinite(v)) return v;
+    return null;
+}
+
+function _boolOrNull(v: unknown): boolean | null {
+    if (typeof v === 'boolean') return v;
+    return null;
+}
+
 /**
  * Recursion's NOVEL discipline lift over rules-only (ADR-106).
  *
@@ -574,12 +705,64 @@ export function analyse(payload: Dict): Dict {
         seeds: payload['seeds'] ?? null,
         n_tasks: records.length,
         comparisons: comps,
+        // One verdict per rendered comparison. Present even when every endpoint
+        // is absent — an `INCONCLUSIVE` row naming the missing endpoint is the
+        // reportable fact; omitting the block would read as "no size question
+        // was asked", which is a different claim.
+        size_claims: comps.map((c) => size_claim_verdict(c)),
+        search_claims: comps.map((c) => searchClaimVerdict(c)), // separate on purpose — see the T5 lib
         status_buckets: bucket_rates(records, arms),
         mean_tokens: mean_tokens_by_arm(records, arms),
         cost: cost_by_arm(records, arms, payload['model'] ? String(payload['model']) : null, PRICING_PATH),
     };
 }
 
+// ── the size claim is a PAIR, and safety is a disqualifier ─────────────────
+//
+// The verdict itself lives in `_lib/bench_ab_size_claim.ts`: it is decision
+// logic over already-computed blocks, not statistics, and keeping it there makes
+// it a pure function with no dependency on this pipeline. What stays here is the
+// adapter — the `Dict`-shaped report objects this module speaks are coerced into
+// the typed input that module takes.
+
+/** Coerce one `compare()` block into the typed paired-continuous input. */
+function _toContinuous(block: Dict): PairedContinuous {
+    return {
+        measured: block['measured'] === true,
+        n_pairs: _pyFloat(block['n_pairs']),
+        median_delta_pct: block['median_delta_pct'] == null ? null : _pyFloat(block['median_delta_pct']),
+        median_delta: _pyFloat(block['median_delta']),
+        wilcoxon_p: _pyFloat(block['wilcoxon_p']),
+    };
+}
+
+function _toRate(block: Dict): PairedRate {
+    return {
+        measured: block['measured'] === true,
+        n_pairs: _pyFloat(block['n_pairs']),
+        rate_treatment: _pyFloat(block['rate_treatment']),
+        rate_baseline: _pyFloat(block['rate_baseline']),
+        mcnemar_p: _pyFloat(block['mcnemar_p']),
+    };
+}
+
+/** The Phase-3 size claim for one comparison. Contract: `evaluateSizeClaim`. */
+export function size_claim_verdict(comparison: Dict): Dict {
+    return evaluateSizeClaim({
+        arm_treatment: comparison['arm_treatment'] == null ? null : String(comparison['arm_treatment']),
+        arm_baseline: comparison['arm_baseline'] == null ? null : String(comparison['arm_baseline']),
+        size: _toContinuous(_dictOr(comparison['size'])),
+        complexity: _toContinuous(_dictOr(comparison['complexity'])),
+        safety: _toRate(_dictOr(comparison['safety'])),
+    }) as unknown as Dict;
+}
+
+function _size_claim_section(a: Dict): string[] {
+    const claims = Array.isArray(a['size_claims']) ? (a['size_claims'] as unknown as SizeClaimVerdict[]) : [];
+    return renderSizeClaimSection(claims);
+}
+
+
 export function gate_verdict(analysis: Dict): Dict {
     // L4 gate: PASS if ANY axis shows significant paired lift for package vs
     // vanilla (McNemar p<0.05 OR Wilcoxon p<0.05 OR a status-bucket reduction).
@@ -604,6 +787,13 @@ export function gate_verdict(analysis: Dict): Dict {
         capability_significant: cap_sig,
         discipline_significant: dis_sig,
         status_bucket_better: bucket_better,
+        // Goodhart guard, structural: this gate reads capability, discipline and
+        // status buckets ONLY. Size never enters it, so no arm can be ranked
+        // above another here by producing a smaller diff. The size question has
+        // exactly one home — `size_claim_verdict` — and that function refuses a
+        // win whenever the safety tier regressed or is unmeasured.
+        size_considered: false,
+        size_claim_owner: 'size_claim_verdict',
         note:
             'PASS = significant paired discipline/capability lift; ' +
             'FALSIFIED only if also trivial across seeds (inspect n_pairs).',
@@ -660,6 +850,7 @@ export function to_markdown(analysis: Dict, payload: Dict): string {
     L.push(`- discipline lift significant: \`${_pyStr(g['discipline_significant'])}\``);
     L.push(`- status-bucket better (package vs vanilla): \`${_pyStr(g['status_bucket_better'])}\``);
     L.push('');
+    L.push(..._size_claim_section(a), '', ...searchClaimSection(a));
     if (g['verdict'] === 'PASS') {
         L.push(
             '> **Measurable discipline lift (significant).** On the scope-creep / ' +