@event4u/agent-config 16.5.0 → 17.0.0

package/src/scripts/probe_turnaround.ts

@@ -21,6 +21,11 @@
  *   - the >60 s blocking tail and its share of tool time  (F2)
  *   - that tail split by cause, `unknown` always printed (road-to-blocking-time-by-cause)
  *   - the first-call context floor         (F3 cross-check)
+ *   - turn ends by ask shape, usage-limit pauses split night/day, and turn-end
+ *     refusals by detector — every class table with an `unknown` row and a sum
+ *     check
+ *   - with `--git FROM..TO`, merged changes, true merges, net ticked steps and
+ *     archived roadmaps per night window
  *
  * A MEASUREMENT, NOT A GATE — by default. `--against-baseline` compares against
  * `src/config/turnaround-budget.json` and is the only mode that can exit
@@ -33,17 +38,47 @@
  *   ./scripts-run src/scripts/probe_turnaround [--store PATH] [--limit N]
  *   ./scripts-run src/scripts/probe_turnaround --json
  *   ./scripts-run src/scripts/probe_turnaround --against-baseline
+ *   ./scripts-run src/scripts/probe_turnaround --steps [--json]   (per closed roadmap step: model ·
+ *       change · verify · ceremony · wait · refusal · unknown, and minutes per change class)
+ *   ./scripts-run src/scripts/probe_turnaround --workspace PATH --git 2026-09-28..2026-10-13 [--ref main]
+ *   ./scripts-run src/scripts/probe_turnaround --store PATH --against-baseline --queue-root CHECKOUT
+ *
+ * `--queue-root` gives an exit 1 of the gating mode a reader: it upserts one
+ * record into CHECKOUT's self-repair store, which the prompt-time hook injects
+ * as the queue line. The same verdict again, any day → the same record, folded.
  *
  * The MEASURING session is excluded by default — see `recentSessions`.
  *
- * Exit codes: 0 = reported (or within baseline) · 1 = baseline regression, or an
- * empty corpus under `--against-baseline` · 2 = usage error.
+ * Exit codes: 0 = reported (or within baseline) · 1 = baseline regression, an
+ * empty corpus under `--against-baseline`, or a class table whose rows do not
+ * sum to its total · 2 = usage error.
  */
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 import { fileURLToPath } from 'node:url';
 
+import { collectRefusalStats, DETECTOR_IDS, type RefusalStats } from './_lib/turn_end_refusals.js';
+import {
+    checkSum,
+    classifyTurnEnd,
+    median,
+    readCiMinutes,
+    readEstateAtRef,
+    standingRules,
+    isUsageLimitPause,
+    isUsageLimitReset,
+    nightKey,
+    readCommitFacts,
+    type EstateFigures,
+    type NightTally,
+    type Tally,
+    tallyExclusive,
+    tallyNights,
+    TURN_END_CLASSES,
+} from './_lib/turnaround_throughput.js';
 import { defaultStore, isInjectedBody, userText } from './conformance_scan.js';
+import { upsertFinding } from './_lib/self_repair_store.js';
+import { readSteps, STEP_CLASSES, storeTranscripts, summariseSteps } from './_lib/step_anatomy.js';
 
 const _FILE = fileURLToPath(import.meta.url);
 const REPO_ROOT = path.resolve(path.dirname(_FILE), '..', '..');
