create-walle 0.10.1 → 0.10.3

package/template/coding-task-manager/bin/lead-wait-census.js

@@ -0,0 +1,1348 @@
+#!/usr/bin/env node
+'use strict';
+
+// WP-0 (docs/lead-cost-routing-round1-2026-10-21.html §8, §1.2 and §1.6): the read-only lead
+// census, promoted from the 2026-10-21 pilot's scratch scripts (dd/waits4.js, dd/waits5.js,
+// cmpct/scen.js + cmpct/calls.js) into the tool the report quotes before and after every later WP.
+//
+// WHY IT EXISTS. Two questions the design answers with numbers, never with assumptions:
+//   (1) §1.2 — how do Codex leads wait, and what does each wake carry? The naive count (grep the
+//       tool names) is wrong: Codex leads issue most waits INSIDE code-mode `exec` scripts
+//       (`tools.write_stdin(...)`), and a code-mode `wait` on a yielded cell must be attributed to
+//       the cell's own script. So every wait-type call is paired with its output by call_id and the
+//       wake is classified NEWS or NOTHING — exactly the pilot's rule.
+//   (2) §1.6 — how often do leads make exploration bursts (a run of >=3 consecutive lead calls
+//       whose replies contain only read/search tools, category precedence per cmpct/calls.js)?
+//       Those runs are the Part B target, so the census reports bursts, the lead calls inside them
+//       after the first, their cost from usage_calls.cost_micros, and (`--bursts`) the hand-off
+//       compliance ratio the design's D-13 veto reads.
+//
+// READ-ONLY. Both databases are opened in place with `{ readOnly: true }` and never written; every
+// rollout is opened only through lib/transcript-source.js (createTranscriptReadStream, which
+// resolves the `.jsonl.zst` sibling). The only file this tool may ever write is the optional
+// `--json <file>`. Output is aggregates only — family labels, counts, percentages, dollars —
+// never a command string, prompt text, transcript path or session id.
+//
+// usage:
+//   node bin/lead-wait-census.js --since 2026-09-20T00:00:00Z --until 2026-10-20T17:00:00Z
+//                               [--bursts] [--command-outcomes] [--json <file>] [--data-dir <dir>]
+//
+// WP-3 (`--command-outcomes`, §5 OQ-2). One row per POLLED COMMAND RUN: a Codex command session — an
+// `exec_command` / `tools.exec_command(...)` call whose output carries a session id — followed by at
+// least one empty-`chars` `write_stdin` poll on that same session. Per family the table reports n,
+// unfinished, how often the lead acted on the partial output before the command exited, kill, the
+// duration percentiles and the partial-output median. The command string is never printed, only its
+// `classifyCommand` family label. `acted_on_partial` is the mechanical ordering rule, not a reading of
+// the lead's intent: after the LAST poll that returned non-empty output and before the exit poll, the
+// lead's first non-wait action is a stdin write (chars) on that session, an edit tool call, or a
+// kill/pkill command — the design's "cited the partial output" (AC-3a) is satisfied by this stricter
+// rule. Ambiguities the brief left open, resolved here and reported by WP-3:
+//   * wait set  — `sleep`, `wait_agent`, `walle_worker_wait`, `walle_worker_status` and a code-mode
+//                 cell `wait` are skipped; a `write_stdin` poll is an ACTION (the brief lists "another
+//                 poll" as false, and case 1 is itself a write_stdin), so an empty poll ends the scan
+//                 with false;
+//   * window    — it starts after the LAST non-empty partial poll (the newest thing the lead saw), not
+//                 the first;
+//   * duration  — originating call timestamp to the exit poll's OUTPUT timestamp (the moment the exit
+//                 was observed), so the last poll's own wait is never dropped;
+//   * pairing   — Codex returns one result per tool call, in call order, so a call is paired with
+//                 ITS result (`outputResults`): a session id belongs to the call that opened it, and a
+//                 poll's bytes/exit come from that poll's own result. Scripts that print extra text per
+//                 call and CLI-form outputs fall back to pairing the output's session ids with the
+//                 script's commands in order. A poll whose session id is not a numeric literal (a
+//                 variable, or the `{ session_id, … }` shorthand) cannot be paired and is ignored;
+//   * batching  — a script that polls and also starts commands or edits (the common real shape) still
+//                 resolves its polls; such a batch is one ACTION for the ordering rule;
+//   * bytes     — a poll's bytes are the COMMAND's output (the code-mode JSON `output` field, or the
+//                 text after Codex's `Output:` header), never Codex's own wrapper lines, so a poll
+//                 whose command printed nothing counts as empty partial output;
+//   * exit      — only the brief's two markers count (`"exit_code"` in a poll's result, or the CLI
+//                 `Process exited with code`). Real leads often print just `r.output`, which drops the
+//                 exit marker from the transcript, so such a run stays `unfinished` even though it did
+//                 exit; the tool never infers an exit from the mere absence of later polls.
+
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const readline = require('node:readline');
+const { DatabaseSync } = require('node:sqlite');
+
+const { createTranscriptReadStream } = require('../lib/transcript-source');
+const { getDataDir, getDefaultDataDir } = require('../lib/data-dir');
+
+const MAX_LINE = 5e6;
+const CODEX_THREAD_RE = /([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\.jsonl/;
+
+// WP-5 (§6.8, D-11): a Codex launch with
+// `features.code_mode.direct_only_tool_namespaces=["mcp__wall_e"]` emits the Wall-E calls as BARE
+// names, so one tool appears under two spellings in the same rollout. Both map to the same family;
+// the code-mode spellings stay recognised, so before/after windows stay comparable.
+const WAIT_TOOLS = new Map([
+  ['write_stdin', 'write_stdin poll'],
+  ['wait_agent', 'wait_agent'],
+  ['sleep', 'sleep'],
+  ['mcp__wall_e__walle_worker_wait', 'walle_worker_wait'],
+  ['mcp__wall_e__walle_worker_status', 'walle_worker_status'],
+  ['walle_worker_wait', 'walle_worker_wait'],
+  ['walle_worker_status', 'walle_worker_status'],
+]);
+
+class UsageError extends Error {}
+
+function usage() {
+  return [
+    'usage: node bin/lead-wait-census.js --since <ISO> --until <ISO> [--bursts] [--command-outcomes] [--json <file>] [--data-dir <dir>]',
+    '  --since <ISO>      window start, inclusive (2026-09-20T00:00:00Z)',
+    '  --until <ISO>      window end, exclusive',
+    '  --bursts           also print the exploration-burst table (§1.6) and the hand-off ratio',
+    '  --command-outcomes also print the polled-command-run table (§5 OQ-2): per command family, how',
+    '                     often the lead acted on partial output before the command exited',
+    '  --json <file>      write the same numbers as JSON (the only file this tool may write)',
+    '  --data-dir <dir>   directory holding usage.db and core.db (default: the CTM data dir)',
+  ].join('\n');
+}
+
+function parseArgs(argv) {
+  const parsed = { since: null, until: null, bursts: false, commandOutcomes: false, json: null, dataDir: null, help: false };
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i];
+    if (arg === '--help' || arg === '-h') { parsed.help = true; continue; }
+    if (arg === '--bursts') { parsed.bursts = true; continue; }
+    if (arg === '--command-outcomes') { parsed.commandOutcomes = true; continue; }
+    if (['--since', '--until', '--json', '--data-dir'].includes(arg)) {
+      const value = argv[i + 1];
+      if (value === undefined || value.startsWith('--')) throw new UsageError(`${arg} needs a value`);
+      i += 1;
+      if (arg === '--since') parsed.since = value;
+      else if (arg === '--until') parsed.until = value;
+      else if (arg === '--json') parsed.json = value;
+      else parsed.dataDir = value;
+      continue;
+    }
+    throw new UsageError(`unknown option ${arg}`);
+  }
+  for (const key of ['since', 'until']) {
+    if (parsed[key] === null) throw new UsageError(`--${key} is required`);
+    if (!Number.isFinite(Date.parse(parsed[key]))) throw new UsageError(`--${key} must be an ISO timestamp, got ${parsed[key]}`);
+  }
+  parsed.w0 = Date.parse(parsed.since);
+  parsed.w1 = Date.parse(parsed.until);
+  if (!(parsed.w0 < parsed.w1)) throw new UsageError('--since must be earlier than --until');
+  return parsed;
+}
+
+/** The one data directory this tool reads: `--data-dir`, else the CTM data dir when it is the literal default. */
+function resolveDataDir(dataDir) {
+  const literal = path.resolve(getDefaultDataDir());
+  if (dataDir) return path.resolve(dataDir);
+  const resolved = path.resolve(getDataDir());
+  return resolved === literal ? resolved : literal;
+}
+
+function openReadOnlyDb(dbPath) {
+  return new DatabaseSync(dbPath, { readOnly: true });
+}
+
+function parseJson(text) {
+  try { return JSON.parse(text); } catch { return null; } /* expected: a rollout line the reader must skip */
+}
+
+function outputText(output) {
+  if (typeof output === 'string') return output;
+  if (Array.isArray(output)) return output.map((x) => (x && x.text) || '').join('\n');
+  return JSON.stringify(output);
+}
+
+/* ------------------------------------------------------------------ *
+ * Lead / worker split
+ * ------------------------------------------------------------------ */
+
+/**
+ * The session index: worker provider thread ids, each worker's lane and profile, and the set of
+ * LEAD provider-session ids.
+ *
+ * The lead set is read from core.db's `agent_sessions` — the authoritative provider-session table:
+ * a session is a lead when its `ctm_session_id` is not one of `worker_sessions` and it has no
+ * `parent_agent_session_id`, i.e. a top-level interactive session rather than a delegated worker or
+ * a native sub-agent thread. A worker's `runtime_json.providerThreadId` is NOT a sufficient
+ * exclusion on its own (older worker rows carry none) and says nothing about sub-agent threads, so
+ * both rules are applied: `agent_sessions` decides membership, the thread ids are the belt-and-braces
+ * cross-check.
+ */
+function readWorkerIndex(coreDb) {
+  const threadIds = new Set();
+  const workerCtmIds = new Set();
+  const workerLaneById = new Map();
+  for (const row of coreDb.prepare('SELECT ctm_session_id, route_alias, runtime_json, launch_json FROM worker_sessions').iterate()) {
+    const runtime = parseJson(row.runtime_json || '') || {};
+    const launch = parseJson(row.launch_json || '') || {};
+    const ctmSessionId = String(row.ctm_session_id);
+    workerCtmIds.add(ctmSessionId);
+    if (runtime.providerThreadId) threadIds.add(String(runtime.providerThreadId));
+    workerLaneById.set(ctmSessionId, {
+      routed: Boolean(row.route_alias),
+      review: launch.workerProfile === 'review',
+    });
+  }
+  let sessionRows = null;
+  try {
+    sessionRows = coreDb.prepare('SELECT agent_session_id, ctm_session_id, parent_agent_session_id FROM agent_sessions').all();
+  } catch {
+    // expected: a core.db predating `agent_sessions`; the caller then falls back to the
+    // worker-thread exclusion alone rather than reporting an empty census.
+    sessionRows = null;
+  }
+  if (sessionRows === null) return { threadIds, workerCtmIds, workerLaneById, leadSessions: null };
+  const leadSessions = new Set();
+  for (const row of sessionRows) {
+    const ctmSessionId = row.ctm_session_id === null || row.ctm_session_id === undefined ? '' : String(row.ctm_session_id);
+    if (ctmSessionId && workerCtmIds.has(ctmSessionId)) continue;
+    const parent = row.parent_agent_session_id === null || row.parent_agent_session_id === undefined ? '' : String(row.parent_agent_session_id);
+    if (parent) continue;
+    if (row.agent_session_id) leadSessions.add(String(row.agent_session_id));
+  }
+  return { threadIds, workerCtmIds, workerLaneById, leadSessions };
+}
+
+/**
+ * The Codex lead threads of the window: threads whose lead calls (agent_id = '', the worker
+ * provider threads removed) fall inside it. A rollout is appended to while its session runs, so a
+ * thread with no call in the window cannot carry a wait call the census would count.
+ */
+function codexLeadThreads(usageDb, workerThreadIds, args) {
+  const leads = new Set();
+  const statement = usageDb.prepare("SELECT DISTINCT session_id FROM usage_calls WHERE provider = 'codex' AND agent_id = '' AND ts >= ? AND ts < ?");
+  for (const row of statement.iterate(args.w0, args.w1)) {
+    const sessionId = String(row.session_id);
+    if (!workerThreadIds.has(sessionId)) leads.add(sessionId);
+  }
+  return leads;
+}
+
+/**
+ * The Codex rollout files of the lead threads, preferring the `.zst` sibling when both exist
+ * (the pilot's rule). Only the day directories under the Codex sessions root are walked — no other
+ * directory is read.
+ */
+function codexRolloutFiles(sessionsRoot, leadThreads) {
+  const byLogical = new Map();
+  let years = [];
+  try { years = fs.readdirSync(sessionsRoot, { withFileTypes: true }); }
+  catch { return byLogical; } /* expected: no Codex rollout tree on this host */
+  for (const year of years) {
+    if (!year.isDirectory()) continue;
+    const yearDir = path.join(sessionsRoot, year.name);
+    let months = [];
+    try { months = fs.readdirSync(yearDir, { withFileTypes: true }); } catch { continue; } /* expected: unreadable year dir */
+    for (const month of months) {
+      if (!month.isDirectory()) continue;
+      const monthDir = path.join(yearDir, month.name);
+      let days = [];
+      try { days = fs.readdirSync(monthDir, { withFileTypes: true }); } catch { continue; } /* expected: unreadable month dir */
+      for (const day of days) {
+        if (!day.isDirectory()) continue;
+        const dayDir = path.join(monthDir, day.name);
+        let entries = [];
+        try { entries = fs.readdirSync(dayDir); } catch { continue; } /* expected: unreadable day dir */
+        for (const name of entries) {
+          const match = CODEX_THREAD_RE.exec(name);
+          if (!match || !leadThreads.has(match[1])) continue;
+          const full = path.join(dayDir, name);
+          const logical = full.replace(/\.zst$/, '');
+          const existing = byLogical.get(logical);
+          if (!existing || full.endsWith('.zst')) byLogical.set(logical, full);
+        }
+      }
+    }
+  }
+  return byLogical;
+}
+
+/* ------------------------------------------------------------------ *
+ * §1.2 — waits (waits4.js + waits5.js)
+ * ------------------------------------------------------------------ */
+
+/** Wait-tool labels of a call, or null when the call is not a pure wait call (waits4's kindOf). */
+function waitLabelsOf(tools, script) {
+  if (!tools.length) return null;
+  for (const tool of tools) if (!WAIT_TOOLS.has(tool)) return null;
+  if (tools.includes('write_stdin') && /chars\s*:\s*"[^"]+"/.test(script || '')) return null;
+  return [...new Set(tools.map((tool) => WAIT_TOOLS.get(tool)))].sort();
+}
+
+/** The table's row label (§1.2): `<family> [how called]`, or `mixed` for a multi-wait script. */
+const VIA_LABEL = Object.freeze({ direct: 'direct', exec: 'inside exec', 'cell-wait': 'code-mode cell wait' });
+
+function waitRowLabel(labels, via) {
+  if (labels.length > 1) return 'mixed';
+  return `${labels[0]} [${VIA_LABEL[via] || via}]`;
+}
+
+/** The exit marker of a `write_stdin` poll output, shared by waits4's outcome() and WP-3's runs. */
+const EXIT_RE = /"exit_code"\s*:\s*-?\d|Process exited with code/;
+
+/** waits4's outcome(): NEWS or NOTHING, in the pilot's check order. */
+function waitOutcome(labels, output) {
+  const out = String(output || '');
+  if (/^Script running with cell ID/m.test(out)) return 'NOTHING: cell still running';
+  if (/interrupted by new input|Wait interrupted/i.test(out)) return 'NEWS: user input';
+  if (labels.includes('write_stdin poll')) {
+    if (EXIT_RE.test(out)) return 'NEWS: process exited';
+    if (/"session_id"|Process running/.test(out)) return 'NOTHING: still running';
+  }
+  if (labels.includes('wait_agent')) {
+    if (/"timed_out"\s*:\s*true|timed out/i.test(out)) return 'NOTHING: timed out';
+    return 'NEWS: agent update';
+  }
+  if (labels.includes('walle_worker_wait')) {
+    const woke = /"woke_on"\s*:\s*"([a-z_]+)"/.exec(out);
+    if (woke) return woke[1] === 'timeout' ? 'NOTHING: timeout' : `NEWS: ${woke[1]}`;
+  }
+  if (labels.includes('walle_worker_status')) {
+    const status = /"status"\s*:\s*"([a-z_]+)"/.exec(out);
+    if (status) return /working|starting|throttled/.test(status[1]) ? `NOTHING: ${status[1]}` : `NEWS: ${status[1]}`;
+  }
+  if (labels.length === 1 && labels[0] === 'sleep') return 'NOTHING: slept';
+  return 'unclassified';
+}
+
+/**
+ * Records one RESOLVED wait call. Shared by the `function_call_output`/`custom_tool_call_output` path
+ * and WP-5's direct `item_completed` path, so both spellings of one call run the same §1.2
+ * NEWS/NOTHING rule (the classifier is not forked) and the same window/drop test.
+ */
+function emitWait(report, call, ts, out) {
+  if (!call.inWin) return;
+  if (!call.labels || call.labels[0] === 'other' || call.labels[0] === 'unknown cell') {
+    report.droppedWait(call.labels ? call.labels[0] : 'not a wait script');
+    return;
+  }
+  report.wait({
+    ts,
+    rowLabel: waitRowLabel(call.labels, call.via),
+    labels: call.labels,
+    outcome: waitOutcome(call.labels, out),
+    yieldMs: call.yieldMs === undefined ? null : call.yieldMs,
+  });
+}
+
+/** The text of an `item_completed` McpToolCall's `item.result`: its `content` text parts, else the value. */
+function mcpToolResultText(result) {
+  if (result && Array.isArray(result.content)) return outputText(result.content);
+  return outputText(result === undefined || result === null ? '' : result);
+}
+
+function percentile(sorted, p) {
+  if (!sorted.length) return null;
+  return sorted[Math.floor(p * (sorted.length - 1))];
+}
+
+/** One-tool-per-call label for the "first tool after a sleep" histogram (waits5.js). */
+function toolLabel(tools) {
+  if (!tools.length) return '(no tool)';
+  const labels = [...new Set(tools.map((tool) => WAIT_TOOLS.get(tool) || String(tool).replace('mcp__wall_e__walle_', '')))].sort();
+  return labels.join('+').slice(0, 60);
+}
+
+/**
+ * Streams one Codex rollout (through transcript-source: `.zst` siblings included) and reports every
+ * wait call in the window: row label, outcome, the code-mode cell yield it asked for, and the tool
+ * the lead called next after a sleep.
+ */
+async function scanRolloutForWaits(transcriptPath, opts, report) {
+  if (!fs.existsSync(transcriptPath)) return;
+  if (opts.commandRuns) beginCommandFile(opts.commandRuns);
+  const stream = createTranscriptReadStream(transcriptPath, {});
+  const calls = new Map();
+  const cells = new Map();
+  // WP-5: the call ids already reported, so one call seen under both rollout spellings counts once.
+  const reportedWaits = new Set();
+  let afterSleep = false;
+  const lines = readline.createInterface({ input: stream, crlfDelay: Infinity });
+  for await (const line of lines) {
+    // `call` is the cheap pre-filter of every call/output record; the direct Wall-E item is spelled
+    // `McpToolCall`, which does not contain the lowercase needle, so it is named here too.
+    if (line.length > MAX_LINE || !(line.includes('call') || line.includes('McpToolCall'))) continue;
+    const record = parseJson(line);
+    if (!record) continue;
+    const ts = Date.parse(record.timestamp);
+    const inWin = ts >= opts.w0 && ts < opts.w1;
+    const payload = record.payload || {};
+    const type = payload.type;
+    if (opts.commandRuns) trackCommandRun(opts.commandRuns, payload, ts, inWin);
+    // WP-5 (§6.8, D-11): the direct Wall-E MCP spelling. Since the launch change
+    // (`features.code_mode.direct_only_tool_namespaces=["mcp__wall_e"]`) one live call appears as THREE
+    // records: `function_call` (bare `walle_worker_wait`, `call_id`), this `item_completed`
+    // McpToolCall, and their `function_call_output` carrying the same `call_id`. VERIFIED on a real
+    // rollout of 2026-10-24 (39 such waits, ~/.codex/sessions/2026/10/24/): the response_item
+    // `function_call` and `function_call_output` both carry `call_id`, and it is byte-equal to the
+    // `item_completed` item's `id` (`call_id` is NOT a field of the item). One shared id, so the
+    // id-keyed dedup below is exact and no (tool, timestamp) fallback is needed.
+    if (type === 'item_completed') {
+      const item = payload.item;
+      if (item && item.type === 'McpToolCall' && item.server === 'wall-e' && WAIT_TOOLS.has(item.tool)) {
+        const callId = item.id === undefined || item.id === null ? '' : String(item.id);
+        const alreadyReported = Boolean(callId) && reportedWaits.has(callId);
+        if (callId) reportedWaits.add(callId);
+        if (!alreadyReported) {
+          // The `function_call` for the same call carries the call's own window position, so reuse it
+          // when it has been seen; the completion's own timestamp decides otherwise.
+          const call = (callId && calls.get(callId)) || { labels: [WAIT_TOOLS.get(item.tool)], via: 'direct', inWin, yieldMs: null };
+          if (callId) calls.delete(callId);
+          emitWait(report, call, ts, mcpToolResultText(item.result));
+        }
+      }
+      continue;
+    }
+    if (type === 'custom_tool_call' && payload.name === 'exec') {
+      const script = payload.input || '';
+      const tools = execToolNames(script);
+      // `labels` is null for a script that mixes waits with other work; the call is still tracked so
+      // that a later code-mode cell wait on it resolves to it (and is dropped, as `other`).
+      const labels = waitLabelsOf(tools, script);
+      calls.set(payload.call_id, { labels, via: 'exec', inWin, yieldMs: labels ? execYieldOf(script) : null });
+      if (inWin) {
+        if (tools.includes('sleep')) {
+          afterSleep = true;
+          const duration = /duration_ms["\s:]*(\d+)/.exec(script);
+          if (duration) report.sleepDuration(Number(duration[1]));
+        } else if (afterSleep) {
+          report.sleepNext(toolLabel(tools));
+          afterSleep = false;
+        }
+      }
+      continue;
+    }
+    if (type === 'function_call') {
+      const args = parseJson(payload.arguments || '{}') || {};
+      if (payload.name === 'wait' && args.cell_id) {
+        calls.set(payload.call_id, { labels: cells.get(String(args.cell_id)) || null, via: 'cell-wait', inWin });
+        continue;
+      }
+      const labels = waitLabelsOf([payload.name], payload.arguments || '');
+      if (labels) calls.set(payload.call_id, { labels, via: 'direct', inWin, yieldMs: null });
+      if (inWin) {
+        if (payload.name === 'sleep') {
+          afterSleep = true;
+          const duration = /duration_ms["\s:]*(\d+)/.exec(payload.arguments || '');
+          if (duration) report.sleepDuration(Number(duration[1]));
+        } else if (afterSleep) {
+          report.sleepNext(toolLabel([payload.name]));
+          afterSleep = false;
+        }
+      }
+      continue;
+    }
+    if (type === 'function_call_output' || type === 'custom_tool_call_output') {
+      const call = calls.get(payload.call_id);
+      if (!call) continue;
+      calls.delete(payload.call_id);
+      const out = outputText(payload.output);
+      if (call.via === 'exec') {
+        const cell = /Script running with cell ID (\S+)/.exec(out);
+        // A cell inherits the script's wait family; a script that also did other work marks `other`,
+        // and a cell wait on `other` is not a wait-type call (waits4.js's rule).
+        if (cell) cells.set(cell[1], call.labels || ['other']);
+      }
+      // WP-5 dedup: this call was already reported from its `item_completed` McpToolCall (the record
+      // that carries the result), so the bare `function_call`/`function_call_output` pair is dropped.
+      const callId = payload.call_id === undefined || payload.call_id === null ? '' : String(payload.call_id);
+      if (callId && reportedWaits.has(callId)) continue;
+      if (callId) reportedWaits.add(callId);
+      emitWait(report, call, ts, out);
+    }
+  }
+  if (opts.commandRuns) finishCommandFile(opts.commandRuns);
+}
+
+/** waits4.js: the cell yield the lead asked for when wrapping a wait in a code-mode script. */
+function execYieldOf(script) {
+  const match = /@exec:\s*(\{[^}]*\})/.exec(script);
+  if (!match) return 'default';
+  const parsed = parseJson(match[1]);
+  if (parsed && parsed.yield_time_ms !== undefined) return parsed.yield_time_ms;
+  return 'default';
+}
+
+async function runWaitPass(args, leadThreads) {
+  const sessionsRoot = path.join(os.homedir(), '.codex', 'sessions');
+  const files = codexRolloutFiles(sessionsRoot, leadThreads);
+  const rows = [];
+  const sleepDurations = [];
+  const sleepNext = new Map();
+  const yields = new Map();
+  const dropped = new Map();
+  const bump = (map, key) => map.set(key, (map.get(key) || 0) + 1);
+  const report = {
+    wait(call) {
+      rows.push(call);
+      if (call.yieldMs !== null) {
+        const key = call.labels.join('+');
+        if (!yields.has(key)) yields.set(key, new Map());
+        bump(yields.get(key), String(call.yieldMs));
+      }
+    },
+    sleepNext(label) { bump(sleepNext, label); },
+    sleepDuration(ms) { if (Number.isFinite(ms)) sleepDurations.push(ms); },
+    droppedWait(reason) { bump(dropped, reason); },
+  };
+  let unreadable = 0;
+  for (const transcriptPath of files.values()) {
+    try {
+      await scanRolloutForWaits(transcriptPath, args, report);
+    } catch {
+      // REPORTED, never silent: a rollout whose bytes cannot be decoded (a damaged `.zst` sibling)
+      // is counted and skipped so one bad file cannot abort the census.
+      unreadable += 1;
+    }
+  }
+  return { rows, sleepDurations, sleepNext, yields, dropped, fileCount: files.size, unreadable };
+}
+
+/* ------------------------------------------------------------------ *
+ * WP-3 — §5 OQ-2: did the lead act on a command's partial output?
+ * ------------------------------------------------------------------ */
+
+const SESSION_ID_JSON_RE = /"session_id"\s*:\s*(\d+)/g;
+const SESSION_ID_TEXT_RE = /Process running with session ID (\d+)/g;
+const EDIT_TOOLS = new Set(['apply_patch', 'Edit', 'Write', 'MultiEdit', 'NotebookEdit']);
+// Waits the lead parks on that carry no new information by themselves, so they are never "the first
+// non-wait action". `write_stdin` is deliberately absent: the rule counts a poll as an action.
+const PASSIVE_WAIT_TOOLS = new Set([
+  'sleep', 'wait_agent', 'wait', 'walle_worker_wait', 'walle_worker_status',
+  'mcp__wall_e__walle_worker_wait', 'mcp__wall_e__walle_worker_status',
+]);
+const KILL_RE = /\bp?kill\b/;
+
+/** One run's state: the command session, its origin, and the empty-`chars` polls seen on it. */
+function blankCommandRun(sessionId, startTs, family) {
+  return { sessionId, startTs, family, polls: [], pollsCount: 0, durationMs: null, partialBytes: null, unfinished: true, acted: false, kill: false };
+}
+
+/** The per-run accumulator, reset for every rollout file (ordering is only meaningful inside one). */
+function createCommandRunTracker() {
+  return { runs: [], actions: [], open: new Map(), seq: 0, pendingRuns: new Map() };
+}
+
+function beginCommandFile(state) {
+  state.actions = [];
+  state.open = new Map();
+  state.seq = 0;
+  state.pendingRuns = new Map();
+}
+
+/**
+ * The lead's action in one rollout call record, as the WP-3 ordering rule sees it: the command
+ * strings it starts, the `write_stdin` sites it names, whether it edits, and whether it is nothing
+ * but a passive wait. `order` is the script's tool calls in call order, which is also the order of
+ * the result texts Codex returns for them (see `outputResults`).
+ */
+function describeLeadAction(payload) {
+  const action = { waitOnly: false, edit: false, polls: [], commands: [], commandSites: [], order: [] };
+  if (payload.type === 'function_call') {
+    const name = String(payload.name || '');
+    const args = parseJson(payload.arguments || '{}') || {};
+    if (name === 'exec_command' || name === 'shell' || name === 'local_shell') {
+      const cmd = args.command === undefined ? args.cmd : args.command;
+      action.commands.push(Array.isArray(cmd) ? cmd.join(' ') : String(cmd === undefined || cmd === null ? '' : cmd));
+    } else if (name === 'write_stdin') {
+      const sessionId = typeof args.session_id === 'number' ? args.session_id : literalSessionId(`session_id:${args.session_id}`);
+      action.polls.push({ sessionId, chars: typeof args.chars === 'string' ? args.chars : '', site: 0 });
+    } else if (EDIT_TOOLS.has(name)) action.edit = true;
+    else if (PASSIVE_WAIT_TOOLS.has(name)) action.waitOnly = true;
+    return action;
+  }
+  if (payload.type === 'custom_tool_call') {
+    const name = String(payload.name || '');
+    if (name === 'exec') {
+      const script = String(payload.input || '');
+      const sites = execCallWindows(script);
+      action.order = sites.map((site) => {
+        if (site.name === 'exec_command' || site.name === 'shell') return { kind: 'command', cmd: commandLiteralOf(script, site.at) };
+        if (site.name === 'write_stdin') return { kind: 'poll', sessionId: literalSessionId(site.window), chars: literalChars(site.window) };
+        return { kind: 'other' };
+      });
+      action.order.forEach((call, i) => {
+        if (call.kind === 'command') { action.commands.push(call.cmd); action.commandSites.push(i); }
+        else if (call.kind === 'poll') action.polls.push({ sessionId: call.sessionId, chars: call.chars, site: i });
+      });
+      action.edit = sites.some((site) => EDIT_TOOLS.has(site.name));
+      // A script with no tool call at all is a reply to the user, not a wait.
+      action.waitOnly = Boolean(sites.length) && !action.edit && !action.commands.length && !action.polls.length
+        && sites.every((site) => PASSIVE_WAIT_TOOLS.has(site.name));
+      return action;
+    }
+    if (EDIT_TOOLS.has(name)) action.edit = true;
+    else if (PASSIVE_WAIT_TOOLS.has(name)) action.waitOnly = true;
+    return action;
+  }
+  return null;
+}
+
+/**
+ * The command output a poll returned, which is what "the partial output the lead saw" means here:
+ * Codex wraps it in its own `Script completed / Wall time … / Output:` (code-mode) or
+ * `Command: … / Chunk ID: … / Wall time: … / Output:` (CLI) header, and a poll whose command produced
+ * nothing must count as empty, so the wrapper is stripped before the byte count.
+ */
+function pollOutputText(output) {
+  const out = String(output || '');
+  const marker = out.lastIndexOf('Output:\n');
+  const body = marker >= 0 ? out.slice(marker + 'Output:\n'.length) : out;
+  const parsed = parseJson(body.trim());
+  if (parsed && typeof parsed === 'object' && typeof parsed.output === 'string') return parsed.output;
+  // `Promise.allSettled(...)` keeps each result under `value`; the command's output is what counts.
+  const settled = parsed && typeof parsed === 'object' && parsed.value;
+  if (settled && typeof settled === 'object' && typeof settled.output === 'string') return settled.output;
+  return body;
+}
+
+/** The session ids an originating call's output names, in the order they appear (code-mode JSON, then CLI text). */
+function runSessionIds(output) {
+  const out = String(output || '');
+  const found = [];
+  for (const [re, group] of [[SESSION_ID_JSON_RE, 1], [SESSION_ID_TEXT_RE, 1]]) {
+    re.lastIndex = 0;
+    let m;
+    while ((m = re.exec(out))) found.push({ at: m.index, sessionId: Number(m[group]) });
+  }
+  found.sort((a, b) => a.at - b.at);
+  return found.map((hit) => hit.sessionId);
+}
+
+/**
+ * One result text per tool call of the script, when Codex returned the output as its array form: the
+ * first element is Codex's own `Script completed / Wall time … / Output:` header and every following
+ * element is one call's result, in call order. `aligned` says the count matched the script's calls, so
+ * result `i` really belongs to call `i`; a lead that prints extra text per call, or a CLI-form output
+ * (a single string), leaves `texts` null and the caller falls back to scanning the whole output.
+ */
+function outputResults(output, callCount) {
+  if (!Array.isArray(output)) return { texts: null, aligned: false };
+  const texts = output.map((part) => (typeof part === 'string' ? part : String((part && part.text) || '')));
+  const body = texts.length && /^\s*(Script completed|Script running with cell ID)/.test(texts[0]) ? texts.slice(1) : texts;
+  return { texts: body, aligned: body.length === callCount };
+}
+
+/** The family label `classifyCommand` gives a command string (never the command itself). */
+function commandFamily(cmd) {
+  const rec = blankCall();
+  classifyCommand(cmd, rec);
+  const cats = new Set(Object.keys(rec.cat));
+  if (!cats.size) return 'unknown command';
+  if (cats.has('edit')) return 'edit files';
+  if (cats.has('test')) return 'run tests / gate';
+  if (cats.has('ship')) return 'commit / merge';
+  if (cats.has('review')) return 'review diff / log';
+  if (cats.has('read')) return 'read / search';
+  return 'other shell';
+}
+
+/**
+ * Feeds one rollout call record (or its output) into the run tracker. The call record creates the
+ * action entry and the run's polls; the output record resolves the run's session ids and the poll's
+ * exit, bytes and observation time.
+ */
+function trackCommandRun(state, payload, ts, inWin) {
+  const type = payload.type;
+  if (type === 'function_call' || type === 'custom_tool_call') {
+    const action = describeLeadAction(payload);
+    if (!action || !payload.call_id) return;
+    const entry = { seq: state.seq, ts, inWin, action };
+    state.seq += 1;
+    state.actions.push(entry);
+    state.open.set(String(payload.call_id), entry);
+    if (!inWin) return;
+    for (const poll of action.polls) {
+      if (poll.sessionId === null || poll.chars.length) continue;
+      const run = state.pendingRuns.get(poll.sessionId);
+      if (run) run.polls.push({ seq: entry.seq, ts, outTs: null, bytes: 0, exited: false });
+    }
+    return;
+  }
+  if (type !== 'function_call_output' && type !== 'custom_tool_call_output') return;
+  const entry = state.open.get(String(payload.call_id));
+  if (!entry) return;
+  state.open.delete(String(payload.call_id));
+  const out = outputText(payload.output);
+  const { texts, aligned } = outputResults(payload.output, entry.action.order.length);
+  if (entry.action.commands.length) {
+    if (!entry.inWin) return;
+    const ids = runSessionIds(out);
+    entry.action.commands.forEach((cmd, i) => {
+      // With one result per call, the call's own result says whether it opened a session; without that
+      // alignment the ids of the whole output are paired with the commands in order.
+      const sessionId = aligned ? runSessionIds(texts[entry.action.commandSites[i]])[0] : (ids.length === 1 ? ids[0] : ids[i]);
+      if (sessionId === undefined) return;
+      if (state.pendingRuns.has(sessionId)) return;
+      const run = blankCommandRun(sessionId, entry.ts, commandFamily(cmd));
+      state.pendingRuns.set(sessionId, run);
+    });
+  }
+  // A real lead batches polls with other work in one script, so this runs even when the script also
+  // started commands or edited files.
+  for (const poll of entry.action.polls) {
+    if (poll.sessionId === null || poll.chars.length) continue;
+    const run = state.pendingRuns.get(poll.sessionId);
+    if (!run) continue;
+    const record = run.polls.find((p) => p.seq === entry.seq);
+    if (!record) continue;
+    const result = aligned ? String(texts[poll.site] || '') : out;
+    record.outTs = ts;
+    record.bytes = pollOutputText(result).length;
+    record.exited = EXIT_RE.test(result);
+  }
+}
+
+/** What the lead's action does to an in-flight run: `acted` (case 1/2/3) and the kill sub-flag. */
+function actionVerdict(action, sessionId) {
+  for (const poll of action.polls) {
+    if (poll.sessionId !== sessionId || !poll.chars.length) continue;
+    return { acted: true, kill: poll.chars.includes('\u0003') };
+  }
+  if (action.edit) return { acted: true, kill: false };
+  for (const cmd of action.commands) if (KILL_RE.test(cmd)) return { acted: true, kill: true };
+  return { acted: false, kill: false };
+}
+
+/**
+ * Closes one rollout file: every run either has an exit poll (duration, partial bytes and the
+ * ordering rule) or is counted unfinished. Nothing is inferred from what the lead wrote — only from
+ * which call came first.
+ */
+function finishCommandFile(state) {
+  for (const run of state.pendingRuns.values()) {
+    const polls = run.polls;
+    run.pollsCount = polls.length;
+    // The brief's definition: a run is a run only when at least one empty-`chars` poll followed the
+    // originating call. A session that was started and never polled is not a polled command run.
+    if (!polls.length) continue;
+    const exitIndex = polls.findIndex((poll) => poll.exited);
+    if (exitIndex < 0) {
+      state.runs.push(run);
+      continue;
+    }
+    run.unfinished = false;
+    run.durationMs = polls[exitIndex].outTs - run.startTs;
+    let partialBytes = 0;
+    let lastPartial = -1;
+    for (let i = 0; i < exitIndex; i += 1) {
+      if (polls[i].bytes > 0) { partialBytes += polls[i].bytes; lastPartial = i; }
+    }
+    run.partialBytes = partialBytes;
+    if (lastPartial >= 0) {
+      for (let seq = polls[lastPartial].seq + 1; seq < polls[exitIndex].seq; seq += 1) {
+        const entry = state.actions[seq];
+        if (!entry || !entry.inWin || entry.action.waitOnly) continue;
+        const verdict = actionVerdict(entry.action, run.sessionId);
+        run.acted = verdict.acted;
+        run.kill = verdict.kill;
+        break;
+      }
+    }
+    state.runs.push(run);
+  }
+  state.pendingRuns = new Map();
+}
+
+function numberText(value) { return Number(value).toLocaleString('en-US'); }
+
+/** §5 OQ-2's rows: per command family, plus the pooled `Total`, sorted by finished runs. */
+function commandOutcomeRows(runs) {
+  const byFamily = new Map();
+  for (const run of runs) {
+    if (!byFamily.has(run.family)) {
+      byFamily.set(run.family, { family: run.family, n: 0, unfinished: 0, acted: 0, kill: 0, durations: [], partials: [] });
+    }
+    const entry = byFamily.get(run.family);
+    if (run.unfinished) { entry.unfinished += 1; continue; }
+    entry.n += 1;
+    if (run.acted) { entry.acted += 1; if (run.kill) entry.kill += 1; }
+    entry.durations.push(run.durationMs);
+    entry.partials.push(run.partialBytes);
+  }
+  const rows = [...byFamily.values()].sort((a, b) => b.n - a.n || a.family.localeCompare(b.family));
+  const total = { family: 'Total', n: 0, unfinished: 0, acted: 0, kill: 0, durations: [], partials: [] };
+  for (const row of rows) {
+    total.n += row.n;
+    total.unfinished += row.unfinished;
+    total.acted += row.acted;
+    total.kill += row.kill;
+    total.durations.push(...row.durations);
+    total.partials.push(...row.partials);
+  }
+  rows.push(total);
+  for (const row of rows) {
+    row.durations.sort((a, b) => a - b);
+    row.partials.sort((a, b) => a - b);
+    const p50 = percentile(row.durations, 0.5);
+    const p90 = percentile(row.durations, 0.9);
+    row.share = row.n ? (100 * row.acted) / row.n : 0;
+    row.dur_p50_s = p50 === null ? null : Math.round(p50 / 1000);
+    row.dur_p90_s = p90 === null ? null : Math.round(p90 / 1000);
+    row.partial_p50 = percentile(row.partials, 0.5);
+  }
+  return rows;
+}
+
+/** The §5 OQ-2 table, in the brief's shape; a family label is the only thing ever printed. */
+function commandOutcomeLines(rows) {
+  const lines = ['command outcomes (polled code-mode command runs; did the lead act on partial output before exit?)'];
+  const seconds = (v) => (v === null ? 'n/a' : numberText(v));
+  lines.push(`${pad('family', 20)}${padLeft('n', 6)}${padLeft('unfinished', 12)}${padLeft('acted-on-partial', 18)}${padLeft('kill', 6)}${padLeft('dur p50/p90 s', 16)}${padLeft('partial p50', 13)}`);
+  for (const row of rows) {
+    lines.push(`${pad(row.family, 20)}${padLeft(numberText(row.n), 6)}${padLeft(numberText(row.unfinished), 12)}`
+      + `${padLeft(`${numberText(row.acted)} (${row.share.toFixed(1)}%)`, 18)}${padLeft(numberText(row.kill), 6)}`
+      + `${padLeft(`${seconds(row.dur_p50_s)} / ${seconds(row.dur_p90_s)}`, 16)}${padLeft(seconds(row.partial_p50), 13)}`);
+  }
+  return lines;
+}
+
+/* ------------------------------------------------------------------ *
+ * §1.6 — exploration bursts
+ * ------------------------------------------------------------------ */
+
+// The pilot's per-call classifier, ported VERBATIM from its scratch script ref/parse-tools.js
+// (TEST_RE/COMMIT_RE/REVIEW_RE/READ_RE, DELEG, fileClass/lineDiff/patchStats, classifyCommand,
+// addTool, addExec). It is deliberately not a reconstruction of the same intent: `read / search` is
+// what drives a burst, so a looser read rule silently inflates every baseline this tool prints.
+const TEST_RE = /\b(npm (run )?test|npx (playwright|jest|vitest)|node --test|node\s+\S*run-(test-suite|hermetic)|test-gate|run-hermetic|pytest|playwright test|jest\b|vitest\b|go test|cargo test|phpunit|deflake)/;
+const COMMIT_RE = /\bgit\s+(-C\s+\S+\s+)?(commit|merge|push|cherry-pick|rebase)\b/;
+const REVIEW_RE = /\bgit\s+(-C\s+\S+\s+)?(diff|show|log)\b/;
+const READ_RE = /^\s*(cd\s+\S+\s*&&\s*)?(cat|sed|head|tail|rg|grep|ls|find|wc|nl|less|awk|tree|jq|sqlite3)\b/;
+const DELEG = {
+  Agent: 'spawn_sub', Task: 'spawn_sub', spawn_agent: 'spawn_sub', TaskOutput: 'wait_sub', AgentOutputTool: 'wait_sub', wait: 'wait_sub', wait_agent: 'wait_sub',
+  send_message: 'msg_sub', send_input: 'msg_sub', SendMessage: 'msg_sub', close_agent: 'msg_sub', TaskStop: 'msg_sub',
+  walle_delegate_implementation: 'delegate', walle_worker_wait: 'worker_wait', walle_worker_status: 'worker_status',
+  walle_resume_worker: 'worker_resume', walle_stop_worker: 'worker_stop',
+  followup_task: 'msg_sub', list_agents: 'wait_sub', ListAgents: 'wait_sub', SubagentHandback: 'handback',
+};
+
+function fileClass(p) {
+  const f = String(p || '');
+  if (/\/\.claude\/briefs\/|brief\.md$|-brief\.md$|worker-reports\//.test(f)) return 'brief';
+  if (/(^|\/)(tests?|tests-[a-z]+|__tests__)\/|\.test\.|\.spec\./.test(f)) return 'test';
+  if (/\.(html|md|txt)$/.test(f)) return 'doc';
+  if (/\.(json|lock|snap|svg|csv|jsonl)$/.test(f) || /golden|baseline|fixtures\//.test(f)) return 'data';
+  return 'code';
+}
+
+function lineDiff(oldS, newS) {
+  const a = String(oldS || '').split('\n'); const b = String(newS || '').split('\n');
+  if (!oldS) return { add: newS ? b.length : 0, del: 0 };
+  const m = new Map(); for (const l of a) m.set(l, (m.get(l) || 0) + 1);
+  let common = 0; for (const l of b) { const c = m.get(l); if (c) { common++; m.set(l, c - 1); } }
+  return { add: b.length - common, del: a.length - common };
+}
+
+/**
+ * The `tools.<name>(` calls one Codex code-mode `exec` script makes, in script order, each with the
+ * slice of script text that follows it (the window its arguments live in).
+ */
+function execCallWindows(script) {
+  const s = String(script || '');
+  const sites = [];
+  for (const m of s.matchAll(/tools\.([A-Za-z0-9_]+)\s*\(/g)) {
+    const next = s.indexOf('tools.', m.index + 1);
+    sites.push({ name: m[1], at: m.index, window: s.slice(m.index, next < 0 ? m.index + 600 : Math.min(next, m.index + 600)) });
+  }
+  return sites;
+}
+
+/** The `tools.<name>(` calls one Codex code-mode `exec` script makes, in script order. */
+function execToolNames(script) {
+  return execCallWindows(script).map((site) => site.name);
+}
+
+/**
+ * The `cmd:`/`command:` literal of the `exec_command` whose `tools.` match starts at `fromIndex`,
+ * searched forward (parse-tools.js's window). A non-JSON literal is kept raw.
+ */
+function commandLiteralOf(script, fromIndex) {
+  const cm = /(?:cmd|command)\s*:\s*("(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|`[^`]*`|\[[^\]]*\])/.exec(script.slice(fromIndex, fromIndex + 4000));
+  let cmd = cm ? cm[1] : '';
+  try { if (cmd.startsWith('"')) cmd = JSON.parse(cmd); } catch { /* expected: a non-JSON literal; keep the raw text */ }
+  return cmd;
+}
+
+/** The command strings a call record starts, in script order (WP-3's run origins). */
+function execCommandStrings(script) {
+  const s = String(script || '');
+  return execCallWindows(s)
+    .filter((site) => site.name === 'exec_command' || site.name === 'shell')
+    .map((site) => commandLiteralOf(s, site.at));
+}
+
+/** The literal argument of a `"..."`/`'...'`/`` `...` `` site, decoded when it is JSON-escaped. */
+function decodeStringLiteral(literal) {
+  const parsed = parseJson(String(literal));
+  return typeof parsed === 'string' ? parsed : String(literal).slice(1, -1);
+}
+
+/** The numeric session id a `write_stdin` call site names, or null when it is not a literal. */
+function literalSessionId(text) {
+  const m = /session_id\s*:\s*(?:"(\d+)"|'(\d+)'|(\d+))/.exec(text);
+  return m ? Number(m[1] ?? m[2] ?? m[3]) : null;
+}
+
+/** The `chars` a `write_stdin` call site carries ('' when the field is absent). */
+function literalChars(text) {
+  const m = /chars\s*:\s*("(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|`[^`]*`)/.exec(text);
+  return m ? decodeStringLiteral(m[1]) : '';
+}
+
+/** The `tools.write_stdin(...)` call sites of a code-mode script, with their session id and chars. */
+function writeStdinSites(script) {
+  return execCallWindows(script)
+    .filter((site) => site.name === 'write_stdin')
+    .map((site) => ({ sessionId: literalSessionId(site.window), chars: literalChars(site.window) }));
+}
+
+function unescapeJs(s) { return s.includes('\n') ? s : s.replace(/\\n/g, '\n').replace(/\\t/g, '\t').replace(/\\"/g, '"').replace(/\\\\/g, '\\'); }
+
+function patchStats(text, rec) {
+  let i = 0;
+  while ((i = text.indexOf('*** Begin Patch', i)) >= 0) {
+    const j = text.indexOf('*** End Patch', i); const body = unescapeJs(text.slice(i, j < 0 ? undefined : j)); i = j < 0 ? text.length : j + 1;
+    let cur = null;
+    for (const line of body.split('\n')) {
+      const h = /^\*\*\* (Update|Add|Delete) File: (.+)$/.exec(line.trim());
+      if (h) { cur = h[2].trim(); rec.files.add(cur); continue; }
+      if (!cur) continue;
+      const cls = fileClass(cur);
+      if (line.startsWith('+') && !line.startsWith('+++')) rec.lines[cls] = (rec.lines[cls] || [0, 0]), rec.lines[cls][0]++;
+      else if (line.startsWith('-') && !line.startsWith('---')) rec.lines[cls] = (rec.lines[cls] || [0, 0]), rec.lines[cls][1]++;
+    }
+    rec.cat.edit = (rec.cat.edit || 0) + 1;
+  }
+}
+
+function classifyCommand(cmd, rec) {
+  const c = String(cmd || '');
+  if (!c) return;
+  if (/apply_patch/.test(c) && c.includes('*** Begin Patch')) { patchStats(c, rec); return; }
+  if (TEST_RE.test(c)) rec.cat.test = (rec.cat.test || 0) + 1;
+  else if (COMMIT_RE.test(c)) rec.cat.ship = (rec.cat.ship || 0) + 1;
+  else if (REVIEW_RE.test(c)) rec.cat.review = (rec.cat.review || 0) + 1;
+  else if (READ_RE.test(c)) rec.cat.read = (rec.cat.read || 0) + 1;
+  else rec.cat.bash = (rec.cat.bash || 0) + 1;
+}
+
+function addTool(name, input, rec) {
+  const base = String(name || '').replace(/^mcp__[a-z_-]+__/i, '');
+  if (DELEG[base]) { rec.cat[DELEG[base]] = (rec.cat[DELEG[base]] || 0) + 1; return; }
+  switch (base) {
+    case 'Edit': case 'MultiEdit': case 'Write': case 'NotebookEdit': {
+      const fp = input && (input.file_path || input.notebook_path); if (fp) rec.files.add(fp);
+      const cls = fileClass(fp);
+      const edits = base === 'MultiEdit' ? (input.edits || []) : base === 'Write' ? [{ old_string: '', new_string: input && input.content }] : [{ old_string: input && input.old_string, new_string: input && (input.new_string ?? input.new_source) }];
+      for (const e of edits) { const d = lineDiff(e.old_string, e.new_string); rec.lines[cls] = rec.lines[cls] || [0, 0]; rec.lines[cls][0] += d.add; rec.lines[cls][1] += d.del; }
+      rec.cat[cls === 'brief' ? 'brief' : 'edit'] = (rec.cat[cls === 'brief' ? 'brief' : 'edit'] || 0) + 1;
+      return;
+    }
+    case 'apply_patch': patchStats(typeof input === 'string' ? input : JSON.stringify(input || ''), rec); return;
+    case 'Read': case 'Grep': case 'Glob': case 'LS': case 'NotebookRead': rec.cat.read = (rec.cat.read || 0) + 1; return;
+    case 'Bash': case 'shell': case 'exec_command': case 'local_shell': {
+      const cmd = input && (input.command ?? input.cmd);
+      classifyCommand(Array.isArray(cmd) ? cmd.join(' ') : cmd, rec); return;
+    }
+    case 'write_stdin': case 'BashOutput': case 'KillShell': case 'Monitor': case 'sleep': case 'ScheduleWakeup': case 'clock__curr_time': rec.cat.poll = (rec.cat.poll || 0) + 1; return;
+    default:
+      if (/search_graph|search_code|get_code_snippet|trace_path|query_graph|get_architecture|codebase/i.test(name)) { rec.cat.read = (rec.cat.read || 0) + 1; return; }
+      if (/^(browser_batch|computer|javascript_tool|navigate|tabs_[a-z_]+|find|get_page_text|read_page|form_input|read_console_messages|read_network_requests|gif_creator|upload_image|resize_window)$/.test(base)) { rec.cat.browser = (rec.cat.browser || 0) + 1; return; }
+      if (/^(WebFetch|WebSearch|web__run|web_search)$/.test(base)) { rec.cat.web = (rec.cat.web || 0) + 1; return; }
+      if (/^walle_|lookup_context|search_memories|context_hint/.test(base)) { rec.cat.memory = (rec.cat.memory || 0) + 1; return; }
+      rec.cat.other = (rec.cat.other || 0) + 1; rec.other[base] = (rec.other[base] || 0) + 1;
+  }
+}
+
+/** Codex code-mode `exec`: JS text calling tools.<name>({...}). Extract inner calls. */
+function addExec(code, rec) {
+  const s = String(code || '');
+  const re = /tools\.([A-Za-z0-9_]+)\s*\(/g; let m;
+  let any = false;
+  while ((m = re.exec(s))) {
+    any = true;
+    const name = m[1];
+    if (name === 'exec_command' || name === 'shell') {
+      classifyCommand(commandLiteralOf(s, m.index), rec);
+    } else if (name === 'apply_patch') {
+      patchStats(s.slice(m.index), rec);
+    } else addTool(name, null, rec);
+  }
+  if (!any && s.includes('*** Begin Patch')) patchStats(s, rec);
+}
+
+/** The per-call tool accumulator ref/parse-tools.js fills in (`cat`, `lines`, `files`, `other`). */
+function blankCall() {
+  return { cat: {}, lines: {}, files: new Set(), other: {} };
+}
+
+// ref/calls.js `category()`, precedence included. Only `read / search` drives a burst.
+const WAIT_FAMILIES = new Set(['worker_wait', 'worker_status', 'wait_sub', 'poll']);
+
+function categoryOf(call, last) {
+  const own = Object.keys(call.cat || {}); const s = new Set(own); const L = call.lines || {};
+  if (!own.length) return last ? 'reply to user' : 'text only, mid-turn';
+  if (s.has('delegate') || s.has('spawn_sub') || s.has('brief')) return 'brief / launch delegate';
+  if (s.has('worker_resume') || s.has('msg_sub') || s.has('worker_stop')) return 'send-back / steer delegate';
+  if (own.every((k) => WAIT_FAMILIES.has(k))) return 'wait / poll';
+  if (s.has('edit') && (L.code || L.test)) return 'edit code/tests';
+  if (s.has('edit')) return 'edit docs/other';
+  if (s.has('ship')) return 'commit / merge';
+  if (s.has('test')) return 'run tests / gate';
+  if (s.has('review')) return 'review diff / log';
+  if (s.has('read')) return 'read / search';
+  if (s.has('bash')) return 'other shell';
+  if (s.has('browser')) return 'browser';
+  if (s.has('memory') || s.has('web')) return 'memory / web';
+  if (s.has('handback')) return 'reply to user';
+  return 'other tool';
+}
+
+/**
+ * Lead calls of the window: `agent_id = ''` and the session is one of the lead sessions (a
+ * top-level provider session — not a worker, not a sub-agent thread). Sessions the ledger knows but
+ * the session index does not are excluded, never guessed in.
+ */
+function readLeadCalls(usageDb, args, index) {
+  const rows = [];
+  const statement = usageDb.prepare(`SELECT call_key, provider, session_id, agent_id, ts, model, cost_micros, source_file_id, line_offset
+    FROM usage_calls WHERE ts >= ? AND ts < ? ORDER BY session_id, ts`);
+  for (const row of statement.iterate(args.w0, args.w1)) {
+    if (String(row.agent_id || '') !== '') continue;
+    const sessionId = String(row.session_id);
+    if (index.leadSessions && !index.leadSessions.has(sessionId)) continue;
+    if (index.threadIds.has(sessionId)) continue;
+    rows.push({
+      sessionId,
+      provider: String(row.provider),
+      model: row.model === null || row.model === undefined ? '' : String(row.model),
+      ts: Number(row.ts),
+      costMicros: Number(row.cost_micros) || 0,
+      sourceFileId: Number(row.source_file_id),
+      lineOffset: Number(row.line_offset),
+    });
+  }
+  return rows;
+}
+
+function sourcePathsByFileId(usageDb) {
+  const map = new Map();
+  for (const row of usageDb.prepare('SELECT file_id, source_path FROM usage_files').iterate()) {
+    map.set(Number(row.file_id), String(row.source_path));
+  }
+  return map;
+}
+
+/**
+ * Reads the categories of the given calls out of their vendor transcripts. A call's reply is the
+ * record at its ledger line offset (Claude: the assistant message with its tool_use blocks; Codex:
+ * the token_usage_record, whose response items are the tool calls that preceded it).
+ */
+async function categoriesForCalls(calls, pathsByFileId) {
+  const byPath = new Map();
+  for (const call of calls) {
+    const sourcePath = pathsByFileId.get(call.sourceFileId);
+    if (!sourcePath) continue;
+    if (!byPath.has(sourcePath)) byPath.set(sourcePath, new Map());
+    byPath.get(sourcePath).set(call.lineOffset, call);
+  }
+  for (const [transcriptPath, offsets] of byPath) {
+    if (!fs.existsSync(transcriptPath)) {
+      for (const call of offsets.values()) call.category = null;
+      continue;
+    }
+    await scanTranscriptForCategories(transcriptPath, offsets);
+  }
+  return calls;
+}
+
+async function scanTranscriptForCategories(transcriptPath, offsets) {
+  let open = blankCall(); // the tools of the response that is still open (Codex)
+  let byteOffset = 0;
+  const stream = createTranscriptReadStream(transcriptPath, {});
+  const lines = readline.createInterface({ input: stream, crlfDelay: Infinity });
+  for await (const line of lines) {
+    const lineStart = byteOffset;
+    byteOffset += Buffer.byteLength(line, 'utf8') + 1;
+    const wanted = offsets.get(lineStart);
+    if (line.length > MAX_LINE) { if (wanted) wanted.category = null; continue; }
+    const record = parseJson(line);
+    if (!record) { if (wanted) wanted.category = null; continue; }
+    const payload = record.payload || {};
+    if (record.type === 'assistant') {
+      // Claude: the tools are the assistant message's tool_use blocks (parse-tools.js groups them by
+      // message id; the ledger points at the message line).
+      const call = blankCall();
+      if (record.message && Array.isArray(record.message.content)) {
+        for (const block of record.message.content) if (block && block.type === 'tool_use') addTool(block.name, block.input, call);
+      }
+      if (wanted) wanted.category = categoryOf(call, false);
+      continue;
+    }
+    if (wanted) {
+      // Codex: the reply's tool calls are the response items that preceded this usage record
+      // (`token_usage_record`, or the `token_count` event the ledger offsets point at).
+      wanted.category = categoryOf(open, false);
+      open = blankCall();
+      continue;
+    }
+    collectCodexTools(record, payload, open);
+  }
+}
+
+/** The tool calls one Codex rollout record carries (parse-tools.js's response_item switch). */
+function collectCodexTools(record, payload, call) {
+  if (record.type !== 'response_item') return;
+  if (payload.type === 'custom_tool_call') {
+    if (payload.name === 'exec') addExec(payload.input, call);
+    else addTool(payload.name, payload.input, call);
+  } else if (payload.type === 'function_call') {
+    addTool(payload.name, parseJson(payload.arguments || '{}') || {}, call);
+  } else if (payload.type === 'local_shell_call') {
+    classifyCommand((payload.action && payload.action.command || []).join(' '), call);
+  }
+}
+
+/**
+ * Runs of >=3 consecutive read/search lead calls, per cmpct/scen.js: the session's calls are taken in
+ * timestamp order, a run is a maximal stretch of `read / search` calls, it ends at any other call (a
+ * call whose reply we could not read counts as "not read / search", never as a read) or at a gap of
+ * 20 minutes or more, and only runs of 3 or more count.
+ */
+function findBursts(calls) {
+  const bySession = new Map();
+  for (const call of calls) {
+    if (!bySession.has(call.sessionId)) bySession.set(call.sessionId, []);
+    bySession.get(call.sessionId).push(call);
+  }
+  let bursts = 0;
+  let callsAfterFirst = 0;
+  let costMicros = 0;
+  for (const list of bySession.values()) {
+    list.sort((a, b) => a.ts - b.ts);
+    let i = 0;
+    while (i < list.length) {
+      if (list[i].category !== 'read / search') { i += 1; continue; }
+      let j = i;
+      while (j + 1 < list.length && list[j + 1].category === 'read / search' && list[j + 1].ts - list[j].ts < 20 * 60e3) j += 1;
+      if (j - i + 1 >= 3) {
+        bursts += 1;
+        for (let k = i + 1; k <= j; k += 1) { callsAfterFirst += 1; costMicros += list[k].costMicros; }
+      }
+      i = j + 1;
+    }
+  }
+  return { bursts, callsAfterFirst, costMicros };
+}
+
+/** Review-profile hand-offs launched from lead sessions in the window, split by lane. */
+function reviewHandOffs(usageDb, workerLaneById, args) {
+  const byLane = new Map([['routed', 0], ['native', 0], ['unknown', 0]]);
+  const statement = usageDb.prepare('SELECT session_id, worker_ctm_session_id, ts FROM usage_delegations WHERE ts >= ? AND ts < ?');
+  for (const row of statement.iterate(args.w0, args.w1)) {
+    const worker = workerLaneById.get(String(row.worker_ctm_session_id));
+    if (!worker || !worker.review) continue;
+    const lane = worker.routed ? 'routed' : 'native';
+    byLane.set(lane, byLane.get(lane) + 1);
+  }
+  return byLane;
+}
+
+/* ------------------------------------------------------------------ *
+ * Output
+ * ------------------------------------------------------------------ */
+
+function pad(text, width) { return String(text).padEnd(width); }
+function padLeft(text, width) { return String(text).padStart(width); }
+
+function waitTableLines(rowTally, total, nothingTotal) {
+  const lines = [];
+  lines.push(`${pad('what the lead waited on [how called]', 44)}${padLeft('calls', 7)}  ${padLeft('wake carried nothing', 14)}  outcomes`);
+  for (const [label, entry] of sortedEntries(rowTally)) {
+    const pct = entry.calls ? Math.round((100 * entry.nothing) / entry.calls) : 0;
+    const outcomes = [...entry.outcomes].sort((a, b) => b[1] - a[1]).map(([name, count]) => `${name} ${count}`).join(' · ');
+    lines.push(`${pad(label, 44)}${padLeft(entry.calls, 7)}  ${padLeft(`${pct}%`, 14)}  ${outcomes}`);
+  }
+  const totalPct = total ? Math.round((100 * nothingTotal) / total) : 0;
+  lines.push(`${pad('Total', 44)}${padLeft(total, 7)}  ${padLeft(`${totalPct}% (${nothingTotal})`, 14)}`);
+  return lines;
+}
+
+function tallyWaitRows(rows) {
+  const table = new Map();
+  for (const row of rows) {
+    const entry = table.get(row.rowLabel) || { calls: 0, nothing: 0, outcomes: new Map() };
+    entry.calls += 1;
+    if (row.outcome.startsWith('NOTHING')) entry.nothing += 1;
+    entry.outcomes.set(row.outcome, (entry.outcomes.get(row.outcome) || 0) + 1);
+    table.set(row.rowLabel, entry);
+  }
+  return table;
+}
+
+function sortedEntries(map) {
+  return [...map].sort((a, b) => b[1].calls - a[1].calls);
+}
+
+function histogramLines(map, header, limit) {
+  const parts = [...map].sort((a, b) => b[1] - a[1]).slice(0, limit).map(([key, count]) => `${key} ${count}`);
+  return `${header}: ${parts.length ? parts.join(' · ') : '(none)'}`;
+}
+
+async function runCensus(args) {
+  const dataDir = resolveDataDir(args.dataDir);
+  const usageDb = openReadOnlyDb(path.join(dataDir, 'usage.db'));
+  const coreDb = openReadOnlyDb(path.join(dataDir, 'core.db'));
+  try {
+    const { threadIds, workerLaneById, leadSessions } = readWorkerIndex(coreDb);
+    const leadThreads = codexLeadThreads(usageDb, threadIds, args);
+    // WP-3's tracker is created only for `--command-outcomes`, so every other run streams and
+    // reports exactly the records it always did.
+    const commandRuns = args.commandOutcomes ? createCommandRunTracker() : null;
+    const waits = await runWaitPass(commandRuns ? { ...args, commandRuns } : args, leadThreads);
+    const table = tallyWaitRows(waits.rows);
+    let total = 0;
+    let nothingTotal = 0;
+    for (const entry of table.values()) { total += entry.calls; nothingTotal += entry.nothing; }
+    return { dataDir, waits, table, total, nothingTotal, workerLaneById, workerThreadIds: threadIds, leadSessions, commandRuns, usageDb, coreDb };
+  } catch (error) {
+    usageDb.close();
+    coreDb.close();
+    throw error;
+  }
+}
+
+module.exports = {
+  parseArgs,
+  resolveDataDir,
+  openReadOnlyDb,
+  readWorkerIndex,
+  codexLeadThreads,
+  codexRolloutFiles,
+  waitLabelsOf,
+  waitRowLabel,
+  waitOutcome,
+  emitWait,
+  mcpToolResultText,
+  percentile,
+  toolLabel,
+  execYieldOf,
+  scanRolloutForWaits,
+  categoryOf,
+  addTool,
+  addExec,
+  classifyCommand,
+  fileClass,
+  blankCall,
+  execToolNames,
+  execCommandStrings,
+  writeStdinSites,
+  commandFamily,
+  createCommandRunTracker,
+  describeLeadAction,
+  trackCommandRun,
+  finishCommandFile,
+  commandOutcomeRows,
+  commandOutcomeLines,
+  findBursts,
+  reviewHandOffs,
+  readLeadCalls,
+  sourcePathsByFileId,
+  categoriesForCalls,
+  scanTranscriptForCategories,
+  tallyWaitRows,
+  sortedEntries,
+  usage,
+  UsageError,
+  runCensus,
+  run,
+};
+
+async function run(argv) {
+  const args = parseArgs(argv);
+  if (args.help) { process.stdout.write(`${usage()}\n`); return 0; }
+  const census = await runCensus(args);
+  try {
+    const out = [];
+    out.push(`lead wait census  window ${args.since} .. ${args.until} (exclusive)`);
+    out.push(...waitTableLines(census.table, census.total, census.nothingTotal));
+    const sleeps = [...census.waits.sleepDurations].sort((a, b) => a - b);
+    out.push(`sleep duration_ms p10 ${percentile(sleeps, 0.1)} p50 ${percentile(sleeps, 0.5)} p90 ${percentile(sleeps, 0.9)} (n=${sleeps.length})`);
+    out.push(histogramLines(census.waits.sleepNext, 'first tool the lead calls after a sleep', 14));
+    for (const [kind, hist] of [...census.waits.yields].sort()) {
+      const counts = [...hist].sort((a, b) => b[1] - a[1]).map(([v, c]) => `${v === 'default' ? 'default (30,000)' : `${v} ms`} ${c}`);
+      out.push(`code-mode cell yield asked when wrapping ${kind} [inside exec]: ${counts.join(' · ')}`);
+    }
+    const commandRows = args.commandOutcomes ? commandOutcomeRows(census.commandRuns.runs) : null;
+    if (commandRows) {
+      out.push('');
+      out.push(...commandOutcomeLines(commandRows));
+    }
+    const result = {
+      window: { since: args.since, until: args.until },
+      waits: { total: census.total, wake_carried_nothing: census.nothingTotal, rows: [] },
+      sleep: { n: sleeps.length, p10: percentile(sleeps, 0.1), p50: percentile(sleeps, 0.5), p90: percentile(sleeps, 0.9) },
+      sleep_next: Object.fromEntries(census.waits.sleepNext),
+      cell_yield: Object.fromEntries([...census.waits.yields].map(([k, v]) => [k, Object.fromEntries(v)])),
+      rollouts_scanned: census.waits.fileCount,
+    };
+    for (const [label, entry] of sortedEntries(census.table)) {
+      result.waits.rows.push({ label, calls: entry.calls, wake_carried_nothing: entry.nothing, outcomes: Object.fromEntries(entry.outcomes) });
+    }
+    if (commandRows) {
+      result.command_outcomes = commandRows.map((row) => ({
+        family: row.family,
+        n: row.n,
+        unfinished: row.unfinished,
+        acted_on_partial: row.acted,
+        acted_on_partial_pct: Number(row.share.toFixed(1)),
+        kill: row.kill,
+        dur_p50_s: row.dur_p50_s,
+        dur_p90_s: row.dur_p90_s,
+        partial_p50: row.partial_p50,
+      }));
+    }
+    if (args.bursts) {
+      const calls = readLeadCalls(census.usageDb, args, { leadSessions: census.leadSessions, threadIds: census.workerThreadIds });
+      const paths = sourcePathsByFileId(census.usageDb);
+      await categoriesForCalls(calls, paths);
+      const bursts = findBursts(calls);
+      const handOffs = reviewHandOffs(census.usageDb, census.workerLaneById, args);
+      const leadBurstUsd = bursts.bursts ? bursts.costMicros / 1e6 / bursts.bursts : 0;
+      out.push('');
+      out.push('exploration bursts (runs of >=3 consecutive read/search lead calls)');
+      out.push(`bursts ${bursts.bursts}`);
+      out.push(`lead calls inside bursts after the first ${bursts.callsAfterFirst}`);
+      out.push(`lead cost of those calls $${(bursts.costMicros / 1e6).toFixed(0)}; lead_burst_usd $${leadBurstUsd.toFixed(2)}`);
+      const routed = handOffs.get('routed');
+      const native = handOffs.get('native');
+      const perBurst = (n) => (bursts.bursts ? (n / bursts.bursts).toFixed(3) : 'n/a');
+      out.push(`review-profile hand-offs in window: routed ${routed} (${perBurst(routed)} per burst) · native ${native} (${perBurst(native)} per burst)`);
+      result.bursts = {
+        bursts: bursts.bursts,
+        calls_after_first: bursts.callsAfterFirst,
+        cost_usd: bursts.costMicros / 1e6,
+        lead_burst_usd: leadBurstUsd,
+        handoffs: { routed, native, routed_per_burst: bursts.bursts ? routed / bursts.bursts : null, native_per_burst: bursts.bursts ? native / bursts.bursts : null },
+      };
+    }
+    process.stdout.write(`${out.join('\n')}\n`);
+    if (args.json) fs.writeFileSync(args.json, `${JSON.stringify(result, null, 2)}\n`);
+  } finally {
+    census.usageDb.close();
+    census.coreDb.close();
+  }
+  return 0;
+}
+
+if (require.main === module) {
+  run(process.argv.slice(2))
+    .then(() => { process.exitCode = 0; })
+    .catch((error) => {
+      if (error instanceof UsageError) process.stderr.write(`lead-wait-census: ${error.message}\n${usage()}\n`);
+      else process.stderr.write(`lead-wait-census: ${error && error.stack ? error.stack : error}\n`);
+      process.exitCode = error instanceof UsageError ? 1 : 2;
+    });
+}