@ironbee-ai/cli 0.14.1 → 0.16.0

package/dist/analytics/codex/projection.js

@@ -0,0 +1,1477 @@
+"use strict";
+/**
+ * Codex session analytics projection.
+ *
+ * Turns a parsed rollout (`CodexRolloutLine[]`) into a single
+ * `SessionAnalytics` delta that's POSTed to the collector with a
+ * deterministic event id (one id per session — backend latest-wins).
+ *
+ * Privacy fence preserved: every emitted field is a count, label,
+ * byte size, or timestamp. No raw user prompts / assistant text / tool
+ * arguments on the wire. The projection READS content for keyword
+ * matching (classifier) + byte counting + apply_patch parsing, but only
+ * structural signals leave the projection.
+ *
+ * Scope note: per-turn `session_turn_analytics` events are intentionally
+ * OUT OF SCOPE on Codex. Session-level aggregates (turn counts, category
+ * breakdown, code_changes, per-tool maps) still ship via the master
+ * `session_analytics` record. Turn boundary lifecycle was an order of
+ * magnitude more code than the master event itself — Codex's turn shape
+ * (per `task_started`) was rich enough to support it, but the per-turn
+ * wire records added complexity that didn't pay off in observability.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatHexAsUuid = void 0;
+exports.deriveCodexSessionAnalyticsEventId = deriveCodexSessionAnalyticsEventId;
+exports.projectCodexDelta = projectCodexDelta;
+const crypto_1 = require("crypto");
+const event_1 = require("../../lib/event");
+Object.defineProperty(exports, "formatHexAsUuid", { enumerable: true, get: function () { return event_1.formatHexAsUuid; } });
+const types_1 = require("../shared/types");
+const classifier_1 = require("../shared/classifier");
+const tokens_1 = require("../shared/tokens");
+const errors_1 = require("../shared/errors");
+const apply_patch_1 = require("./apply-patch");
+const pricing_1 = require("./pricing");
+const classifier_2 = require("./classifier");
+const util_1 = require("../../clients/codex/util");
+const types_2 = require("./types");
+function deriveCodexSessionAnalyticsEventId(sessionId) {
+    const hex = (0, crypto_1.createHash)("sha256")
+        .update(`session_analytics:${sessionId}`)
+        .digest("hex");
+    return (0, event_1.formatHexAsUuid)(hex.slice(0, 32));
+}
+function freshAccumulator() {
+    return {
+        firstSeenTs: null, lastSeenTs: null, sessionMetaTs: null,
+        sessionSource: null, systemPromptBytes: 0,
+        turnDurationMsTotal: 0, turnDurationCount: 0,
+        firstTokenMsTotal: 0, firstTokenMsCount: 0,
+        turnCount: 0,
+        userMsgCount: 0, userMsgBytes: 0,
+        assistantMsgCount: 0,
+        toolCallCount: 0,
+        sawEditPendingBash: false, sawBashAfterEdit: false, retries: 0,
+        interruptionCount: 0,
+        currentTurnHadEdit: false, currentTurnHadRetry: false,
+        turnsWithEdit: 0, turnsWithRetry: 0, oneShotTurns: 0,
+        inputTokens: 0, outputTokens: 0, cacheReadTokens: 0, reasoningTokens: 0, costUsd: 0,
+        currentModel: "gpt-5.5",
+        models: {}, tools: {}, mcpServers: {}, bashBinaries: {}, bashSubcommands: {}, skills: {}, subAgents: {},
+        callIdToToolName: {}, callIdToBashBinary: {}, callIdToSubAgentType: {},
+        pendingPatchEntries: {}, mcpErrorRecordedCallIds: new Set(),
+        usesSubAgent: false, usesSkill: false, usesMcp: false, usesWebSearch: false, usesWebFetch: false,
+        kw: { debug: false, feature: false, refactor: false, brainstorm: false, research: false, file_pattern: false, script_pattern: false, url: false },
+        toolBuckets: (0, classifier_1.emptyToolBucketFlags)(),
+        bashFlags: (0, classifier_1.emptyBashCmdFlags)(),
+        fileChangeCounts: {}, languages: {}, linesAdded: 0, linesRemoved: 0,
+        toolErrors: 0, toolErrorCategories: {},
+        contextLatest: 0, contextPeak: 0,
+        assistantTurnIndex: 0, contextTokensBuckets: {},
+        processErrors: {},
+        userMsgsByHour: {}, userMsgsByDate: {}, userMsgsByWeekday: {},
+        lastAgentMessageMs: null, responseTimeBuckets: {},
+        priorLineTsMs: null, idleMs: 0,
+    };
+}
+// ─────────────────────────────────────────────────────────────────────────
+// Small helpers
+// ─────────────────────────────────────────────────────────────────────────
+function utf8Bytes(s) {
+    if (!s) {
+        return 0;
+    }
+    try {
+        return Buffer.byteLength(s, "utf8");
+    }
+    catch {
+        return 0;
+    }
+}
+function emptyToolUsage() {
+    return { count: 0, errors: 0, input_size: 0, output_size: 0, approximated_input_tokens: 0, approximated_output_tokens: 0 };
+}
+function emptyModelUsage() {
+    return { count: 0, input_tokens: 0, output_tokens: 0, cache_creation_tokens: 0, cache_read_tokens: 0, cost_usd: 0 };
+}
+function bumpToolInputSize(map, key, inputBytes) {
+    if (!map[key]) {
+        map[key] = emptyToolUsage();
+    }
+    map[key].count += 1;
+    if (inputBytes > 0) {
+        map[key].input_size += inputBytes;
+        // Raw float (no Math.round) — mirrors Claude's `slot.approximated_input_tokens
+        // = slot.input_size / BYTES_PER_TOKEN` (projection.ts:1912). Rounding here
+        // would silently drift values cross-client: a tool with input_size=10 emits
+        // Codex=3 vs Claude=2.5, breaking backend aggregations summing per-tool
+        // approximated_*_tokens across both clients.
+        map[key].approximated_input_tokens = map[key].input_size / tokens_1.BYTES_PER_TOKEN;
+    }
+}
+function addToolOutputBytes(map, key, bytes) {
+    if (!map[key]) {
+        map[key] = emptyToolUsage();
+    }
+    map[key].output_size += bytes;
+    map[key].approximated_output_tokens = map[key].output_size / tokens_1.BYTES_PER_TOKEN;
+}
+function localHour(iso) {
+    const d = new Date(iso);
+    // Return null on invalid timestamp instead of silently bucketing into
+    // hour 0. The call site previously got `0` from this helper and dumped
+    // every malformed-timestamp user_message into `messages_by_hour["0"]`
+    // (midnight bucket) — while the sister helpers `localDate` /
+    // `localWeekday` correctly returned "" and were guarded. The three
+    // histograms then disagreed by the malformed count: hour gained N
+    // phantom entries at "0", date and weekday gained 0. Backend cohort
+    // dashboards that pivot on time-of-day misattribute the count.
+    return Number.isFinite(d.getTime()) ? d.getHours() : null;
+}
+function localDate(iso) {
+    const d = new Date(iso);
+    if (!Number.isFinite(d.getTime())) {
+        return "";
+    }
+    const yyyy = d.getFullYear();
+    const mm = String(d.getMonth() + 1).padStart(2, "0");
+    const dd = String(d.getDate()).padStart(2, "0");
+    return `${yyyy}-${mm}-${dd}`;
+}
+function localWeekday(iso) {
+    const names = ["sunday", "monday", "tuesday", "wednesday", "thursday", "friday", "saturday"];
+    const d = new Date(iso);
+    return Number.isFinite(d.getTime()) ? names[d.getDay()] : "";
+}
+/**
+ * Bash subcommand extraction — privacy-safe (mirrors `extractBashSubcommand`
+ * in `analytics/claude/projection.ts`; keep the lists in sync).
+ *
+ * Without this guard, `tool_meta.bash_subcommands` would carry the raw
+ * second token of every command — including secrets / args / inline JSON
+ * (`echo '{"session_id":"...","status":"fail",...}'` → leaked verdict body,
+ * `rg "isValidCreditCard|cardNumber"` → leaked search pattern). Both are
+ * actual cases observed in production Codex sessions.
+ *
+ * Policy: emit `<binary> <subcommand>` ONLY for the small set of CLIs that
+ * actually have well-known subcommand verbs (git/npm/cargo/...), AND only
+ * when the second token has a safe identifier shape (alphanumeric + `.-_`).
+ * Everything else returns just the binary name (`echo`, `cat`, `find`, ...).
+ */
+const KNOWN_MULTI_SUBCOMMAND_BINARIES = new Set([
+    "git", "npm", "yarn", "pnpm", "bun",
+    "cargo", "go", "uv", "pipx", "poetry",
+    "docker", "kubectl", "helm",
+    "brew", "apt", "apt-get",
+    "aws", "gcloud", "az",
+    "make", "deno", "rustup",
+]);
+const SUBCOMMAND_TOKEN_RE = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
+function extractBashSubcommand(cmd) {
+    const tokens = cmd.trim().split(/\s+/);
+    const stripped = [];
+    for (const t of tokens) {
+        // Skip leading env-var assignments (e.g. `FOO=bar npm test` → strip FOO=bar).
+        if (/^[A-Za-z_][A-Za-z0-9_]*=/.test(t)) {
+            continue;
+        }
+        stripped.push(t);
+    }
+    if (stripped.length === 0) {
+        return undefined;
+    }
+    // Path-strip to match `extractBashBinary` (clients/codex/util.ts): same
+    // command source must produce the same key shape across `bash_binaries`
+    // and `bash_subcommands` so backend joins line up. Without the strip,
+    // `/usr/bin/git status` shipped `bash_binaries["git"]` (stripped) AND
+    // `bash_subcommands["/usr/bin/git"]` (raw) in the SAME payload, AND the
+    // `KNOWN_MULTI_SUBCOMMAND_BINARIES` lookup missed the absolute-path token
+    // → `git status` granularity dropped entirely whenever the agent typed
+    // an absolute path or `env … /usr/bin/git status`. Internal projection
+    // divergence with secret-shaped pollution downstream of the same fence
+    // round 73 closed for `bash_binaries`.
+    const rawBinary = stripped[0];
+    const binary = rawBinary.split(/[\\/]/).pop() ?? rawBinary;
+    // Defense-in-depth: empty/whitespace-only commands fall through with
+    // `binary = ""`. The current Codex caller filters via `if (sub)` so the
+    // empty key never reaches the wire, but defending at function level
+    // matches the Claude-side fix and protects future callers.
+    if (binary.length === 0) {
+        return undefined;
+    }
+    if (stripped.length === 1) {
+        return binary;
+    }
+    if (KNOWN_MULTI_SUBCOMMAND_BINARIES.has(binary)
+        && SUBCOMMAND_TOKEN_RE.test(stripped[1])) {
+        return `${binary} ${stripped[1]}`;
+    }
+    return binary;
+}
+// Same `[2s, 3600s]` admission window as the Claude side — filters out
+// auto-dispatched ticks at the low end and "left the laptop overnight"
+// stretches at the high end so the histogram reflects real human
+// response cadence.
+const RESPONSE_TIME_MIN_SEC = 2;
+const RESPONSE_TIME_MAX_SEC = 3600;
+/**
+ * Bucket an `agent_message → next user_message` gap (ms) into one of seven
+ * human-readable response-time buckets. Mirrors `responseTimeBucket` in
+ * `analytics/claude/projection.ts` — keep bucket boundaries in sync.
+ */
+function responseTimeBucket(ms) {
+    const sec = ms / 1000;
+    // Strict boundaries (matches Claude's caller-side guard at projection.ts:2311
+    // `gapSec > MIN && gapSec < MAX` — so 2.0s and 3600.0s exact gaps are both
+    // EXCLUDED, not included). Without strict bounds Codex over-counts boundary
+    // values vs Claude in cross-client dashboards.
+    if (sec <= RESPONSE_TIME_MIN_SEC || sec >= RESPONSE_TIME_MAX_SEC) {
+        return null;
+    }
+    if (sec < 10) {
+        return "2-10s";
+    }
+    if (sec < 30) {
+        return "10-30s";
+    }
+    if (sec < 60) {
+        return "30s-1m";
+    }
+    if (sec < 120) {
+        return "1-2m";
+    }
+    if (sec < 300) {
+        return "2-5m";
+    }
+    if (sec < 900) {
+        return "5-15m";
+    }
+    return ">15m";
+}
+/**
+ * Detect a Codex skill activation in a `response_item.message` (role=user)
+ * content text. Codex framework injects a synthetic user message of shape
+ * `<skill>\n<name>NAME</name>\n<path>...</path>\n---\n<rest of SKILL.md>` when
+ * the model invokes a skill (live-verified across 2026/05-06 sessions).
+ * Returns the skill name (e.g. "ironbee-verify") or null if the content
+ * doesn't match the injection shape.
+ *
+ * Defensive on the content shape — payload is typed `unknown` because Codex
+ * has multiple content-array variants (input_text / output_text / etc).
+ */
+function extractCodexSkillName(content) {
+    // content shape: [{ type: "input_text", text: "<skill>\n<name>X</name>..." }, ...]
+    if (!Array.isArray(content) || content.length === 0) {
+        return null;
+    }
+    const first = content[0];
+    if (typeof first !== "object" || first === null) {
+        return null;
+    }
+    const text = first.text;
+    if (typeof text !== "string") {
+        return null;
+    }
+    if (!text.startsWith("<skill>")) {
+        return null;
+    }
+    // <name>NAME</name> — non-greedy, line-aware (NAME can't contain </name>).
+    const m = /<name>([^<]+)<\/name>/.exec(text);
+    return m ? m[1].trim() : null;
+}
+/**
+ * Bucket an assistant-message index into one of the six `ContextTurnBucket`
+ * keys. Mirrors `turnBucket` in `analytics/claude/projection.ts` — keep in sync.
+ */
+function contextTurnBucket(turnIndex) {
+    if (turnIndex <= 3) {
+        return "1-3";
+    }
+    if (turnIndex <= 10) {
+        return "4-10";
+    }
+    if (turnIndex <= 25) {
+        return "11-25";
+    }
+    if (turnIndex <= 50) {
+        return "26-50";
+    }
+    if (turnIndex <= 100) {
+        return "51-100";
+    }
+    return "100+";
+}
+/**
+ * Classify a Codex tool-output string into one of the closed-list error
+ * categories. Mirrors Claude's `classifyToolError` taxonomy (see
+ * `analytics/claude/projection.ts`) so the wire shape stays uniform across
+ * clients — same `ToolErrorCategory` keys appear under
+ * `errors.tool_error_categories` regardless of client.
+ *
+ * Codex doesn't have a structured `is_error: true` signal (unlike Anthropic's
+ * tool_result blocks), so detection is pattern-based on the output text.
+ * Order matters — first match wins; check exit codes / explicit rejection
+ * before the broader edit/file patterns so e.g. an `Exit code: 1` from a
+ * failing edit lands in `command_failed`, not `edit_failed`.
+ */
+function classifyOutputError(output) {
+    if (!output) {
+        return { isError: false, category: null };
+    }
+    // 1. User interrupt — explicit cancel signal beats everything else.
+    //    Anchored to (?:^|\n) so a tool output that narratively contains
+    //    "[Request interrupted by user]" as a substring (test fixtures,
+    //    log replays, copy-pasted instructions) doesn't false-positive
+    //    into user_rejected. Cross-pipeline parity: live `detectFailure`
+    //    (clients/codex/hooks/track-action.ts) and import `looksLikeError`
+    //    (import/codex/runner.ts) both anchor identically — without this
+    //    `session_analytics.errors.tool_error_categories.user_rejected`
+    //    increments on substring matches while `tool_call.error` stays
+    //    undefined on the same call.
+    if (/(?:^|\n)\[Request interrupted by user\]/.test(output)) {
+        return { isError: true, category: "user_rejected" };
+    }
+    // 2. Non-zero exit code (both legacy `Process exited with code N` and
+    //    the `Exit code: N` shell-tool format Codex emits for exec_command
+    //    AND apply_patch). Both patterns are LINE-ANCHORED so a tool whose
+    //    legitimate stdout contains "Process exited with code N" in
+    //    narrative / log text doesn't false-positive into command_failed.
+    //    Cross-pipeline parity: live `detectFailure` (clients/codex/hooks/
+    //    track-action.ts) and import `looksLikeError` (import/codex/
+    //    runner.ts) both anchor to (?:^|\n) — projection must match or
+    //    `session_analytics.errors.tool_error_categories` diverges from
+    //    `tool_call.error` on the same call (analytics flags it, but
+    //    tool_call.error stays undefined).
+    const procExit = /(?:^|\n)Process exited with code (\d+)/i.exec(output);
+    if (procExit && procExit[1] !== "0") {
+        return { isError: true, category: "command_failed" };
+    }
+    const exitCode = /^Exit code:\s*(\d+)/m.exec(output);
+    if (exitCode && exitCode[1] !== "0") {
+        return { isError: true, category: "command_failed" };
+    }
+    // 3. file_changed — Claude-parity. Tightly scoped so common git diff
+    //    output (`1 file changed, 2 insertions(+)`) doesn't match.
+    if (/modified since (?:last )?read|stale read/i.test(output)) {
+        return { isError: true, category: "file_changed" };
+    }
+    // 4. file_too_large — Claude-parity. Triggered when a Codex tool refuses
+    //    an oversized file or hits a size cap.
+    if (/file (?:is )?too large|exceeds (?:maximum|max|the (?:size )?limit)/i.test(output)) {
+        return { isError: true, category: "file_too_large" };
+    }
+    // 5. file_not_found — tight phrases that come from tool-side wrappers,
+    //    not arbitrary grep / ls noise. "No such file" alone would catch
+    //    `ls: /nope: No such file or directory` even when the user wanted
+    //    that output; the explicit phrasings below are safer.
+    if (/file not found|No such file or directory|does not exist/i.test(output)) {
+        return { isError: true, category: "file_not_found" };
+    }
+    // 6. edit_failed — apply_patch verification failures (Codex's most
+    //    common edit-error shape: `apply_patch verification failed: Failed
+    //    to find expected lines in ...`), plus the legacy patch/cannot-apply
+    //    patterns the prior regex caught and Claude's "string to replace not
+    //    found" phrasing for cross-client parity.
+    //    The leading `Error` branch uses `/^\s*Error\b/` (no `/m` flag, no
+    //    colon requirement) for cross-pipeline parity with live `detectFailure`
+    //    and import `looksLikeError`. Both anchor to the START OF THE WHOLE
+    //    OUTPUT (not each line) and require the word `Error\b` — NOT a colon
+    //    suffix. The prior `/^(?:error|Error|ERROR):/m` form diverged two ways:
+    //    (a) missed bare `Error fetching ...` / `Error executing ...` outputs
+    //    that live + import correctly flag (no colon); (b) matched mid-output
+    //    `Error:` lines that live + import don't (no `/m` flag there). Net:
+    //    `session_analytics.errors.tool_error_categories.edit_failed` diverged
+    //    from `tool_call.error` non-null counts on the same call.
+    if (/^\s*Error\b/.test(output)
+        || /apply_patch verification failed/i.test(output)
+        || /failed to find expected lines/i.test(output)
+        || /string to replace not found/i.test(output)
+        || /patch failed|patch could not|cannot apply/i.test(output)) {
+        return { isError: true, category: "edit_failed" };
+    }
+    return { isError: false, category: null };
+}
+/**
+ * Map a file extension to a canonical language label. PascalCase / acronym
+ * casing mirrors Claude's `EXTENSION_TO_LANGUAGE` (projection.ts:39) so the
+ * `code_changes.languages` map is cross-client comparable — a backend
+ * aggregating Claude + Codex sessions sees a single key `"TypeScript"`
+ * regardless of source, not `"TypeScript"` + `"typescript"` as distinct
+ * buckets. Codex covers more extensions than Claude's narrower list, which
+ * is fine (more granular labels just appear under canonical casing).
+ */
+function languageFromPath(path) {
+    const ext = (/\.[a-z0-9]+$/i.exec(path)?.[0] ?? "").toLowerCase();
+    const map = {
+        ".ts": "TypeScript", ".tsx": "TypeScript",
+        ".js": "JavaScript", ".jsx": "JavaScript", ".mjs": "JavaScript", ".cjs": "JavaScript",
+        ".py": "Python", ".rb": "Ruby", ".go": "Go", ".rs": "Rust",
+        ".java": "Java", ".kt": "Kotlin", ".scala": "Scala",
+        ".swift": "Swift", ".m": "Objective-C", ".mm": "Objective-C",
+        ".c": "C", ".h": "C", ".cpp": "C++", ".cc": "C++", ".hpp": "C++",
+        ".cs": "C#", ".vb": "VB",
+        ".php": "PHP", ".html": "HTML", ".htm": "HTML",
+        ".css": "CSS", ".scss": "CSS", ".sass": "CSS", ".less": "CSS",
+        ".md": "Markdown", ".mdx": "Markdown",
+        ".json": "JSON", ".yaml": "YAML", ".yml": "YAML", ".toml": "TOML", ".xml": "XML",
+        ".sh": "Shell", ".bash": "Shell", ".zsh": "Shell",
+        ".sql": "SQL", ".graphql": "GraphQL", ".proto": "Protocol Buffer",
+        ".ex": "Elixir", ".exs": "Elixir", ".erl": "Erlang",
+        ".lua": "Lua", ".dart": "Dart", ".clj": "Clojure",
+    };
+    return map[ext] ?? null;
+}
+/**
+ * Shared per-tool-call accounting. Both `function_call` and `custom_tool_call`
+ * route here so the per-tool maps, MCP detection, Bash extraction, and
+ * code_changes derivation work uniformly.
+ *
+ * `inputRaw` is the raw input text used for size attribution:
+ *   - function_call: `arguments` (JSON-encoded; JSON-parsed when extracting Bash cmd or apply_patch body).
+ *   - custom_tool_call: `input` (raw patch text for apply_patch).
+ *
+ * `applyPatchBodyOverride` short-circuits the JSON parse path for custom_tool_call
+ * — pass the raw patch body and we use it directly. Pass `null` for function_call
+ * and we fall back to `extractApplyPatchBody(inputRaw)`.
+ */
+function processToolCall(acc, rawToolName, inputRaw, callId, applyPatchBodyOverride, 
+/**
+ * Codex's `function_call.namespace` value — used to disambiguate
+ * sub-agent detection from third-party MCP servers that might collide
+ * with built-in tool names (e.g. a custom MCP exposing its own
+ * `spawn_agent`). When set to `"multi_agent_v1"`, treat `spawn_agent`
+ * as the canonical sub-agent orchestrator. When unset / different, the
+ * tool name match still works as a fallback (legacy 0.131 rollouts
+ * omitted the field entirely).
+ */
+namespace = undefined) {
+    acc.toolCallCount += 1;
+    // Canonicalize the bare devtools tool name (`bdt_content_take_screenshot`
+    // → `bdt_content_take-screenshot`) so the `tools` map key matches the
+    // wire shape emitted by `tool_call` events. No-op on non-devtools names.
+    const toolName = (0, util_1.canonicalizeCodexToolName)(rawToolName);
+    const inputSize = utf8Bytes(inputRaw);
+    // Map Codex tool name → Claude classifier vocab (so the shared classifier's
+    // keyword logic + tool-bucket booleans work).
+    //
+    // ALSO used as the `tools` map key — without this, every Codex session
+    // shipped `session_analytics.tools["exec_command" | "apply_patch" |
+    // "read_file" | "web_search" | "web_fetch" | "update_plan"]`, while the
+    // live `tool_call` events from `hooks/track-action.ts` ship
+    // `tool_name: "Bash"` (via `normalizeCodexToolName`) for the SAME logical
+    // shell call. Cross-event-type backend joins (per-tool aggregates ↔
+    // per-call tool_call events) broke on Codex sessions because the names
+    // never matched. Same fix aligns Codex `session_analytics.tools` with
+    // Claude `session_analytics.tools` so cross-client aggregations on
+    // `tools["Bash"]` / `tools["Read"]` / etc. include both sources. Devtools
+    // / sub-agent / unknown tool names pass through unchanged.
+    const claudeAlias = toolName === "apply_patch"
+        ? "Edit"
+        : toolName === "exec_command" || toolName === "Bash"
+            ? "Bash"
+            : toolName === "update_plan"
+                ? "TodoWrite"
+                : toolName === "read_file"
+                    ? "Read"
+                    : toolName === "web_search"
+                        ? "WebSearch"
+                        : toolName === "web_fetch"
+                            ? "WebFetch"
+                            : toolName;
+    (0, classifier_1.applyToolBucketFlags)(acc.toolBuckets, claudeAlias);
+    // Track call_id → wire-vocab tool_name for the output branch's bucket
+    // lookup. Storing `claudeAlias` here (not raw `toolName`) keeps
+    // `acc.tools[key]` writes from `processToolCallOutput` on the same key
+    // that `processToolCall`'s input write used — without this the output
+    // bytes would land in a `tools["exec_command"]` slot that the input
+    // write never created, splitting input/output across two map entries.
+    if (toolName.length > 0 && callId.length > 0) {
+        acc.callIdToToolName[callId] = claudeAlias;
+    }
+    bumpToolInputSize(acc.tools, claudeAlias, inputSize);
+    // MCP server extraction — handles BOTH `mcp__<server>__<tool>` (Claude wire
+    // shape, kept for forward-compat) AND bare `bdt_*` / `ndt_*` / `bedt_*`
+    // (Codex rollout shape; the dominant case in practice).
+    const mcpServer = (0, util_1.extractCodexMcpServer)(toolName);
+    if (mcpServer !== null) {
+        acc.usesMcp = true;
+        // applyToolBucketFlags only sets the mcp bucket for the `mcp__*` shape —
+        // OR-set it here so classifyTurn sees a consistent signal regardless of surface.
+        acc.toolBuckets.mcp = true;
+        bumpToolInputSize(acc.mcpServers, mcpServer, inputSize);
+    }
+    const cat = (0, classifier_2.classifyCodexToolName)(toolName);
+    if (cat === "research") {
+        if (toolName === "web_search") {
+            acc.usesWebSearch = true;
+        }
+        if (toolName === "web_fetch") {
+            acc.usesWebFetch = true;
+        }
+    }
+    // Sub-agent detection — Codex's `multi_agent_v1` namespace exposes
+    // `spawn_agent` (with arguments.agent_type ∈ {explorer, worker, default,
+    // custom}). The two coordination tools `wait_agent` / `close_agent` are
+    // tracked under their bare names in `tools[*]` like any other function_call
+    // — they're not per-sub-agent buckets. Only `spawn_agent` populates the
+    // `subAgents[agent_type]` map (Claude-parity `Agent`/`Task.input.subagent_type`).
+    // Namespace-guarded sub-agent detection. Codex's `multi_agent_v1`
+    // namespace exclusively owns `spawn_agent` / `wait_agent` / `close_agent`.
+    // A third-party MCP server could legally expose its own tool named
+    // `spawn_agent` under a different namespace (e.g. `mcp__custom-orchestrator`);
+    // we should NOT route THAT into sub_agents. Legacy fallback: 0.131-alpha
+    // rollouts omit the namespace field entirely → fall back to name-only
+    // detection (the dominant case for IronBee users today).
+    const isMultiAgentNs = namespace === "multi_agent_v1"
+        || namespace === undefined // legacy / missing field — name-only fallback
+        || namespace === ""; // some Codex versions emit "" instead of omitting
+    if (toolName === "spawn_agent" && isMultiAgentNs) {
+        let agentType = null;
+        try {
+            const obj = JSON.parse(inputRaw || "{}");
+            if (obj !== null && typeof obj === "object") {
+                const t = obj.agent_type;
+                if (typeof t === "string" && t.length > 0) {
+                    agentType = t;
+                }
+            }
+        }
+        catch { /* ignore — malformed arguments */ }
+        if (agentType !== null) {
+            bumpToolInputSize(acc.subAgents, agentType, inputSize);
+            acc.usesSubAgent = true;
+            acc.toolBuckets.task = true;
+            if (callId.length > 0) {
+                acc.callIdToSubAgentType[callId] = agentType;
+            }
+        }
+    }
+    // Bash: classify subcommand + first-token binary. Only function_call carries
+    // Bash; custom_tool_call is apply_patch-only, so the JSON parse will fail
+    // harmlessly there.
+    if (toolName === "exec_command" || toolName === "Bash") {
+        const bashCmd = (() => {
+            try {
+                const obj = JSON.parse(inputRaw || "{}");
+                if (obj !== null && typeof obj === "object") {
+                    const cmd = obj.cmd
+                        ?? obj.command;
+                    if (typeof cmd === "string") {
+                        return cmd;
+                    }
+                }
+            }
+            catch { /* ignore */ }
+            return "";
+        })();
+        // Reuse `extractBashBinary` from `clients/codex/util.ts` so the
+        // `bash_binaries` aggregate key matches the per-event
+        // `tool_call.tool_input.binary` value byte-for-byte. Without this,
+        // `/usr/bin/git status` shipped `tool_input.binary="git"` (path
+        // stripped) AND `bash_binaries["/usr/bin/git"]` (raw token) on the
+        // same wire payload — backend couldn't join per-event labels to the
+        // session-level aggregate. Same string source, two divergent keys.
+        const bin = (0, util_1.extractBashBinary)(bashCmd) || "";
+        if (bin) {
+            bumpToolInputSize(acc.bashBinaries, bin, inputSize);
+            // Remember which binary this call_id ran so processToolCallOutput
+            // can mirror outBytes to the same bashBinaries bucket. Without
+            // this, every binary's output_size stays at 0.
+            if (callId.length > 0) {
+                acc.callIdToBashBinary[callId] = bin;
+            }
+            // Privacy-safe subcommand — emits `<binary> <subcommand>` only
+            // for known multi-subcommand CLIs (git/npm/cargo/...) AND when
+            // the second token has a safe identifier shape. Otherwise just
+            // the binary name; raw arguments NEVER reach the wire.
+            const sub = extractBashSubcommand(bashCmd);
+            if (sub) {
+                acc.bashSubcommands[sub] = (acc.bashSubcommands[sub] ?? 0) + 1;
+            }
+            const bc = (0, classifier_1.emptyBashCmdFlags)();
+            (0, classifier_1.applyBashCmdFlags)(bc, bashCmd);
+            acc.bashFlags.test = acc.bashFlags.test || bc.test;
+            acc.bashFlags.build = acc.bashFlags.build || bc.build;
+            acc.bashFlags.install = acc.bashFlags.install || bc.install;
+            acc.bashFlags.git = acc.bashFlags.git || bc.git;
+        }
+    }
+    // Edit→Bash→Edit retry detection. `acc.retries` is the session-level
+    // count (raw retry events); `currentTurnHadEdit` / `currentTurnHadRetry`
+    // are per-turn flags that drive Claude-parity COUNTS on
+    // `turns.with_retry` / `turns.one_shot` (folded by closeCurrentTurnIfAny
+    // on each new task_started + at finalize).
+    if (toolName === "apply_patch") {
+        acc.currentTurnHadEdit = true;
+        if (acc.sawEditPendingBash && acc.sawBashAfterEdit) {
+            acc.retries += 1;
+            acc.currentTurnHadRetry = true;
+            acc.sawEditPendingBash = true;
+            acc.sawBashAfterEdit = false;
+        }
+        else {
+            acc.sawEditPendingBash = true;
+            acc.sawBashAfterEdit = false;
+        }
+    }
+    else if (toolName === "exec_command" || toolName === "Bash") {
+        if (acc.sawEditPendingBash) {
+            acc.sawBashAfterEdit = true;
+        }
+    }
+    // apply_patch → code_changes derivation. custom_tool_call passes the body
+    // directly via the override; function_call routes through extractApplyPatchBody.
+    //
+    // LAZY-COMMIT: parse here but STASH in `pendingPatchEntries[callId]`
+    // rather than committing to code_changes. The authoritative success
+    // signal is `event_msg.patch_apply_end.success` (paired by call_id) —
+    // commit only when that fires with success=true. Without lazy-commit,
+    // a rejected apply_patch (e.g. "verification failed: Failed to find
+    // expected lines") would still inflate `lines_added` / `lines_removed`
+    // / `files_modified` / `languages` for code that never landed on disk.
+    if (toolName === "apply_patch") {
+        const body = applyPatchBodyOverride
+            ?? (0, apply_patch_1.extractApplyPatchBody)(inputRaw || "{}");
+        if (body !== null && callId.length > 0) {
+            let files = [];
+            try {
+                files = (0, apply_patch_1.parseApplyPatchBody)(body);
+            }
+            catch {
+                files = [];
+            }
+            if (files.length > 0) {
+                acc.pendingPatchEntries[callId] = files;
+            }
+        }
+    }
+}
+/** Commit a single apply_patch invocation's parsed entries into the final
+ *  code_changes aggregates. Called when `patch_apply_end.success === true`
+ *  AND defensively at end-of-walker for any still-pending entries (legacy
+ *  rollouts without patch_apply_end / mid-write truncation). */
+function commitPatchEntries(acc, entries) {
+    for (const f of entries) {
+        acc.fileChangeCounts[f.path] = (acc.fileChangeCounts[f.path] ?? 0) + 1;
+        acc.linesAdded += f.linesAdded;
+        acc.linesRemoved += f.linesRemoved;
+        const lang = languageFromPath(f.path);
+        if (lang) {
+            acc.languages[lang] = (acc.languages[lang] ?? 0) + 1;
+        }
+    }
+}
+/**
+ * Shared `function_call_output` / `custom_tool_call_output` handler — attributes
+ * the response bytes (and any error) to the originating tool via the
+ * `callIdToToolName` map. Falls back to a sentinel `[orphan]` bucket when the
+ * call_id was never seen — defensive only; the bucket should stay at 0 in
+ * well-formed rollouts.
+ */
+function processToolCallOutput(acc, callId, output) {
+    const outBytes = utf8Bytes(output ?? "");
+    const { isError, category } = classifyOutputError(output);
+    // Wire-order guard: `mcp_tool_call_end` fires BEFORE function_call_output
+    // for MCP calls (verified Codex 0.135). If this output's call_id was
+    // already recorded as an MCP error there, suppress the error increment
+    // here to prevent double-counting. Output bytes are still attributed
+    // normally below.
+    const alreadyMcpErrored = acc.mcpErrorRecordedCallIds.has(callId);
+    const effectiveIsError = isError && !alreadyMcpErrored;
+    if (effectiveIsError) {
+        acc.toolErrors += 1;
+        if (category !== null) {
+            acc.toolErrorCategories[category] = (acc.toolErrorCategories[category] ?? 0) + 1;
+        }
+        // Mark this call_id in the same set the mcp_tool_call_end branch
+        // uses so the symmetric guard there (reverse-wire-order case) can
+        // skip via call-id match instead of the broken tool-name-scoped
+        // check. Without this, the reverse-order protection relied on a
+        // tool-NAME-scoped guard that silently dropped every legitimate
+        // subsequent error on the same MCP tool after the first.
+        acc.mcpErrorRecordedCallIds.add(callId);
+        // Note: `interruptionCount` is sourced EXCLUSIVELY from
+        // `event_msg.turn_aborted` (the canonical Codex interrupt signal —
+        // verified across all 2026/* sessions). The `user_rejected` output
+        // pattern is retained for category labeling, but no longer doubles
+        // as an interruption signal — that risked double-counting on
+        // sessions where both fire (rare today but defensive against
+        // future Codex schema additions).
+    }
+    const key = acc.callIdToToolName[callId] ?? ORPHAN_OUTPUT_BUCKET;
+    addToolOutputBytes(acc.tools, key, outBytes);
+    if (effectiveIsError) {
+        acc.tools[key].errors += 1;
+    }
+    // Mirror outBytes to the matching sub-buckets so per-server / per-binary
+    // output_size lines up with the per-tool view. Without this, mcp_servers[*]
+    // and bash_binaries[*] would only ever show input bytes (every call
+    // populates input on processToolCall, but output here was tools-only).
+    const mcpServer = (0, util_1.extractCodexMcpServer)(key);
+    if (mcpServer !== null) {
+        addToolOutputBytes(acc.mcpServers, mcpServer, outBytes);
+        if (effectiveIsError) {
+            acc.mcpServers[mcpServer].errors += 1;
+        }
+    }
+    const bashBinary = acc.callIdToBashBinary[callId];
+    if (bashBinary !== undefined) {
+        addToolOutputBytes(acc.bashBinaries, bashBinary, outBytes);
+        if (effectiveIsError) {
+            acc.bashBinaries[bashBinary].errors += 1;
+        }
+    }
+    const subAgentType = acc.callIdToSubAgentType[callId];
+    if (subAgentType !== undefined) {
+        addToolOutputBytes(acc.subAgents, subAgentType, outBytes);
+        if (effectiveIsError) {
+            acc.subAgents[subAgentType].errors += 1;
+        }
+    }
+    // apply_patch failure fallback: if patch_apply_end never arrived (or
+    // arrives AFTER this output line for some rollout shapes) but the output
+    // text classified as `edit_failed`, drop the stashed PatchFileEntry[]
+    // — same effect as `patch_apply_end.success: false`. Primary path is
+    // still patch_apply_end (more authoritative + handles silent failures);
+    // this is the secondary safety net.
+    if (isError && category === "edit_failed") {
+        delete acc.pendingPatchEntries[callId];
+    }
+}
+/**
+ * Sentinel key used when a `function_call_output` / `custom_tool_call_output`
+ * arrives for a `call_id` we never saw in a corresponding tool-call event.
+ * Should stay at 0 in well-formed rollouts; non-zero counts here usually point
+ * at a Codex schema change (new response_item type we're not parsing) or
+ * mid-session truncation in the test harness.
+ */
+const ORPHAN_OUTPUT_BUCKET = "[orphan]";
+/**
+ * Close the current task_started turn — fold its per-turn flags into the
+ * closed-turn aggregates. Called on every NEW `task_started` event (to close
+ * the previous turn) AND at finalization (to close the in-flight last turn).
+ * No-op when no turn has been opened yet (first call before any task_started).
+ */
+function closeCurrentTurnIfAny(acc) {
+    // Skip when no turn was open AND no flags accumulated — first
+    // `task_started` of the session has nothing to close. But on a truncated
+    // rollout (no `task_started` at all, just orphan tool calls), the flags
+    // may have accumulated against the implicit "turn 0"; fold those into
+    // the aggregates so `category_breakdown.turns_with_edit` / `turns.one_shot`
+    // / `turns.with_retry` reflect real edits even on degenerate rollouts.
+    if (acc.turnCount === 0 && !acc.currentTurnHadEdit && !acc.currentTurnHadRetry) {
+        return;
+    }
+    if (acc.currentTurnHadEdit) {
+        acc.turnsWithEdit += 1;
+    }
+    if (acc.currentTurnHadRetry) {
+        acc.turnsWithRetry += 1;
+    }
+    // Claude-parity `one_shot`: the turn produced edits AND had no retry.
+    // Bash-only / read-only turns don't count.
+    if (acc.currentTurnHadEdit && !acc.currentTurnHadRetry) {
+        acc.oneShotTurns += 1;
+    }
+    acc.currentTurnHadEdit = false;
+    acc.currentTurnHadRetry = false;
+    // Reset the Edit→Bash→Edit state-machine flags too. These are
+    // session-level scratch state that drives `currentTurnHadRetry`, and
+    // without per-turn reset, an Edit in turn 1 + Bash + Edit in turn 2 (a
+    // legitimate fresh prompt with a build-test-fix shape) is mis-classified
+    // as a retry of turn 1's work. Same logical scope as `currentTurnHad*`,
+    // so they reset together.
+    acc.sawEditPendingBash = false;
+    acc.sawBashAfterEdit = false;
+}
+function projectCodexDelta(input) {
+    const { sessionId, projectName, userEmail, lines, endReason, isFinal } = input;
+    const acc = freshAccumulator();
+    for (const ln of lines) {
+        try {
+            processLine(acc, ln);
+        }
+        catch (e) {
+            // Claude-parity process_errors capture: a single malformed line
+            // (schema drift, corrupt JSON post-parse, unexpected payload
+            // shape) is recorded with dedup + sample_context but does NOT
+            // crash the projection. sample_context = top-level type +
+            // payload.type for downstream diagnostics.
+            const payloadType = (typeof ln.payload === "object" && ln.payload !== null
+                && typeof ln.payload.type === "string")
+                ? ln.payload.type
+                : "(unknown)";
+            (0, errors_1.recordProcessError)(acc.processErrors, e, ln.timestamp ?? new Date(0).toISOString(), `${ln.type}.${payloadType}`);
+        }
+    }
+    const delta = buildSessionAnalytics(acc, sessionId, projectName, userEmail, endReason, isFinal === true);
+    return { delta };
+}
+/**
+ * Per-line walker body, extracted so the outer loop's try/catch can wrap
+ * a single function call. Any thrown error here lands in `process_errors`
+ * via `recordProcessError`, and projection continues with the next line —
+ * Claude-parity defensive posture.
+ */
+function processLine(acc, ln) {
+    const ts = ln.timestamp;
+    if (acc.firstSeenTs === null) {
+        acc.firstSeenTs = ts;
+    }
+    acc.lastSeenTs = ts;
+    // Idle attribution (Claude-parity): the gap BEFORE a user_message
+    // event is attributed to "user thinking / away" idle time; every
+    // other gap is active (agent + tools + model time). We compute the
+    // gap here against the prior line's timestamp, then advance the
+    // cursor unconditionally. Negative / zero gaps are ignored (line
+    // ordering should be monotonic in practice).
+    const lnMs = new Date(ts).getTime();
+    if (acc.priorLineTsMs !== null && Number.isFinite(lnMs)
+        && (0, types_2.isEventMsg)(ln, "user_message")) {
+        const gap = lnMs - acc.priorLineTsMs;
+        if (gap > 0) {
+            acc.idleMs += gap;
+        }
+    }
+    if (Number.isFinite(lnMs)) {
+        acc.priorLineTsMs = lnMs;
+    }
+    // session_meta — set model + record session start
+    if (ln.type === "session_meta") {
+        const meta = ln.payload;
+        if (acc.sessionMetaTs === null) {
+            acc.sessionMetaTs = meta.timestamp ?? ts;
+        }
+        if (meta.model_provider === "openai") {
+            acc.currentModel = "gpt-5.5";
+        }
+        // Capture session_meta.source (surface origin) + system-prompt bytes
+        // for forward-compat — wire emission deferred (see SessionAccumulator
+        // docstrings for sessionSource / systemPromptBytes).
+        if (acc.sessionSource === null && typeof meta.source === "string" && meta.source.length > 0) {
+            acc.sessionSource = meta.source;
+        }
+        const baseText = meta.base_instructions?.text;
+        if (typeof baseText === "string" && acc.systemPromptBytes === 0) {
+            acc.systemPromptBytes = utf8Bytes(baseText);
+        }
+        return;
+    }
+    if (ln.type === "turn_context") {
+        const tc = ln.payload;
+        if (typeof tc.model === "string" && tc.model.length > 0) {
+            // Strip bracketed runtime suffixes (e.g. `gpt-5.5-codex[1m]` →
+            // `gpt-5.5-codex`) so `session_analytics.models[<key>]` map keys
+            // ship the canonical id consistent with `api_request.model`
+            // (api-request.ts strips identically at its own capture site).
+            // Without this, cross-event joins on `model` see distinct
+            // strings for the same physical model.
+            acc.currentModel = tc.model.replace(/\[[^\]]*\]/g, "").trim();
+        }
+        return;
+    }
+    // ── event_msg variants ──────────────────────────────────────────────
+    if ((0, types_2.isEventMsg)(ln, "task_started")) {
+        const _p = ln.payload;
+        void _p;
+        // Close the PRIOR turn (if any) before opening the new one — so
+        // `turnsWithRetry` / `oneShotTurns` accumulate correctly across
+        // multi-turn sessions. The in-flight last turn is closed in
+        // buildSessionAnalytics.
+        closeCurrentTurnIfAny(acc);
+        acc.turnCount += 1;
+        return;
+    }
+    if ((0, types_2.isEventMsg)(ln, "user_message")) {
+        const p = ln.payload;
+        const msg = p.message ?? "";
+        acc.userMsgCount += 1;
+        acc.userMsgBytes += utf8Bytes(msg);
+        // Symmetric guard with localDate / localWeekday below — skip the
+        // whole user_msg's time-bucket attribution when the timestamp is
+        // malformed (rather than silently dumping it into hour-0 while the
+        // date/weekday buckets correctly drop it).
+        const hr = localHour(ts);
+        if (hr !== null) {
+            const hrKey = String(hr);
+            acc.userMsgsByHour[hrKey] = (acc.userMsgsByHour[hrKey] ?? 0) + 1;
+        }
+        const d = localDate(ts);
+        if (d) {
+            acc.userMsgsByDate[d] = (acc.userMsgsByDate[d] ?? 0) + 1;
+        }
+        const w = localWeekday(ts);
+        if (w) {
+            acc.userMsgsByWeekday[w] = (acc.userMsgsByWeekday[w] ?? 0) + 1;
+        }
+        // Response-time histogram: time elapsed between the previous
+        // agent reply and this user prompt — proxy for "how quickly did
+        // the human come back to the conversation."
+        const userMs = new Date(ts).getTime();
+        if (acc.lastAgentMessageMs !== null && Number.isFinite(userMs)) {
+            const bucket = responseTimeBucket(userMs - acc.lastAgentMessageMs);
+            if (bucket !== null) {
+                acc.responseTimeBuckets[bucket] = (acc.responseTimeBuckets[bucket] ?? 0) + 1;
+            }
+        }
+        // Merge keyword flags from this user message (session-level OR).
+        const kw = (0, classifier_1.extractUserMsgKeywords)(msg);
+        acc.kw.debug = acc.kw.debug || kw.debug;
+        acc.kw.feature = acc.kw.feature || kw.feature;
+        acc.kw.refactor = acc.kw.refactor || kw.refactor;
+        acc.kw.brainstorm = acc.kw.brainstorm || kw.brainstorm;
+        acc.kw.research = acc.kw.research || kw.research;
+        acc.kw.file_pattern = acc.kw.file_pattern || kw.file_pattern;
+        acc.kw.script_pattern = acc.kw.script_pattern || kw.script_pattern;
+        acc.kw.url = acc.kw.url || kw.url;
+        return;
+    }
+    if ((0, types_2.isEventMsg)(ln, "agent_message")) {
+        const _p = ln.payload;
+        void _p;
+        // Mark the wall-clock at which the agent finished a VISIBLE reply
+        // so the next user_message can compute its response_time_buckets
+        // gap. Stays here (not on token_count) because the gap we want is
+        // "after the agent stopped TALKING, how long until the user came
+        // back" — tool-only API calls don't count.
+        const ms = new Date(ts).getTime();
+        if (Number.isFinite(ms)) {
+            acc.lastAgentMessageMs = ms;
+        }
+        return;
+    }
+    if ((0, types_2.isEventMsg)(ln, "token_count")) {
+        const p = ln.payload;
+        const last = p.info?.last_token_usage;
+        if (!last) {
+            return;
+        }
+        // ONE token_count event per API call — including the ones whose
+        // assistant message contained only function_calls (no visible
+        // text). Claude-parity: `turns.assistant_count` and
+        // `models[*].count` are API-call counts, NOT text-response counts.
+        // (event_msg.agent_message only fires when the assistant emits
+        // visible text, so it undercounts tool-heavy responses ~5x in
+        // practice.) `assistantTurnIndex` follows the same semantic so
+        // context_tokens bucketing aligns 1:1 with API calls.
+        acc.assistantMsgCount += 1;
+        acc.assistantTurnIndex += 1;
+        // Anthropic/Claude convention: `usage.input_tokens` is EXCLUSIVE of
+        // cached tokens (cache_read_tokens shipped as a separate field so
+        // `input + cache_read = total context`). Codex/OpenAI's payload uses
+        // the inverse — `last.input_tokens` is INCLUSIVE of cached. Subtract
+        // here so the wire shape stays cross-client comparable; without this,
+        // `input + cache_read` would double-count the cached portion on every
+        // Codex session (e.g. 13.8M + 13.3M = 27.1M for a real session whose
+        // actual context churn was ~530K fresh + 13.3M reuse).
+        const freshInput = Math.max(0, last.input_tokens - last.cached_input_tokens);
+        acc.inputTokens += freshInput;
+        // OpenAI's Responses API rollout payload uses `output_tokens` as the
+        // BILLED output total (already includes `reasoning_output_tokens`
+        // as a subset — verified across the real corpus: `total_tokens ===
+        // input_tokens + output_tokens` in every token_count event sampled).
+        // Adding `reasoning_output_tokens` separately here would double-count
+        // reasoning into `session_analytics.usage.output_tokens` and
+        // `models[*].output_tokens` on the wire. `acc.reasoningTokens` keeps
+        // the subset breakdown for any future per-stream split, but the
+        // session-level total stays single-sourced from `output_tokens`.
+        acc.outputTokens += last.output_tokens;
+        acc.cacheReadTokens += last.cached_input_tokens;
+        acc.reasoningTokens += last.reasoning_output_tokens;
+        const cost = (0, pricing_1.computeCodexCost)(acc.currentModel, last);
+        acc.costUsd += cost;
+        // Per-model tokens + count (same fresh-exclusive convention, same
+        // no-double-counting rule for reasoning).
+        if (!acc.models[acc.currentModel]) {
+            acc.models[acc.currentModel] = emptyModelUsage();
+        }
+        acc.models[acc.currentModel].count += 1;
+        acc.models[acc.currentModel].input_tokens += freshInput;
+        acc.models[acc.currentModel].output_tokens += last.output_tokens;
+        acc.models[acc.currentModel].cache_read_tokens += last.cached_input_tokens;
+        acc.models[acc.currentModel].cost_usd += cost;
+        // Context tokens — point-in-time size of THIS API call's prompt window.
+        // Codex exposes two `total_tokens` fields per token_count event:
+        //   - `total_token_usage.total_tokens`: CUMULATIVE session total
+        //     (sums every prior call's input+output → grows ~N² over a long
+        //     session; meaningless as a "context size" signal).
+        //   - `last_token_usage.total_tokens`: per-call total = input +
+        //     output + reasoning + cached_input — the actual prompt size
+        //     for the most recent API response.
+        // Use the per-call value (matches Claude's
+        // `msgInput + msgCacheCreation + msgCacheRead` per-assistant-line
+        // derivation) so `latest` / `peak` / bucket samples reflect real
+        // context-window growth, not cumulative billing.
+        //
+        // Use `last.input_tokens` rather than `last.total_tokens` — the latter
+        // is `input + output [+ reasoning]` which would over-state context
+        // window size by including the model's RESPONSE bytes. Claude's
+        // analog (`msgInput + msgCacheCreation + msgCacheRead`) excludes
+        // output; same exclusion here. On OpenAI's payload `input_tokens`
+        // is INCLUSIVE of `cached_input_tokens`, so this single field already
+        // captures "total bytes the model saw as input on this call."
+        const ctxTokens = last.input_tokens;
+        if (ctxTokens > 0) {
+            acc.contextLatest = ctxTokens;
+            if (ctxTokens > acc.contextPeak) {
+                acc.contextPeak = ctxTokens;
+            }
+            // Per-Claude-parity turn-index bucketing. `token_count` fires
+            // AFTER `agent_message`, so `assistantTurnIndex` already points
+            // at the bucket this sample belongs to. Clamp to 1 for the rare
+            // pre-first-agent_message token_count (e.g. system-prompt-only
+            // accounting line).
+            const bucketKey = contextTurnBucket(Math.max(1, acc.assistantTurnIndex));
+            const slot = acc.contextTokensBuckets[bucketKey]
+                ?? { sum: 0, count: 0 };
+            slot.sum += ctxTokens;
+            slot.count += 1;
+            acc.contextTokensBuckets[bucketKey] = slot;
+        }
+        return;
+    }
+    if ((0, types_2.isEventMsg)(ln, "turn_aborted")) {
+        acc.interruptionCount += 1;
+        // Discard any partial work the aborted turn accumulated so it doesn't
+        // get folded into `turns_with_edit` / `turns_with_retry` / `oneShotTurns`
+        // when the NEXT `task_started` closes it. A turn that the user
+        // interrupted shouldn't count as a successful edit cycle.
+        // turnCount is NOT decremented — the aborted turn is still a turn
+        // (just one that didn't complete its work).
+        acc.currentTurnHadEdit = false;
+        acc.currentTurnHadRetry = false;
+        acc.sawEditPendingBash = false;
+        acc.sawBashAfterEdit = false;
+        // Drop any pending apply_patch entries whose patch_apply_end was
+        // preempted by the abort. Without this clear, the end-of-walker
+        // defensive fold (line ~1370) would commit them as successful →
+        // `code_changes.lines_added/removed/files_modified` would inflate
+        // with edits the user explicitly cancelled. Each pending entry by
+        // definition lost its outcome event, so dropping them all is the
+        // conservative call (matches `patch_apply_end.success === false`
+        // semantic).
+        acc.pendingPatchEntries = {};
+        return;
+    }
+    if ((0, types_2.isEventMsg)(ln, "task_complete")) {
+        // Codex's authoritative turn-completion signal — duration_ms is the
+        // host-measured wall-clock for the turn (including tool execution),
+        // time_to_first_token_ms is the latency to first model token.
+        // Capture for future wire emission (deferred per accumulator
+        // docstrings). Empirically 65 events / 69 rollouts; turns aborted
+        // mid-flight produce turn_aborted INSTEAD, so this is a clean
+        // success-path signal.
+        const p = ln.payload;
+        if (typeof p.duration_ms === "number" && Number.isFinite(p.duration_ms)) {
+            acc.turnDurationMsTotal += p.duration_ms;
+            acc.turnDurationCount += 1;
+        }
+        if (typeof p.time_to_first_token_ms === "number" && Number.isFinite(p.time_to_first_token_ms)) {
+            acc.firstTokenMsTotal += p.time_to_first_token_ms;
+            acc.firstTokenMsCount += 1;
+        }
+        return;
+    }
+    if ((0, types_2.isEventMsg)(ln, "mcp_tool_call_end")) {
+        // Authoritative MCP tool outcome — fires per MCP function_call,
+        // carrying the Rust `Result<Ok|Err>` from the MCP server.
+        //
+        // EMPIRICAL WIRE ORDER (verified Codex 0.135.0 round-12 audit):
+        //   function_call         T0
+        //   mcp_tool_call_end     T0 + Δ   ← FIRES BEFORE OUTPUT
+        //   function_call_output  T0 + Δ + ε
+        //
+        // The cancellation output text ("user cancelled MCP tool call") is
+        // NOT currently matched by `classifyOutputError` — so the output
+        // branch silently classifies as non-error, and we don't double-count
+        // today by accident. To make this robust against future Codex output
+        // text changes (e.g. adding "[Request interrupted by user]" wrapper),
+        // we mark the call_id in `mcpErrorRecordedCallIds` here, and
+        // `processToolCallOutput` skips its error increment if the cid is
+        // in the set. (Output bytes are still attributed normally.)
+        const p = ln.payload;
+        // Defensive: Codex Rust `Result::Err` is typed as `string` today; if a
+        // future Codex version emits a struct variant, fall through gracefully.
+        const errMsg = typeof p.result?.Err === "string"
+            ? p.result.Err
+            : undefined;
+        const cid = p.call_id ?? "";
+        if (errMsg !== undefined && cid.length > 0) {
+            const toolName = acc.callIdToToolName[cid];
+            // Symmetric guard with `processToolCallOutput` — both branches
+            // check `mcpErrorRecordedCallIds.has(cid)` to avoid double-
+            // counting the SAME call_id across reverse wire orderings.
+            // Earlier this guard was tool-NAME-scoped (`tools[toolName].errors > 0`),
+            // which silently dropped every legitimate subsequent MCP error
+            // with a different call_id on the same tool name (e.g., two
+            // separate `bdt_navigation_go-to` cancellations in one session
+            // → only the first one counted). Wire impact: under-counted
+            // `errors.tool_errors_total`, `tools[*].errors`, and
+            // `mcp_servers[*].errors` for any session with multi-call MCP
+            // errors. Call-id-scoped guard fixes the under-count while
+            // preserving reverse-order double-counting protection.
+            const alreadyIncremented = acc.mcpErrorRecordedCallIds.has(cid);
+            if (toolName !== undefined && !alreadyIncremented) {
+                acc.toolErrors += 1;
+                // Categorize as `user_rejected` for cancellation, `other` for
+                // remaining MCP-side errors (transport, server crash, etc).
+                const cat = /cancel/i.test(errMsg) ? "user_rejected" : "other";
+                acc.toolErrorCategories[cat] = (acc.toolErrorCategories[cat] ?? 0) + 1;
+                if (acc.tools[toolName]) {
+                    acc.tools[toolName].errors += 1;
+                }
+                // Mirror to per-server bucket — same pattern as processToolCallOutput.
+                const mcpServer = (0, util_1.extractCodexMcpServer)(toolName)
+                    ?? (typeof p.invocation?.server === "string" ? p.invocation.server : null);
+                if (mcpServer !== null && acc.mcpServers[mcpServer]) {
+                    acc.mcpServers[mcpServer].errors += 1;
+                }
+                // Mark the cid so the later function_call_output's error
+                // classifier doesn't double-count.
+                acc.mcpErrorRecordedCallIds.add(cid);
+            }
+        }
+        return;
+    }
+    if ((0, types_2.isEventMsg)(ln, "patch_apply_end")) {
+        // Authoritative apply_patch outcome — pairs with the originating
+        // custom_tool_call via call_id. On success, commit the eagerly-
+        // parsed PatchFileEntry[] into code_changes. On failure, drop the
+        // entries (they would otherwise inflate lines_added/removed for a
+        // patch that never landed on disk).
+        const p = ln.payload;
+        const cid = p.call_id ?? "";
+        if (cid.length > 0) {
+            const pending = acc.pendingPatchEntries[cid];
+            if (pending !== undefined) {
+                if (p.success) {
+                    commitPatchEntries(acc, pending);
+                }
+                // On failure: drop. delete() runs either way so end-of-walker
+                // doesn't double-commit.
+                delete acc.pendingPatchEntries[cid];
+            }
+        }
+        return;
+    }
+    // ── response_item variants ──────────────────────────────────────────
+    if ((0, types_2.isResponseItem)(ln, "function_call")) {
+        const p = ln.payload;
+        // Pass `namespace` (live wire field on Codex 0.135+) so processToolCall
+        // can authoritatively route `spawn_agent` only when it's truly
+        // `multi_agent_v1` (vs a future third-party MCP server's same-named tool).
+        processToolCall(acc, p.name ?? "", p.arguments ?? "", p.call_id, /* applyPatchBodyOverride */ null, p.namespace);
+        return;
+    }
+    if ((0, types_2.isResponseItem)(ln, "custom_tool_call")) {
+        const p = ln.payload;
+        // Live-verified on Codex 0.135.x: apply_patch is the only emitter of
+        // `custom_tool_call`. `input` carries the RAW patch text (no JSON wrapper).
+        // Pass it as the `applyPatchBodyOverride` so the helper skips the JSON
+        // parse path that `function_call` uses.
+        processToolCall(acc, p.name ?? "", p.input ?? "", p.call_id, p.input ?? null);
+        return;
+    }
+    if ((0, types_2.isResponseItem)(ln, "function_call_output")) {
+        const p = ln.payload;
+        processToolCallOutput(acc, p.call_id, p.output);
+        return;
+    }
+    if ((0, types_2.isResponseItem)(ln, "custom_tool_call_output")) {
+        const p = ln.payload;
+        processToolCallOutput(acc, p.call_id, p.output);
+        return;
+    }
+    // Codex web search — emitted as `response_item.web_search_call`, NOT as a
+    // `function_call name="web_search"`. Live-verified: 80+ web_search_call
+    // events in a single session, 0 function_call(web_search). Without this
+    // branch every Codex web search ships `uses_web_search: false` and
+    // `tools.WebSearch` map missing — silent data loss. Each web_search_call
+    // is a discrete event (no paired output line; results land in the next
+    // assistant message); input_size = JSON of the action payload (query
+    // string + queries[] when present). Key is `WebSearch` to align with the
+    // Claude-vocab canonicalization in processToolCall — without this the
+    // direct response_item branch would split `web_search` (here) vs
+    // `WebSearch` (function_call path) across two map entries on sessions
+    // that mix both surfaces.
+    if ((0, types_2.isResponseItem)(ln, "web_search_call")) {
+        const p = ln.payload;
+        const inputBytes = utf8Bytes(JSON.stringify(p.action ?? {}));
+        acc.toolCallCount += 1;
+        bumpToolInputSize(acc.tools, "WebSearch", inputBytes);
+        acc.usesWebSearch = true;
+        // Set the shared classifier's search bucket so classifyTurn sees
+        // research/exploration signals correctly.
+        acc.toolBuckets.search = true;
+        return;
+    }
+    // Skill detection — Codex injects a synthetic role=user message
+    // wrapping the SKILL.md body when the agent invokes a skill. The
+    // wire signal is `<skill>\n<name>NAME</name>...` — see
+    // `extractCodexSkillName`. Counted into `acc.skills` with input_size
+    // = the full injected text bytes (the skill prompt entering context).
+    // No output_size — skills don't have a return value the way tools do.
+    if ((0, types_2.isResponseItem)(ln, "message")) {
+        const p = ln.payload;
+        if (p.role === "user") {
+            const skillName = extractCodexSkillName(p.content);
+            if (skillName !== null) {
+                // Bytes = full content[0].text length (the SKILL.md body
+                // entering context, the meaningful cost-attributable signal).
+                let bytes = 0;
+                if (Array.isArray(p.content) && p.content.length > 0) {
+                    const c0 = p.content[0];
+                    if (c0 !== null && typeof c0 === "object") {
+                        const t = c0.text;
+                        if (typeof t === "string") {
+                            bytes = utf8Bytes(t);
+                        }
+                    }
+                }
+                bumpToolInputSize(acc.skills, skillName, bytes);
+                acc.usesSkill = true;
+                acc.toolBuckets.skill = true;
+            }
+        }
+        return;
+    }
+}
+// ─────────────────────────────────────────────────────────────────────────
+// Build wire event
+// ─────────────────────────────────────────────────────────────────────────
+function buildSessionAnalytics(acc, sessionId, projectName, userEmail, endReason, isFinal) {
+    // Detect "no real session data" — happens on empty rollouts. We fall back
+    // to the epoch ISO so downstream Date parsing succeeds, but the hour
+    // derivation must be aware that this is synthetic (otherwise
+    // `localHour(epoch_iso)` returns the user's TZ offset modulo 24 — e.g. 2
+    // in UTC+2, 0 in UTC, breaking cross-machine reproducibility for empty
+    // sessions).
+    const hasRealActivity = acc.sessionMetaTs !== null || acc.firstSeenTs !== null;
+    const firstSeen = acc.sessionMetaTs ?? acc.firstSeenTs ?? new Date(0).toISOString();
+    const lastSeen = acc.lastSeenTs ?? firstSeen;
+    const startMs = new Date(firstSeen).getTime();
+    const endMs = new Date(lastSeen).getTime();
+    const durationMin = Number.isFinite(startMs) && Number.isFinite(endMs)
+        ? Math.max(0, Math.round((endMs - startMs) / 60000))
+        : 0;
+    // Session-level category classification (single TurnCategory bucket
+    // since there's no per-turn classification anymore; backend can derive
+    // a "primary topic" from this).
+    const category = (0, classifier_1.classifyTurn)({
+        user_msg_keywords: acc.kw,
+        tool_buckets: acc.toolBuckets,
+        bash_cmd_flags: acc.bashFlags,
+    });
+    // Defensive end-of-walker fold for apply_patches that had no paired
+    // patch_apply_end signal (legacy Codex rollouts pre-0.131, mid-write
+    // truncation, or any failure to emit the outcome event). Commit any
+    // still-pending entries so we don't silently drop code_changes for
+    // valid edits. patch_apply_end / output-text-error already cleared
+    // the entries for known-failed patches.
+    for (const cid of Object.keys(acc.pendingPatchEntries)) {
+        commitPatchEntries(acc, acc.pendingPatchEntries[cid]);
+    }
+    acc.pendingPatchEntries = {};
+    // Close the LAST in-flight turn before reading aggregates — its
+    // currentTurnHadEdit/Retry flags would otherwise stay un-folded.
+    closeCurrentTurnIfAny(acc);
+    // Claude-parity COUNTS (not 0/1 booleans). For a 5-turn session where
+    // 3 turns had retries and 2 were one-shot edits, this emits
+    // `with_retry: 3, one_shot: 2`. Defensive zero-turn fallback: empty
+    // rollout → both 0.
+    const oneShot = acc.oneShotTurns;
+    const withRetry = acc.turnsWithRetry;
+    const category_breakdown = {};
+    if (acc.turnCount > 0 || acc.assistantMsgCount > 0) {
+        category_breakdown[category] = {
+            turns: Math.max(acc.turnCount, 1),
+            // Claude-parity COUNT (was 0/1). For a session where 3 turns
+            // produced edits and 2 didn't, this emits `turns_with_edit: 3`.
+            turns_with_edit: acc.turnsWithEdit,
+            turns_with_retry: withRetry,
+            total_retries: acc.retries,
+            cost_usd: acc.costUsd,
+        };
+    }
+    // hot_files: top-5 by change_count desc; mirror Claude's tiebreaker
+    // (`topKHotFiles` in merge.ts) so equal-count files have a deterministic
+    // path-alphabetical order — important for diff-against-prior-snapshot.
+    const sortedHot = Object.entries(acc.fileChangeCounts)
+        .sort((a, b) => {
+        if (b[1] !== a[1]) {
+            return b[1] - a[1];
+        }
+        return a[0].localeCompare(b[0]);
+    })
+        .slice(0, 5)
+        .map(([path, change_count]) => ({ path, change_count }));
+    // idle_minutes: sum of gap-before-user_message intervals, rounded to
+    // minutes (Claude-parity — same gap-before-human-user attribution).
+    // active_minutes = duration - idle, clamped >= 0 (defensive against
+    // rounding edges).
+    const idleMin = Math.round(acc.idleMs / 60000);
+    const activeMin = Math.max(0, durationMin - idleMin);
+    const time = {
+        duration_minutes: durationMin,
+        active_minutes: activeMin,
+        idle_minutes: idleMin,
+        // Deterministic 0 when no real activity (firstSeen is the epoch
+        // fallback). Otherwise local-TZ hour. Keeps empty-session output
+        // identical across machines regardless of timezone.
+        // `?? 0` preserves the deterministic-0 fallback for malformed
+        // first/last timestamps (matches the no-activity branch).
+        start_hour: hasRealActivity ? (localHour(firstSeen) ?? 0) : 0,
+        last_activity_hour: hasRealActivity ? (localHour(lastSeen) ?? 0) : 0,
+    };
+    const turns = {
+        user_count: acc.userMsgCount,
+        assistant_count: acc.assistantMsgCount,
+        with_retry: withRetry,
+        one_shot: oneShot,
+    };
+    const usage = {
+        input_tokens: acc.inputTokens,
+        output_tokens: acc.outputTokens,
+        cache_creation_tokens: 0,
+        cache_read_tokens: acc.cacheReadTokens,
+        cost_usd: acc.costUsd,
+    };
+    const userMessages = {
+        count: acc.userMsgCount,
+        size: acc.userMsgBytes,
+        // Raw float — same Claude-parity rationale as bumpToolInputSize.
+        approximated_tokens: acc.userMsgBytes / tokens_1.BYTES_PER_TOKEN,
+    };
+    const codeChanges = {
+        files_modified: Object.keys(acc.fileChangeCounts).length,
+        lines_added: acc.linesAdded,
+        lines_removed: acc.linesRemoved,
+        hot_files: sortedHot,
+        languages: { ...acc.languages },
+    };
+    const errors = {
+        tool_errors_total: acc.toolErrors,
+        tool_error_categories: { ...acc.toolErrorCategories },
+        user_interruptions: acc.interruptionCount,
+    };
+    const userActivity = {
+        response_time_buckets: { ...acc.responseTimeBuckets },
+        messages_by_hour: acc.userMsgsByHour,
+        messages_by_date: acc.userMsgsByDate,
+        messages_by_weekday: acc.userMsgsByWeekday,
+    };
+    // Bucket sum/count → sum/count/avg (avg recomputed here so it stays in
+    // sync with any future merge step that re-aggregates sum/count).
+    const bucketsWithAvg = {};
+    for (const [k, v] of Object.entries(acc.contextTokensBuckets)) {
+        bucketsWithAvg[k] = {
+            sum: v.sum,
+            count: v.count,
+            avg: v.count > 0 ? v.sum / v.count : 0,
+        };
+    }
+    // Filter the defensive `[orphan]` sentinel out of the wire `tools` map
+    // when its `count` AND `errors` are both 0 — `processToolCallOutput`
+    // creates the entry with count=0 when output arrives for an unknown
+    // call_id. If the orphan entry has accumulated errors, we MUST keep it
+    // on the wire — otherwise `Σ wire.tools[*].errors < errors.tool_errors_total`
+    // (orphan errors would be invisible per-tool but counted in the
+    // session total, breaking the invariant). Non-zero count would similarly
+    // signal real activity worth surfacing.
+    const wireTools = {};
+    for (const [k, v] of Object.entries(acc.tools)) {
+        if (k === ORPHAN_OUTPUT_BUCKET && v.count === 0 && v.errors === 0) {
+            continue;
+        }
+        wireTools[k] = v;
+    }
+    const contextTokens = {
+        latest: acc.contextLatest,
+        peak: acc.contextPeak,
+        buckets: bucketsWithAvg,
+    };
+    const processErrors = {
+        has: Object.keys(acc.processErrors).length > 0,
+        items: { ...acc.processErrors },
+    };
+    const toolMeta = {
+        bash_subcommands: Object.keys(acc.bashSubcommands).length > 0 ? { ...acc.bashSubcommands } : undefined,
+        uses_sub_agent: acc.usesSubAgent,
+        uses_skill: acc.usesSkill,
+        uses_mcp: acc.usesMcp,
+        uses_web_search: acc.usesWebSearch,
+        uses_web_fetch: acc.usesWebFetch,
+    };
+    const sessionType = deriveSessionType(category_breakdown, durationMin, acc.userMsgCount, Object.keys(acc.fileChangeCounts).length, sortedHot);
+    return {
+        session_id: sessionId,
+        project_name: projectName,
+        user_email: userEmail,
+        schema_version: types_1.SCHEMA_VERSION,
+        transcript_source: "codex",
+        is_final: isFinal,
+        snapshot_at: new Date().toISOString(),
+        offset: 0,
+        end_reason: endReason,
+        start_time: firstSeen,
+        last_activity_time: lastSeen,
+        time,
+        turns,
+        classification: { category_breakdown, session_type: sessionType },
+        usage,
+        models: acc.models,
+        user_messages: userMessages,
+        tools: wireTools,
+        mcp_servers: acc.mcpServers,
+        skills: acc.skills,
+        sub_agents: acc.subAgents,
+        bash_binaries: acc.bashBinaries,
+        tool_meta: toolMeta,
+        code_changes: codeChanges,
+        errors,
+        user_activity: userActivity,
+        context_tokens: contextTokens,
+        process_errors: processErrors,
+    };
+}
+/**
+ * Heuristic mirrored from Claude's `deriveSessionType` (`analytics/claude/merge.ts`)
+ * so the two clients produce the same labels for equivalent shapes. Order matters —
+ * earlier branches take precedence.
+ */
+function deriveSessionType(categories, durationMin, userCount, filesModified, hotFiles) {
+    const totalTurns = Object.values(categories).reduce((s, c) => s + c.turns, 0);
+    const editTurns = Object.values(categories).reduce((s, c) => s + c.turns_with_edit, 0);
+    const explorationTurns = (categories["exploration"]?.turns ?? 0)
+        + (categories["brainstorming"]?.turns ?? 0);
+    // 1. Quick question
+    if (durationMin < 5 && userCount <= 2 && filesModified === 0) {
+        return "quick_question";
+    }
+    // 2. Exploration-dominant
+    if (totalTurns >= 2 && editTurns === 0) {
+        return "exploration";
+    }
+    if (totalTurns >= 3 && explorationTurns / totalTurns >= 0.6) {
+        return "exploration";
+    }
+    // 3. Iterative refinement — hot_files concentration
+    if (hotFiles.length > 0) {
+        const top = hotFiles[0];
+        const totalChanges = hotFiles.reduce((s, f) => s + f.change_count, 0);
+        if (top.change_count >= 5 && totalChanges > 0 && top.change_count / totalChanges >= 0.5) {
+            return "iterative_refinement";
+        }
+    }
+    // 4. Multi-task
+    if (userCount >= 3) {
+        return "multi_task";
+    }
+    // 5. Single task — has edit
+    if (editTurns > 0) {
+        return "single_task";
+    }
+    return "general";
+}
+//# sourceMappingURL=projection.js.map