@@ -94,17 +129,45 @@ const TOOL_CAUSE: Readonly<Record<string, BlockingCause>> = {
  */
 const SHELL_RULES: ReadonlyArray<readonly [RegExp, BlockingCause]> = [
     [/^(\S*\/)?scripts-run \S*ci_settle\b/, 'ci-wait'],
+    [/^(npm exec (--\S+ )*-- |npx (--\S+ )*)?(\S*\/)?agent-config ci:settle\b/, 'ci-wait'],
     [/^gh (run watch|pr checks)\b/, 'ci-wait'],
     [/^(sleep|until|while|watch)\b/, 'sleep-poll'],
     [/^((npx |\S*node_modules\/\.bin\/)?(vitest|jest|pytest|phpunit)\b|npm (run )?test\b|task (ci|test)\b)/, 'test'],
     [/^(task (sync|generate-tools|build)\b|npm (ci|install|run build)\b|(npx )?tsc\b|make\b|esbuild\b)/, 'build'],
     [/^(git (push|fetch|pull|clone)\b|curl\b|wget\b|gh (pr (merge|create)|api)\b)/, 'network'],
     [/^(\S*\/)?scripts-run \S*council_cli run\b/, 'network'],
+    // A provider CLI invoked directly rather than through `council_cli`: the
+    // wait is the same remote round-trip. Added by 3.4 — one council seat in the
+    // second window was reached this way and read as `unknown`.
+    [/^(codex exec\b|claude (-p|--print)\b)/, 'network'],
 ];
 
 /** A segment that only changes directory or sets a variable waited on nothing. */
 const NOISE_SEGMENT = /^(cd\b|export\b|set\b|[A-Za-z_][A-Za-z0-9_]*=\S*$)/;
 
+/**
+ * Assignments that PREFIX a command in the same segment —
+ * `AGENT_CONFIG_BROWSER_SUITES=1 npx vitest run`. `NOISE_SEGMENT` anchors at the
+ * end and so only sees an assignment that is the whole segment; this strips the
+ * prefix form so the command behind it can match. Added by 3.4: in the second
+ * window this one shape held ~80 of 179 unknown blocking minutes, all of them
+ * test runs.
+ */
+const ENV_PREFIX = /^(?:[A-Za-z_][A-Za-z0-9_]*=\S*\s+)+/;
+
+/**
+ * Git's GLOBAL options sit between `git` and the subcommand, so `git -C <path>
+ * push` does not match a rule anchored on `git push`. Strips them so the
+ * subcommand decides. Added by 3.4 — this package's own token-efficiency rule
+ * tells agents to write `git -C <path> …`, so the shape is common here.
+ */
+const GIT_GLOBAL_OPTS = /^git\s+(?:(?:-[Cc]|--git-dir|--work-tree|--namespace|--exec-path)(?:[= ]\S+)\s+|--(?:no-pager|bare|literal-pathspecs|paginate)\s+)+/;
+
+/** Strip what sits in FRONT of the command a segment actually ran. */
+function commandHead(seg: string): string {
+    return seg.replace(ENV_PREFIX, '').replace(GIT_GLOBAL_OPTS, 'git ');
+}
+
 /** A loop keyword in front of a body: `for …; do sleep 60` reads as the sleep. */
 const LOOP_KEYWORD = /^(do|then|else)\s+/;
 
@@ -166,11 +229,18 @@ export function classifyBlockingCall(tool: string, input: unknown): BlockingCaus
     for (const raw of shellSegments(input['command'])) {
         const seg = raw.trim().replace(LOOP_KEYWORD, '');
         if (seg === '' || NOISE_SEGMENT.test(seg)) continue;
-        for (const [re, cause] of SHELL_RULES) if (re.test(seg)) return cause;
+        const head = commandHead(seg);
+        for (const [re, cause] of SHELL_RULES) if (re.test(head)) return cause;
     }
     return 'unknown';
 }
 
+/** A shell call that pushes: any segment whose command is `git push`. */
+export function isGitPushCall(tool: string, input: unknown): boolean {
+    if (tool !== 'Bash' || !isObj(input) || typeof input['command'] !== 'string') return false;
+    return shellSegments(input['command']).some((raw) => /^git push\b/.test(commandHead(raw.trim().replace(LOOP_KEYWORD, ''))));
+}
+
 /**
  * The in-memory record of one blocking call. `summary` is bounded and never
  * printed or serialised by `main`: command text names local paths and hosts,
@@ -280,8 +350,28 @@ export function measure(files: readonly string[]): Turnaround {
     return measureDetailed(files).turnaround;
 }
 
+/** Aggregate only: counts and minutes, never text. */
+export interface Throughput {
+    /** The last assistant text before each real user request, and at end of file. */
+    turnEnds: Tally;
+    pauses: { total: number; night: number; day: number; unknown: number; pausedMinutes: number; unresolved: number };
+    /** `git push` calls and their median wall-clock, pre-push hook included. */
+    push: { calls: number; medianSeconds: number | null };
+    /**
+     * Step 2.1's unit: `nightKey` nights holding an assistant turn, and those of
+     * them that also hold a usage-limit banner. Sorted `YYYY-MM-DD`, no text.
+     */
+    nights: { active: string[]; paused: string[] };
+}
+
+const TURN_END_NAMED = TURN_END_CLASSES.filter((c) => c !== 'unknown');
+
 /** `measure`, plus the per-call blocking records the cause table is built from. */
