@event4u/agent-config 14.2.0 → 14.5.0

package/src/scripts/bench_hook_latency.ts

@@ -57,6 +57,20 @@ import { build_claude_hook_matrix } from './_lib/claude_settings_hooks.js';
 
 const REPO_ROOT = path.resolve(fileURLToPath(import.meta.url), '..', '..', '..');
 const BUNDLE = path.join(REPO_ROOT, 'dist', 'hooks', 'dispatch.js');
+/**
+ * Override the measured dispatcher bundle (`--bundle <path>`), so a
+ * two-version comparison on ONE machine is a flag rather than a throwaway
+ * script. Added for road-to-per-turn-hook-economy step 0.5, whose decisive
+ * probe is exactly that: the same events, the same method, two bundles built
+ * from two trees, same hardware. The measured process is the bundle itself —
+ * a bundle from another tree carries that tree's manifest resolution, so pass
+ * `--project-dir`-shaped state via the workspace as usual.
+ *
+ * Deliberately measurement-only: `--gate` and `--update` refuse an override,
+ * because a budget row and a regression baseline describe THIS tree's bundle
+ * and a foreign reading must never be written into either.
+ */
+let BUNDLE_OVERRIDE: string | null = null;
 const CLI_BIN = path.join(REPO_ROOT, 'dist', 'cli', 'agent-config.js');
 const SHIM = path.join(REPO_ROOT, 'agent-config');
 const MANIFEST_PATH = path.join(REPO_ROOT, 'src', 'scripts', 'hook_manifest.yaml');
@@ -98,17 +112,55 @@ function percentile(sorted: number[], p: number): number {
     return sorted[Math.max(0, idx)] as number;
 }
 