-export function measureDetailed(files: readonly string[]): { turnaround: Turnaround; blocking: BlockingCall[] } {
+export function measureDetailed(files: readonly string[]): {
+    turnaround: Turnaround;
+    blocking: BlockingCall[];
+    throughput: Throughput;
+} {
     const requestIds = new Set<string>();
     /** requestId → tool_use blocks in it. */
     const batch = new Map<string, number>();
@@ -294,10 +384,18 @@ export function measureDetailed(files: readonly string[]): { turnaround: Turnaro
     const contextFloors: number[] = [];
     let userRequests = 0;
     let sessions = 0;
+    const turnEndTexts: string[] = [];
+    const pauses: Throughput['pauses'] = { total: 0, night: 0, day: 0, unknown: 0, pausedMinutes: 0, unresolved: 0 };
+    const pushSeconds: number[] = [];
+    const activeNights = new Set<string>();
+    const pauseNights = new Set<string>();
 
     for (const file of files) {
         let sawFloor = false;
         let sawAny = false;
+        let lastText: string | null = null;
+        let pauseOpen = false;
+        let pausedAt: number | null = null;
         for (const line of fs.readFileSync(file, 'utf8').split('\n')) {
             if (!line.trim()) continue;
             let e: Entry;
@@ -310,13 +408,38 @@ export function measureDetailed(files: readonly string[]): { turnaround: Turnaro
             sawAny = true;
             const msg = e['message'];
 
+            if (isUsageLimitPause(e)) {
+                const t = ms(e['timestamp']);
+                pauses.total += 1;
+                if (t === null) pauses.unknown += 1;
+                else if (nightKey(t) !== null) {
+                    pauses.night += 1;
+                    pauseNights.add(nightKey(t) as string);
+                } else pauses.day += 1;
+                if (pauseOpen) pauses.unresolved += 1;
+                pauseOpen = true;
+                pausedAt = t;
+                continue;
+            }
+            if (isUsageLimitReset(e)) {
+                const t = ms(e['timestamp']);
+                if (pausedAt !== null && t !== null) pauses.pausedMinutes += (t - pausedAt) / 60_000;
+                pauseOpen = false;
+                pausedAt = null;
+                continue;
+            }
+
             if (e['type'] === 'user') {
                 // The SAME predicate the conformance scan uses, imported rather
                 // than re-typed: a skill body and a slash-command header arrive
                 // in the user role and are not requests. Counting them would
                 // deflate calls-per-request by inventing a denominator.
                 const text = userText(e);
-                if (text !== null && !isInjectedBody(text)) userRequests += 1;
+                if (text !== null && !isInjectedBody(text)) {
+                    userRequests += 1;
+                    if (lastText !== null) turnEndTexts.push(lastText);
+                    lastText = null;
+                }
                 if (isObj(msg) && Array.isArray(msg['content'])) {
                     const at = ms(e['timestamp']);
                     for (const b of msg['content']) {
@@ -329,6 +452,7 @@ export function measureDetailed(files: readonly string[]): { turnaround: Turnaro
                         emittedAt.delete(id);
                         const call = calledWith.get(id);
                         calledWith.delete(id);
+                        if (call !== undefined && isGitPushCall(call.tool, call.input)) pushSeconds.push(seconds);
                         if (seconds > BLOCKING_SECONDS) {
                             const tool = call?.tool ?? '';
                             blockingCalls.push({
@@ -344,6 +468,9 @@ export function measureDetailed(files: readonly string[]): { turnaround: Turnaro
             }
 
             if (e['type'] !== 'assistant') continue;
+            const turnAt = ms(e['timestamp']);
+            const turnNight = turnAt === null ? null : nightKey(turnAt);
+            if (turnNight !== null) activeNights.add(turnNight);
             const rid = e['requestId'];
             if (typeof rid === 'string' && rid !== '') requestIds.add(rid);
 
@@ -363,6 +490,9 @@ export function measureDetailed(files: readonly string[]): { turnaround: Turnaro
             const at = ms(e['timestamp']);
             let n = 0;
             for (const b of msg['content']) {
+                if (isObj(b) && b['type'] === 'text' && typeof b['text'] === 'string' && b['text'].trim() !== '') {
+                    lastText = b['text'];
+                }
                 if (!isObj(b) || b['type'] !== 'tool_use') continue;
                 n += 1;
                 const id = String(b['id'] ?? '');
@@ -376,6 +506,8 @@ export function measureDetailed(files: readonly string[]): { turnaround: Turnaro
             }
         }
         if (sawAny) sessions += 1;
+        if (lastText !== null) turnEndTexts.push(lastText);
+        if (pauseOpen) pauses.unresolved += 1;
     }
 
     const toolCalls = [...batch.values()].reduce((a, b) => a + b, 0);
@@ -406,7 +538,17 @@ export function measureDetailed(files: readonly string[]): { turnaround: Turnaro
         contextFloorMax: contextFloors.length === 0 ? 0 : Math.max(...contextFloors),
         blockingByCause: byCause,
     };
-    return { turnaround, blocking: blockingCalls };
+    pauses.pausedMinutes = Math.round(pauses.pausedMinutes);
+    const throughput: Throughput = {
+        turnEnds: tallyExclusive(turnEndTexts, TURN_END_NAMED, (t) => [classifyTurnEnd(t)]),
+        pauses,
+        push: { calls: pushSeconds.length, medianSeconds: median(pushSeconds) },
+        nights: {
+            active: [...activeNights].sort(),
+            paused: [...pauseNights].filter((n) => activeNights.has(n)).sort(),
+        },
+    };
+    return { turnaround, blocking: blockingCalls, throughput };
 }
 
 export interface Budget {
@@ -464,6 +606,68 @@ export function compare(t: Turnaround, b: Budget): string[] {
     return out;
 }
 
+type GitReading = NightTally & { range: string; ref: string };
+
+interface Standing {
+    estate: EstateFigures;
+    rules: { files: number; withoutPaths: number };
+    ci: Array<{ range: string; workflow: string; runs: number; medianMinutes: number | null; truncated: boolean }>;
+}
+
+const WINDOW = /^(\d{4}-\d{2}-\d{2})\.\.(\d{4}-\d{2}-\d{2})$/;
+
+/** `FROM..TO[,FROM..TO…]` as date pairs, or `null` when any window is malformed. */
+export function parseWindows(value: string): Array<[string, string]> | null {
+    const out: Array<[string, string]> = [];
+    for (const w of value.split(',')) {
+        const m = WINDOW.exec(w.trim());
+        if (m === null) return null;
+        out.push([m[1] as string, m[2] as string]);
+    }
+    return out;
+}
+
+/** Night keys inside an inclusive `FROM..TO` range. */
+function inRange(nights: readonly string[], range: string): number {
+    const [from, to] = range.split('..') as [string, string];
+    return nights.filter((n) => n >= from && n <= to).length;
+}
+
+function renderThroughput(tp: Throughput, refusals: RefusalStats, git: readonly GitReading[], st: Standing): string {
+    const p50 = (x: number | null, unit: string): string => (x === null ? 'n/a' : `${String(Math.round(x * 10) / 10)} ${unit}`);
+    const per = (n: number, d: number): string => (d === 0 ? '0' : String(Math.round((n / d) * 10) / 10));
+    const lines = [
+        `  turn ends                    ${String(tp.turnEnds.total)}`,
+        ...Object.entries(tp.turnEnds.rows).map(([c, n]) => `    ${c.padEnd(16)}${String(n)}`),
+        `  usage-limit pauses           ${String(tp.pauses.total)} (night ${String(tp.pauses.night)}, day ${String(tp.pauses.day)}, unknown ${String(tp.pauses.unknown)}), ` +
+            `${String(tp.pauses.pausedMinutes)} min paused, ${String(tp.pauses.unresolved)} without a reset`,
+        `  paused nights                ${String(tp.nights.paused.length)} of ${String(tp.nights.active.length)} active night(s)`,
+        `  turn-end refusals            ${String(refusals.total)} in ${String(refusals.sessionsWithRefusals)} session(s) with a refusal — ` +
+            `the whole refusal store, ${(refusals.earliest ?? '-').slice(0, 10)}..${(refusals.latest ?? '-').slice(0, 10)}, not the --limit window`,
+        ...DETECTOR_IDS.map((d) => `    ${d.padEnd(18)}${String(refusals.byDetector[d])}`),
+        `  git push                     ${String(tp.push.calls)} call(s), p50 ${p50(tp.push.medianSeconds, 's')}`,
+        `  ready roadmaps at 0 ticked   ${String(st.estate.atZero)} of ${String(st.estate.ready)} (at --ref)`,
+        `  open steps without blocked-by ${String(st.estate.unblocked)} of ${String(st.estate.openSteps)}`,
+        `  standing rule files          ${String(st.rules.files)}, ${String(st.rules.withoutPaths)} without \`paths:\``,
+    ];
+    for (const ci of st.ci) {
+        lines.push(
+            `  ${ci.workflow} ${ci.range} (created, UTC dates)   ${String(ci.runs)} successful PR run(s), p50 ${p50(ci.medianMinutes, 'min')}` +
+                (ci.truncated ? ' — TRUNCATED at the listing limit, the window holds more runs' : ''),
+        );
+    }
+    for (const g of git) {
+        lines.push(
+            `  git ${g.range} @ ${g.ref} · ${String(g.calendarNights)} night(s), ${String(g.nights)} with a commit (22:00–08:00 Europe/Berlin)`,
+            `    commits ${String(g.commits)} (${per(g.commits, g.calendarNights)}/night), naming a PR ${String(g.prCommits)} (${per(g.prCommits, g.calendarNights)}/night) · true merges ${String(g.trueMerges)}`,
+            `    net ticked steps ${String(g.netTicked)} (${per(g.netTicked, g.calendarNights)}/night) · roadmaps archived ${String(g.archived)}`,
+            `    paused nights ${String(inRange(tp.nights.paused, g.range))} of ${String(inRange(tp.nights.active, g.range))} active (transcripts in the --limit window)`,
+        );
+    }
+    lines.push('');
+    return lines.join('\n');
+}
+
 function render(t: Turnaround, store: string): string {
     const pct = (x: number): string => `${String(Math.round(x * 1000) / 10)} %`;
     return [
@@ -481,13 +685,66 @@ function render(t: Turnaround, store: string): string {
     ].join('\n');
 }
 
+/**
+ * One record per verdict shape. The evidence carries the metric NAMES, never
+ * values or a date: the store's fingerprint folds digits away, so a red reading
+ * on a later day increments the same record, reopens it and stamps `last_seen`
+ * — the date lives there, not in the text.
+ */
+export function queueRegression(root: string, verdict: string, now: Date): void {
+    const rec = upsertFinding(root, {
+        defect_class: 'model-noticed',
+        source: 'self-detected',
+        evidence: `probe_turnaround regression: ${verdict}`,
+        suggested_surface:
+            `road-to-agent-throughput-recovery owns the figures; re-run probe_turnaround --against-baseline and read ${BUDGET_REL}`,
+    }, now.toISOString());
+    if (rec === null) {
+        process.stderr.write('probe_turnaround: the self-repair creation cap dropped this verdict; the store counts it as overflow\n');
+    }
+}
+
+/**
+ * `--steps`: where each closed roadmap step's wall-clock went. A report, never a
+ * gate; exit 1 only when a step's classes do not sum to its total, because then
+ * the split itself is wrong and no row of it can be read.
+ */
+function reportSteps(files: readonly string[], store: string, json: boolean): number {
+    const readings = files.flatMap((f) => readSteps(f, classifyBlockingCall));
+    const s = summariseSteps(readings);
+    if (json) {
+        process.stdout.write(`${JSON.stringify({ store, sessions: files.length, ...s }, null, 2)}\n`);
+    } else {
+        const lines = [
+            `probe:turnaround --steps · ${String(s.steps)} closed step(s) over ${String(files.length)} transcript(s) in ${store}`,
+            `  per step: p50 ${String(s.p50Min)} min · p90 ${String(s.p90Min)} min · roadmap read p50 ${String(s.roadmapReadP50Kb)} KB · p90 ${String(s.roadmapReadP90Kb)} KB`,
+            '  class      p50 s   p90 s   share',
+            ...STEP_CLASSES.map((c) => {
+                const r = s.byClass[c];
+                return `  ${c.padEnd(9)} ${String(r.p50).padStart(6)}  ${String(r.p90).padStart(6)}  ${(r.share * 100).toFixed(1).padStart(5)} %`;
+            }),
+            '  change class   steps   p50 min   p90 min   mean batch',
+            ...(['R0', 'R1', 'R2', 'R3'] as const).map((k) => {
+                const r = s.byRisk[k];
+                return `  ${k.padEnd(13)} ${String(r.steps).padStart(6)}  ${String(r.p50Min).padStart(8)}  ${String(r.p90Min).padStart(8)}  ${String(r.meanBatch).padStart(11)}`;
+            }),
+        ];
+        process.stdout.write(`${lines.join('\n')}\n`);
+    }
+    if (s.sumErrors.length > 0) {
+        for (const err of s.sumErrors) process.stderr.write(`❌  probe_turnaround: ${err}\n`);
+        return 1;
+    }
+    return 0;
+}
+
 export function main(argv: string[] = process.argv.slice(2)): number {
     const arg = (flag: string, dflt: string): string => {
         const i = argv.indexOf(flag);
         return i >= 0 && argv[i + 1] !== undefined ? (argv[i + 1] as string) : dflt;
     };
     for (const a of argv) {
-        if (a.startsWith('-') && !['--store', '--limit', '--json', '--against-baseline', '--include-current', '-h', '--help'].includes(a)) {
+        if (a.startsWith('-') && !['--store', '--limit', '--json', '--against-baseline', '--include-current', '--workspace', '--git', '--ref', '--rules-dir', '--ci', '--queue-root', '--steps', '-h', '--help'].includes(a)) {
             if (!argv.includes('--store') && !argv.includes('--limit')) {
                 process.stderr.write(`probe_turnaround: unrecognized argument: ${a}\n`);
                 return 2;
@@ -496,24 +753,96 @@ export function main(argv: string[] = process.argv.slice(2)): number {
     }
     if (argv.includes('-h') || argv.includes('--help')) {
         process.stdout.write(
-            'usage: probe_turnaround [--store PATH] [--limit N] [--json] [--against-baseline] [--include-current]\n',
+            'usage: probe_turnaround [--store PATH] [--limit N] [--json] [--against-baseline] [--include-current]\n' +
+                '                        [--workspace PATH] [--git FROM..TO[,…]] [--ref REF] [--rules-dir PATH] [--ci FROM..TO[,…]]\n' +
+                '                        [--queue-root CHECKOUT] [--steps]\n',
         );
         return 0;
     }
     const store = arg('--store', defaultStore(process.cwd()));
+    const qi = argv.indexOf('--queue-root');
+    const queueRoot = qi >= 0 ? argv[qi + 1] : undefined;
+    if (qi >= 0 && (queueRoot === undefined || queueRoot.startsWith('-'))) {
+        process.stderr.write('probe_turnaround: --queue-root needs the checkout whose self-repair store gets the record\n');
+        return 2;
+    }
+    const queue = (verdict: string): void => {
+        if (queueRoot !== undefined) queueRegression(queueRoot, verdict, new Date());
+    };
     const limit = Number(arg('--limit', '10'));
     if (!Number.isFinite(limit) || limit < 1) {
         process.stderr.write('probe_turnaround: --limit needs a positive integer\n');
         return 2;
     }
+    const gitWindows = argv.includes('--git') ? parseWindows(arg('--git', '')) : [];
+    const ciWindows = argv.includes('--ci') ? parseWindows(arg('--ci', '')) : [];
+    if (gitWindows === null || ciWindows === null) {
+        process.stderr.write('probe_turnaround: --git and --ci need FROM..TO[,FROM..TO…] as YYYY-MM-DD..YYYY-MM-DD\n');
+        return 2;
+    }
+    if (argv.includes('--steps')) {
+        // A drain runs in a worktree, and the host files a worktree's transcripts
+        // under a project directory of its own, so one store holds a fraction of
+        // the steps. `--steps` reads a comma-separated list of stores as one corpus.
+        const sid = process.env['CLAUDE_CODE_SESSION_ID'];
+        const measuring = argv.includes('--include-current') || sid === undefined || sid === '' ? null : `${sid}.jsonl`;
+        const stepFiles = store
+            .split(',')
+            .flatMap((s) => storeTranscripts(s))
+            .filter((f) => path.basename(f) !== measuring)
+            .map((f) => ({ f, m: fs.statSync(f).mtimeMs }))
+            .sort((a, b) => b.m - a.m)
+            .slice(0, limit)
+            .map(({ f }) => f);
+        return reportSteps(stepFiles, store, argv.includes('--json'));
+    }
     const files = recentSessions(store, limit, argv.includes('--include-current'));
-    const t = files.length === 0 ? ZERO : measure(files);
+    const detailed = files.length === 0 ? null : measureDetailed(files);
+    const t = detailed?.turnaround ?? ZERO;
+    const tp: Throughput = detailed?.throughput ?? {
+        turnEnds: tallyExclusive([], TURN_END_NAMED, () => []),
+        pauses: { total: 0, night: 0, day: 0, unknown: 0, pausedMinutes: 0, unresolved: 0 },
+        push: { calls: 0, medianSeconds: null },
+        nights: { active: [], paused: [] },
+    };
+    const workspace = arg('--workspace', REPO_ROOT);
+    const ref = arg('--ref', 'HEAD');
+    const rulesDir = arg('--rules-dir', path.join(process.env['HOME'] ?? '', '.claude', 'rules'));
+    const ci: Standing['ci'] = ciWindows.map(([from, to]) => {
+        const { minutes, truncated } = readCiMinutes(REPO_ROOT, 'tests.yml', from, to);
+        return { range: `${from}..${to}`, workflow: 'tests.yml', runs: minutes.length, medianMinutes: median(minutes), truncated };
+    });
+    const standing: Standing = {
+        estate: readEstateAtRef(REPO_ROOT, ref),
+        rules: standingRules(rulesDir),
+        ci,
+    };
+    const refusals = collectRefusalStats(workspace);
+    const git: GitReading[] = gitWindows.map(([from, to]) => ({
+        range: `${from}..${to}`,
+        ref,
+        ...tallyNights(readCommitFacts(REPO_ROOT, ref, from, to), from, to),
+    }));
     const gating = argv.includes('--against-baseline');
 
     if (argv.includes('--json')) {
-        process.stdout.write(`${JSON.stringify({ store, ...t }, null, 2)}\n`);
+        const refusalSummary = { total: refusals.total, sessions: refusals.sessionsWithRefusals, byDetector: refusals.byDetector };
+        process.stdout.write(`${JSON.stringify({ store, ...t, throughput: tp, refusals: refusalSummary, git, standing }, null, 2)}\n`);
     } else {
         process.stdout.write(render(t, store));
+        process.stdout.write(renderThroughput(tp, refusals, git, standing));
+    }
+
+    const sumErrors = [
+        checkSum('turn ends', tp.turnEnds.rows, tp.turnEnds.total),
+        checkSum('usage-limit pauses', { night: tp.pauses.night, day: tp.pauses.day, unknown: tp.pauses.unknown }, tp.pauses.total),
+        checkSum('turn-end refusals', refusals.byDetector, refusals.total),
+        checkSum('blocking tail', Object.fromEntries(BLOCKING_CAUSES.map((c) => [c, t.blockingByCause[c].calls])), t.blockingCalls),
+    ].filter((x): x is string => x !== null);
+    if (sumErrors.length > 0) {
+        for (const err of sumErrors) process.stderr.write(`❌  probe_turnaround: ${err}\n`);
+        if (argv.includes('--against-baseline')) queue('class rows do not sum to their total, no verdict');
+        return 1;
     }
 
     if (!gating) {
@@ -532,6 +861,7 @@ export function main(argv: string[] = process.argv.slice(2)): number {
     const budget = readBudget();
     if (budget === null) {
         process.stderr.write(`❌  probe_turnaround: ${BUDGET_REL} is missing — nothing to compare against.\n`);
+        queue('baseline missing, no verdict');
         return 1;
     }
     if (files.length === 0) {
@@ -541,6 +871,7 @@ export function main(argv: string[] = process.argv.slice(2)): number {
                     'sessions certifies nothing, and the config records `empty_corpus: "fail"` so it ' +
                     'refuses rather than reporting green.\n',
             );
+            queue('empty corpus, no verdict');
             return 1;
         }
         process.stdout.write('probe:turnaround · empty corpus, `empty_corpus: "report"` — no verdict.\n');
@@ -553,6 +884,7 @@ export function main(argv: string[] = process.argv.slice(2)): number {
         process.stderr.write(
             `    → raising a baseline in ${BUDGET_REL} needs the reason as a sentence in the same commit.\n`,
         );
+        queue(regressions.map((r) => r.split(/ [<>] /)[0]).join(', '));
         return 1;
     }
     process.stdout.write('✅  probe_turnaround: within the recorded baseline on all four metrics.\n');