+/**
+ * Size of the synthetic `tool_response` body, in characters (`--payload-bytes`).
+ *
+ * The default 0 keeps the historical minimal payload, so every recorded number
+ * and the CI gate stay comparable. A non-zero value is the **large-payload
+ * cell** of the § 2 matrix in `road-to-per-turn-hook-economy`: D-2 is that the
+ * dispatcher re-serialises the whole envelope — tool result included — once per
+ * concern, so the cost the payload adds is what step 1.2's A/B measures.
+ * Deliberately measurement-only, like `--bundle`: a padded payload must never
+ * write a budget row or a regression baseline.
+ */
+let PAYLOAD_BYTES = 0;
+
+/**
+ * Events a `tool_response` belongs on. The § 2 matrix pads a `PostToolUse` with
+ * a large tool response and a `Stop` with a large *transcript* — two different
+ * fixtures, not one field sprayed across every slot. Padding `stop` was tried
+ * and is wrong twice over: the shape does not occur, and `spawnSync` throws
+ * EPIPE because a dispatcher that never drains a body it has no reason to read
+ * exits while the parent is still writing. The transcript cell is a separate
+ * fixture and is not implemented here.
+ */
+const TOOL_EVENTS: ReadonlySet<string> = new Set(['pre_tool_use', 'post_tool_use']);
+
 function syntheticPayload(event: string, workspace: string): string {
     // Claude-shaped payload; concerns read tool_name/tool_input for
     // pre/post_tool_use. A plain Read is the common non-matching case —
     // the fast path consumers pay on every tool call.
-    return JSON.stringify({
+    const body: Record<string, unknown> = {
         session_id: 'bench-hook-latency',
         cwd: workspace,
         hook_event_name: event,
         tool_name: 'Read',
         tool_input: { file_path: path.join(workspace, 'README.md') },
-    });
+    };
+    if (PAYLOAD_BYTES > 0 && TOOL_EVENTS.has(event)) {
+        // Filler with no JSON metacharacters, so the cost measured is
+        // serialisation volume rather than escaping. The FIELD differs per slot
+        // and that matters: `tool_response` does not exist on a `PreToolUse`
+        // payload, so padding it there would measure a shape the host never
+        // sends — the same objection this file raises against padding `stop`.
+        const filler = 'x'.repeat(PAYLOAD_BYTES);
+        if (event === 'post_tool_use') {
+            body['tool_response'] = filler;
+        } else {
+            body['tool_input'] = { ...(body['tool_input'] as object), description: filler };
+        }
+    }
+    return JSON.stringify(body);
 }
 
 /**
@@ -144,7 +196,15 @@ export function benchEvent(
             ? ['bash', ['-c', hooksJsonCommand(event)]]
             : [
                   process.execPath,
-                  [BUNDLE, '--platform', 'claude', '--event', event, '--project-dir', workspace],
+                  [
+                      BUNDLE_OVERRIDE ?? BUNDLE,
+                      '--platform',
+                      'claude',
+                      '--event',
+                      event,
+                      '--project-dir',
+                      workspace,
+                  ],
               ];
     for (let i = 0; i < runs; i += 1) {
         const started = performance.now();
@@ -170,6 +230,140 @@ export function benchEvent(
     };
 }
 
+/**
+ * Same-run control: a bare `node -e 0`, measured through the identical
+ * spawnSync harness the slots use.
+ *
+ * WHY this exists (road-to-hook-latency-gate-noise). Every slot reading is
+ * `process spawn + interpreter start + bundle load + concern work`, and only
+ * the last term is ours. The first two scale with whatever else the shared CI
+ * runner is doing, which is why the SAME commit measured `pre_tool_use` p95
+ * 107 ms and 187 ms eight minutes apart on 2026-08-19 — a 45 ms swing with no
+ * diff between them. An absolute wall-clock cap therefore reads runner load as
+ * if it were code cost, and a cap that sits INSIDE its own metric's spread
+ * (150 against an observed 107-187) fails by construction rather than on a
+ * regression.
+ *
+ * The control isolates the process-spawn term so `slot - control` is closer to
+ * this tree's own cost than the raw reading is. It is measurement only — see
+ * `normalizedRows` for why it does not gate yet.
+ *
+ * MEASURED LIMIT, first CI reading (2026-08-19): it under-corrects, and by a
+ * lot. The same commit read slot 101 / control 45 / excess 56 ms on darwin and
+ * slot 151 / control 26 / excess 124 ms on a GitHub ubuntu runner — the control
+ * went DOWN while the slot went UP. `node -e 0` covers interpreter startup
+ * only, while a dispatch also loads a ~1 MB bundle and runs the concern chain,
+ * and that term is both the dominant one and the one that varies. So the excess
+ * is NOT invariant across hardware classes; whether it is nonetheless more
+ * stable than the absolute reading across runs on the SAME runner class is the
+ * open question the observe-only collection exists to answer.
+ */
+export function benchControl(runs: number, workspace: string): EventResult {
+    const durations: number[] = [];
+    for (let i = 0; i < runs; i += 1) {
+        const started = performance.now();
+        const proc = spawnSync(process.execPath, ['-e', '0'], {
+            encoding: 'utf-8',
+            env: { ...process.env, AGENT_CONFIG_REPLAY: '1', CLAUDE_PROJECT_DIR: workspace },
+            timeout: 60000,
+        });
+        const elapsed = performance.now() - started;
+        if (proc.error) {
+            throw new Error(`control spawn failed: ${proc.error.message}`);
+        }
+        durations.push(elapsed);
+    }
+    durations.sort((a, b) => a - b);
+    return {
+        event: 'control_node_start',
+        runs,
+        p50_ms: Math.round(percentile(durations, 50)),
+        p95_ms: Math.round(percentile(durations, 95)),
+        max_ms: Math.round(durations[durations.length - 1] as number),
+    };
+}
+
+export interface NormalizedRow {
+    event: string;
+    p95_ms: number;
+    control_p95_ms: number;
+    /** Wall-clock this tree adds on top of a bare interpreter start. */
+    excess_ms: number;
+    /** slot / control — 1.0 would mean the dispatcher costs nothing. */
+    ratio: number;
+}
+
+/**
+ * Per-slot readings normalized against the same run's control.
+ *
+ * OBSERVE-ONLY, deliberately, and the reason is the same one the
+ * `per_turn_composite` row states for itself: definition before bar. No bar can
+ * be pre-registered here yet, because no historical run recorded a control — so
+ * every candidate number would be invented rather than measured, which the
+ * budget file's own contract forbids. Arming it is a config change once the
+ * nightly has published enough control-carrying runs to set `p95_excess_ci`
+ * from real data; no code change is needed.
+ *
+ * `excess_ms` is the gating candidate rather than `ratio`: the ratio's
+ * denominator is the noisiest term, so a slow runner moves it in the direction
+ * that makes the gate look GREEN — the wrong way for a safety net to fail.
+ */
+export function normalizedRows(
+    results: readonly EventResult[],
+    control: EventResult,
+): NormalizedRow[] {
+    return results.map((r) => ({
+        event: r.event,
+        p95_ms: r.p95_ms,
+        control_p95_ms: control.p95_ms,
+        excess_ms: r.p95_ms - control.p95_ms,
+        ratio: control.p95_ms === 0 ? 0 : Math.round((r.p95_ms / control.p95_ms) * 100) / 100,
+    }));
+}
+
+export interface AppliedCap {
+    /** The budget key this cap comes from, so a message names its own source. */
+    name: string;
+    cap_ms: number;
+    /** false → the breach is reported and does NOT fail the build. */
+    blocking: boolean;
+}
+
+/**
+ * Every cap that applies to one slot, tightest first.
+ *
+ * `pre_tool_use` carries a slot-specific cap AND the shared `any_hook_event`
+ * one, and previously only the specific cap was consulted for that slot. That
+ * was harmless while it was both the tighter of the two and blocking — which is
+ * the shipped configuration today (175 vs 250, neither advisory).
+ *
+ * Returning both anyway is the fail-closed shape: `blocking` defaults to TRUE
+ * on an absent key, so an older or hand-edited budget file cannot silently
+ * demote a cap, and if a future config ever does mark the tight cap advisory,
+ * `pre_tool_use` still stays inside the blocking gate rather than dropping out
+ * of it — the one slot the whole budget exists for. A test pins that.
+ */
+export function capsFor(budget: Budget, event: string): AppliedCap[] {
+    const any = budget.budgets_ms.any_hook_event;
+    const caps: AppliedCap[] = [
+        { name: 'any_hook_event', cap_ms: any.p95_ci, blocking: any.blocking ?? true },
+    ];
+    if (event === 'pre_tool_use') {
+        const specific = budget.budgets_ms.pre_tool_use;
+        caps.push({
+            name: 'pre_tool_use',
+            cap_ms: specific.p95_ci,
+            blocking: specific.blocking ?? true,
+        });
+    }
+    return caps.sort((a, b) => a.cap_ms - b.cap_ms);
+}
+
+/** The tightest cap applying to a slot — the threshold a re-measure targets. */
+export function capFor(budget: Budget, event: string): number {
+    return capsFor(budget, event)[0]?.cap_ms ?? Number.POSITIVE_INFINITY;
+}
+
 function loadJson<T>(p: string): T | null {
     try {
         return JSON.parse(fs.readFileSync(p, 'utf-8')) as T;
@@ -178,12 +372,59 @@ function loadJson<T>(p: string): T | null {
     }
 }
 
-interface Budget {
+export interface Budget {
     budgets_ms: {
-        pre_tool_use: { p95_ci: number };
-        any_hook_event: { p95_ci: number };
+        pre_tool_use: { p95_ci: number; blocking?: boolean };
+        any_hook_event: { p95_ci: number; blocking?: boolean };
     };
     regression_gate: { max_regression_pct: number };
+    gate_remeasure?: { attempts?: number };
+    normalized?: {
+        observe_only?: boolean;
+        control?: string;
+        p95_excess_ci?: number | null;
+    };
+    per_turn_composite?: {
+        definition?: string;
+        aggregation?: string;
+        tool_calls?: number;
+        observe_only?: boolean;
+        p50_ci?: number | null;
+    };
+}
+
+/**
+ * The per-turn composite (D-1 / step 4.1): the number a user experiences on one
+ * agentic turn, which no per-slot budget can represent. A single tool call fires
+ * `pre_tool_use` AND `post_tool_use`, so ten tool calls pay twenty dispatches
+ * plus the prompt and stop slots.
+ *
+ * Derived, never separately measured — feeding it the same `results` the slot
+ * rows come from is what keeps the two from disagreeing. `tool_calls` is read
+ * from the budget file rather than hardcoded, so the definition lives with the
+ * row it gates.
+ *
+ * Returns null when a slot the definition needs is missing from `results` (a
+ * partial run), because a composite computed over a subset would silently read
+ * LOW — which is the direction that makes a cap look met.
+ */
+export function perTurnComposite(
+    results: readonly EventResult[],
+    tool_calls: number,
+): { ms: number; parts: Record<string, number> } | null {
+    const p50 = (event: string): number | null => {
+        const r = results.find((x) => x.event === event);
+        return r === undefined ? null : r.p50_ms;
+    };
+    const pre = p50('pre_tool_use');
+    const post = p50('post_tool_use');
+    const ups = p50('user_prompt_submit');
+    const stop = p50('stop');
+    if (pre === null || post === null || ups === null || stop === null) return null;
+    return {
+        ms: (pre + post) * tool_calls + ups + stop,
+        parts: { pre_tool_use: pre, post_tool_use: post, user_prompt_submit: ups, stop },
+    };
 }
 
 interface HistoryEntry {
@@ -205,6 +446,15 @@ interface ResultsDoc {
 }
 
 export function main(argv: string[] = process.argv.slice(2)): number {
+    // Reset the measurement-only globals per invocation. Their guard below is
+    // per-call, so leaving them set let a second `main()` in the same process —
+    // `main(['--bundle', …])` then `main(['--update'])` — write a foreign or
+    // padded reading into this tree's budget row and regression baseline, the
+    // exact outcome the guard's own message says must never happen. Found by
+    // the R2 review.
+    BUNDLE_OVERRIDE = null;
+    PAYLOAD_BYTES = 0;
+
     const gate = argv.includes('--gate');
     const update = argv.includes('--update');
     const viaCli = argv.includes('--via-cli');
@@ -218,9 +468,53 @@ export function main(argv: string[] = process.argv.slice(2)): number {
     const runsIdx = argv.indexOf('--runs');
     const runs = runsIdx >= 0 ? Number.parseInt(argv[runsIdx + 1] ?? '50', 10) : 50;
 
-    if (!fs.existsSync(BUNDLE)) {
+    const payloadIdx = argv.indexOf('--payload-bytes');
+    if (payloadIdx >= 0) {
+        const raw = argv[payloadIdx + 1];
+        const parsed = raw === undefined ? Number.NaN : Number.parseInt(raw, 10);
+        if (!Number.isFinite(parsed) || parsed < 0) {
+            process.stderr.write('bench_hook_latency: --payload-bytes requires a non-negative integer\n');
+            return 2;
+        }
+        if (gate || update || baselineIdx >= 0) {
+            process.stderr.write(
+                'bench_hook_latency: --payload-bytes is measurement-only — a padded payload must ' +
+                    "never write this tree's budget row or regression baseline\n",
+            );
+            return 2;
+        }
+        PAYLOAD_BYTES = parsed;
+    }
+
+    const bundleIdx = argv.indexOf('--bundle');
+    if (bundleIdx >= 0) {
+        const raw = argv[bundleIdx + 1];
+        if (raw === undefined || raw.startsWith('--')) {
+            process.stderr.write('bench_hook_latency: --bundle requires a path\n');
+            return 2;
+        }
+        if (gate || update || baselineIdx >= 0) {
+            process.stderr.write(
+                'bench_hook_latency: --bundle is measurement-only — it cannot be combined with ' +
+                    '--gate, --update or --baseline (a foreign bundle must never be written ' +
+                    "into this tree's budget or regression baseline)\n",
+            );
+            return 2;
+        }
+        if (viaCli) {
+            process.stderr.write(
+                'bench_hook_latency: --bundle overrides the bundle path, which the --via-cli ' +
+                    'path does not use (the shim resolves its own) — pick one\n',
+            );
+            return 2;
+        }
+        BUNDLE_OVERRIDE = path.resolve(raw);
+    }
+
+    const measured_bundle = BUNDLE_OVERRIDE ?? BUNDLE;
+    if (!fs.existsSync(measured_bundle)) {
         process.stderr.write(
-            `bench_hook_latency: bundle missing at ${BUNDLE} — run \`npm run build:hooks\` first\n`,
+            `bench_hook_latency: bundle missing at ${measured_bundle} — run \`npm run build:hooks\` first\n`,
         );
         return 2;
     }
@@ -247,6 +541,7 @@ export function main(argv: string[] = process.argv.slice(2)): number {
 
     const workspace = fs.mkdtempSync(path.join(os.tmpdir(), 'ac-hook-bench-'));
     const results: EventResult[] = [];
+    let control: EventResult | null = null;
     try {
         if (viaCli) {
             // Stage the workspace like a real consumer project so the
@@ -264,9 +559,51 @@ export function main(argv: string[] = process.argv.slice(2)): number {
             const r = benchEvent(event, runs, workspace, via);
             results.push(r);
             process.stdout.write(
-                `${event.padEnd(20)} p50 ${String(r.p50_ms).padStart(5)} ms · p95 ${String(r.p95_ms).padStart(5)} ms · max ${String(r.max_ms).padStart(5)} ms (n=${r.runs}, via ${via})\n`,
+                `${event.padEnd(20)} p50 ${String(r.p50_ms).padStart(5)} ms · p95 ${String(r.p95_ms).padStart(5)} ms · max ${String(r.max_ms).padStart(5)} ms (n=${r.runs}, via ${via}${PAYLOAD_BYTES > 0 ? `, payload ${PAYLOAD_BYTES}B` : ''}${BUNDLE_OVERRIDE === null ? '' : ` @ ${BUNDLE_OVERRIDE}`})\n`,
             );
         }
+
+        // Both of these need the workspace, so they run before the `finally`
+        // below tears it down.
+        control = benchControl(runs, workspace);
+        process.stdout.write(
+            `${'control (node -e 0)'.padEnd(20)} p50 ${String(control.p50_ms).padStart(5)} ms · p95 ${String(control.p95_ms).padStart(5)} ms · max ${String(control.max_ms).padStart(5)} ms (n=${control.runs})\n`,
+        );
+
+        // Breach re-measure (--gate only). A single p95 over the cap is not yet
+        // evidence of a regression: a load spike inside one 50-run sample moves
+        // p95 upward and never downward, so re-measuring and keeping the MINIMUM
+        // is the estimator that discards the spike instead of recording it.
+        //
+        // SHIPS DISABLED (`gate_remeasure.attempts` is 1). The budget file's
+        // `why_not_a_retry_or_best_of_n` rejected it as the first move on
+        // measured grounds: the spread is between runner CLASSES (p50
+        // 111-148 ms), not noise within one machine, so a slow runner measures
+        // slow twice. Two CI runs of this mechanism agree — it recovered
+        // 151→150 and 160→153, i.e. 1-7 ms against a 42 ms spread. The cap was
+        // re-derived to 175 instead; this stays as the escalation that block
+        // names, reachable by setting `attempts` to 3, and costs nothing while
+        // it is off.
+        const attempts = Math.max(1, budget.gate_remeasure?.attempts ?? 1);
+        if (gate && attempts > 1) {
+            for (let i = 0; i < results.length; i += 1) {
+                const first = results[i] as EventResult;
+                if (first.p95_ms <= capFor(budget, first.event)) continue;
+                let best = first;
+                const readings = [first.p95_ms];
+                for (let attempt = 1; attempt < attempts; attempt += 1) {
+                    const again = benchEvent(first.event, runs, workspace, via);
+                    readings.push(again.p95_ms);
+                    if (again.p95_ms < best.p95_ms) best = again;
+                    if (best.p95_ms <= capFor(budget, first.event)) break;
+                }
+                results[i] = best;
+                process.stdout.write(
+                    `ℹ️  ${first.event}: over cap on the first sample — re-measured, p95 readings ` +
+                        `${readings.join(' / ')} ms, keeping the minimum (${best.p95_ms} ms)\n`,
+                );
+            }
+        }
     } finally {
         fs.rmSync(workspace, { recursive: true, force: true });
     }
@@ -275,13 +612,23 @@ export function main(argv: string[] = process.argv.slice(2)): number {
     const prior = loadJson<ResultsDoc>(RESULTS_PATH);
     const priorPath: InvocationPath = prior?.invocation_path ?? 'bundle';
     for (const r of results) {
-        const anyCap = budget.budgets_ms.any_hook_event.p95_ci;
-        const cap = r.event === 'pre_tool_use' ? budget.budgets_ms.pre_tool_use.p95_ci : anyCap;
-        if (gate && r.p95_ms > cap) {
-            process.stderr.write(
-                `❌  ${r.event}: p95 ${r.p95_ms} ms exceeds the pre-registered budget (${cap} ms)\n`,
-            );
-            failed = true;
+        if (gate) {
+            for (const applied of capsFor(budget, r.event)) {
+                if (r.p95_ms <= applied.cap_ms) continue;
+                if (applied.blocking) {
+                    process.stderr.write(
+                        `❌  ${r.event}: p95 ${r.p95_ms} ms exceeds the pre-registered budget ` +
+                            `(${applied.cap_ms} ms, ${applied.name})\n`,
+                    );
+                    failed = true;
+                } else {
+                    process.stdout.write(
+                        `⚠️  ${r.event}: p95 ${r.p95_ms} ms over the advisory budget ` +
+                            `(${applied.cap_ms} ms, ${applied.name}) — reported, not blocking; ` +
+                            `see budgets_ms.${applied.name}.blocking in ${path.basename(BUDGET_PATH)}\n`,
+                    );
+                }
+            }
         }
         if (gate && prior !== null && priorPath === via) {
             const prev = prior.results.find((x) => x.event === r.event);
@@ -303,6 +650,75 @@ export function main(argv: string[] = process.argv.slice(2)): number {
         );
     }
 
+    // Control-normalized rows. Printed on EVERY run for the same reason the
+    // composite below is: a row that only appears under --gate makes the local
+    // reading and the CI reading incomparable, and comparing them is the whole
+    // point of an instrument built to tell code cost apart from runner load.
+    if (control !== null) {
+        const normCfg = budget.normalized;
+        const bar = normCfg?.p95_excess_ci ?? null;
+        const armed = normCfg?.observe_only === false && bar !== null;
+        process.stdout.write(
+            `normalized vs control (node start p95 ${control.p95_ms} ms) — ` +
+                `${armed ? `excess budget ${String(bar)} ms` : 'observe-only'}\n`,
+        );
+        for (const row of normalizedRows(results, control)) {
+            process.stdout.write(
+                `  ${row.event.padEnd(20)} excess ${String(row.excess_ms).padStart(4)} ms · ` +
+                    `ratio ${row.ratio.toFixed(2)}\n`,
+            );
+        }
+        if (armed && gate) {
+            for (const row of normalizedRows(results, control)) {
+                if (row.excess_ms > (bar as number)) {
+                    process.stderr.write(
+                        `❌  ${row.event}: control-normalized excess ${row.excess_ms} ms exceeds ` +
+                            `the budget (${String(bar)} ms)\n`,
+                    );
+                    failed = true;
+                }
+            }
+        }
+    }
+
+    // Per-turn composite (D-1 / step 4.1). Printed on EVERY run, gate or not,
+    // because an observe-only row that only appears under --gate would leave
+    // the local reading and the CI reading incomparable.
+    const compositeCfg = budget.per_turn_composite;
+    const composite =
+        compositeCfg === undefined
+            ? null
+            : perTurnComposite(results, compositeCfg.tool_calls ?? 10);
+    if (compositeCfg !== undefined) {
+        const calls = compositeCfg.tool_calls ?? 10;
+        if (composite === null) {
+            process.stdout.write(
+                `ℹ️  per-turn composite not computed — a slot the definition needs is missing from this run\n`,
+            );
+        } else {
+            const ceiling = compositeCfg.p50_ci ?? null;
+            const observe = compositeCfg.observe_only !== false;
+            const label =
+                observe || ceiling === null ? 'observe-only' : `budget ${String(ceiling)} ms`;
+            process.stdout.write(
+                `per-turn composite  ${String(composite.ms).padStart(5)} ms ` +
+                    `= (pre ${composite.parts['pre_tool_use']} + post ${composite.parts['post_tool_use']}) × ${calls}` +
+                    ` + ups ${composite.parts['user_prompt_submit']} + stop ${composite.parts['stop']}` +
+                    ` (p50, ${label})\n`,
+            );
+            // observe_only is the arming switch for step 4.2 and is honoured
+            // even when a ceiling is present, so a number can be recorded for
+            // one release before it starts failing builds.
+            if (gate && !observe && ceiling !== null && composite.ms > ceiling) {
+                process.stderr.write(
+                    `❌  per-turn composite: ${composite.ms} ms exceeds the pre-registered ` +
+                        `budget (${ceiling} ms)\n`,
+                );
+                failed = true;
+            }
+        }
+    }
+
     if (update || baselineHardware !== null) {
         const existing = prior ?? ({ results: [] } as ResultsDoc);
         const history: HistoryEntry[] = existing.history ?? [];
@@ -329,6 +745,16 @@ export function main(argv: string[] = process.argv.slice(2)): number {
                   invocation_path: via,
                   runs_per_event: runs,
                   results,
+                  ...(composite === null
+                      ? {}
+                      : {
+                            per_turn_composite: {
+                                ms: composite.ms,
+                                tool_calls: compositeCfg?.tool_calls ?? 10,
+                                aggregation: 'p50',
+                                parts: composite.parts,
+                            },
+                        }),
                   ...(history.length > 0 ? { history } : {}),
               }
             : { ...existing, history };