@ironbee-ai/cli 0.15.0 → 0.16.0

package/dist/analytics/{projection.js → claude/projection.js}

@@ -24,9 +24,9 @@
  * read-once-locally pattern.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatHexAsUuid = void 0;
 exports.deriveStepId = deriveStepId;
 exports.deriveTurnId = deriveTurnId;
-exports.formatHexAsUuid = formatHexAsUuid;
 exports.deriveSessionAnalyticsEventId = deriveSessionAnalyticsEventId;
 exports.deriveTurnEventId = deriveTurnEventId;
 exports.deriveStepEventId = deriveStepEventId;
@@ -36,31 +36,40 @@ exports.projectDelta = projectDelta;
 exports.projectDeltaInternal = projectDeltaInternal;
 const node_crypto_1 = require("node:crypto");
 const diff_1 = require("diff");
-const logger_1 = require("../lib/logger");
-const types_1 = require("./types");
+const event_1 = require("../../lib/event");
+const logger_1 = require("../../lib/logger");
+const types_1 = require("../shared/types");
 const pricing_1 = require("./pricing");
-const errors_1 = require("./errors");
-const classifier_1 = require("./classifier");
+const errors_1 = require("../shared/errors");
+const classifier_1 = require("../shared/classifier");
 // ─────────────────────────────────────────────────────────────────────────
 // Constants — keep in sync with /insights:332-349 + 651-677 + 651-677
 // ─────────────────────────────────────────────────────────────────────────
+// Kept in cross-client parity with Codex `languageFromPath`
+// (`src/analytics/codex/projection.ts`). The two pipelines feed the same
+// `code_changes.languages` map on the wire — a backend aggregating Claude +
+// Codex sessions sees one key `"TypeScript"` regardless of source, NOT
+// `"TypeScript"` (Codex side) + a silently dropped Claude `.kt` / `.swift`
+// edit. Real corpus: Claude sessions editing `.php` / `.kt` / `.scala` /
+// `.swift` etc. previously emitted zero `languages[...]` entries because the
+// table didn't cover them — silent data loss vs the Codex side. Add new
+// extensions to BOTH tables in lockstep.
 const EXTENSION_TO_LANGUAGE = {
-    ".ts": "TypeScript",
-    ".tsx": "TypeScript",
-    ".js": "JavaScript",
-    ".jsx": "JavaScript",
-    ".py": "Python",
-    ".rb": "Ruby",
-    ".go": "Go",
-    ".rs": "Rust",
-    ".java": "Java",
-    ".md": "Markdown",
-    ".json": "JSON",
-    ".yaml": "YAML",
-    ".yml": "YAML",
-    ".sh": "Shell",
-    ".css": "CSS",
-    ".html": "HTML",
+    ".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",
 };
 const INTERRUPT_MARKER = "[Request interrupted by user";
 // Response-time clamp per /insights:633.
@@ -125,12 +134,33 @@ function extractBashSubcommand(cmd) {
     if (stripped.length === 0) {
         return undefined;
     }
-    const binary = stripped[0];
+    // Path-strip the binary token before the multi-subcommand set lookup —
+    // without this, `/usr/bin/git status` misses
+    // `KNOWN_MULTI_SUBCOMMAND_BINARIES.has("/usr/bin/git")` and drops to the
+    // single-binary fallback, losing the "status" / "install" verb. Same
+    // agent activity (`git status` vs `/usr/bin/git status`) would then ship
+    // two different wire shapes — cross-session aggregation breaks even
+    // within a single Claude project. Mirrors the Codex-side fix at
+    // analytics/codex/projection.ts:425. `extractBashBinary` deliberately
+    // keeps the full path (documented Claude-vs-Codex divergence on
+    // `bash_binaries`), but `bash_subcommands` has no such divergence —
+    // verb granularity is the load-bearing signal here.
+    const rawBinary = stripped[0];
+    const binary = rawBinary.split(/[\\/]/).pop() ?? rawBinary;
+    // Guard against empty/whitespace-only commands ("", "   ", env-vars-only).
+    // `"".trim().split(/\s+/)` returns `[""]` (single empty-string element),
+    // not `[]` — the env-var skip doesn't filter the empty token, so
+    // `stripped = [""]` and `binary = ""`. The caller checks `sub !== undefined`,
+    // so the empty string would slip through and ship `bash_subcommands[""]: N`
+    // on the wire. Codex side filters via `if (sub)` (truthy check) but
+    // Claude's caller uses `!== undefined` — defending at the function level
+    // covers both call sites and any future caller.
+    if (binary.length === 0) {
+        return undefined;
+    }
     if (stripped.length === 1) {
         return binary;
     }
-    // Only include subcommand for known multi-subcommand CLIs AND when the
-    // second token has a safe identifier shape. Otherwise just emit the binary.
     if (KNOWN_MULTI_SUBCOMMAND_BINARIES.has(binary)
         && SUBCOMMAND_TOKEN_RE.test(stripped[1])) {
         return `${binary} ${stripped[1]}`;
@@ -478,15 +508,13 @@ function deriveTurnId(sessionId, turnIndex, startTime) {
         .slice(0, 16);
 }
 /**
- * Format a 32-char hex string into UUID-shaped layout (8-4-4-4-12). NOT
- * RFC 4122-compliant (no version/variant bits) but matches the regex
- * shape collectors expect for `Event.id`. Pure presentation — collisions
- * impossible because the source hash space is the same 32 hex chars.
+ * Re-exported from `src/lib/event.ts` (single source of truth). Kept here
+ * for backwards compatibility with existing consumers (`src/import/ids.ts`,
+ * Codex `projection.ts`, status-snapshot etc.) that import the
+ * symbol from this module.
  */
-function formatHexAsUuid(hex32) {
-    return `${hex32.slice(0, 8)}-${hex32.slice(8, 12)}-${hex32.slice(12, 16)}-`
-        + `${hex32.slice(16, 20)}-${hex32.slice(20, 32)}`;
-}
+var event_2 = require("../../lib/event");
+Object.defineProperty(exports, "formatHexAsUuid", { enumerable: true, get: function () { return event_2.formatHexAsUuid; } });
 /**
  * Deterministic Event.id for `session_analytics` wire records.
  * `sha256("session_analytics:" + session_id)`, formatted as UUID. One id
@@ -506,7 +534,7 @@ function deriveSessionAnalyticsEventId(sessionId) {
     const hex = (0, node_crypto_1.createHash)("sha256")
         .update(`session_analytics:${sessionId}`)
         .digest("hex");
-    return formatHexAsUuid(hex.slice(0, 32));
+    return (0, event_1.formatHexAsUuid)(hex.slice(0, 32));
 }
 /**
  * Deterministic Event.id for `session_turn_analytics` wire records.
@@ -517,7 +545,7 @@ function deriveTurnEventId(sessionId, turnId) {
     const hex = (0, node_crypto_1.createHash)("sha256")
         .update(`session_turn_analytics:${sessionId}:${turnId}`)
         .digest("hex");
-    return formatHexAsUuid(hex.slice(0, 32));
+    return (0, event_1.formatHexAsUuid)(hex.slice(0, 32));
 }
 /**
  * Deterministic Event.id for `session_turn_step_analytics` wire records.
@@ -528,7 +556,7 @@ function deriveStepEventId(sessionId, stepId) {
     const hex = (0, node_crypto_1.createHash)("sha256")
         .update(`session_turn_step_analytics:${sessionId}:${stepId}`)
         .digest("hex");
-    return formatHexAsUuid(hex.slice(0, 32));
+    return (0, event_1.formatHexAsUuid)(hex.slice(0, 32));
 }
 /**
  * Open a fresh turn from the human-user prompt that started it. Computes
@@ -1095,6 +1123,20 @@ function projectDelta(input) {
     // Reported back via DeltaInternal.seen_assistant_message_ids.
     const seenAssistantMessageIds = new Set(input.priorSeenAssistantMessageIds ?? []);
     const newAssistantMessageIdsThisSlice = [];
+    // Anthropic API tool_use_id dedup. Claude Code 2.1+ transcript writer
+    // splits a single API response's content blocks across multiple JSONL
+    // lines (each carrying the SAME message.id but DIFFERENT tool_use
+    // blocks per chunk — empirically verified against real transcripts:
+    // 170 assistant lines / 84 distinct msg_ids on a 19-min session,
+    // every multi-line msg_id had blocks of distinct types per chunk).
+    // msg_id dedup alone would drop the streaming-split chunks entirely,
+    // losing ~60% of tool_uses on real sessions. Instead, content-block
+    // walks run on EVERY chunk and individual `tool_use` blocks are deduped
+    // by their stable Anthropic-assigned `id`. This ALSO catches the
+    // legacy "true duplicate re-emit" case (where the same block was
+    // persisted multiple times verbatim — same id => skip).
+    const seenToolUseIds = new Set(input.priorSeenToolUseIds ?? []);
+    const newToolUseIdsThisSlice = [];
     // Idle attribution: walking the timeline, the gap BEFORE a human-user
     // message is "idle" (user typing/thinking/away). Every other gap is
     // "active" (model + tools + agent loop). Seed `priorTsMs` from the prior
@@ -1158,218 +1200,347 @@ function projectDelta(input) {
                 priorTsMs = tsMillis;
             }
             if (line.type === "assistant" && line.message !== undefined) {
-                // Anthropic msg_id dedup: skip the entire assistant block
-                // (counters, tokens, cost, model, context, CONSUMER, EMITTER,
-                // tool counting, step open) when this API response was already
-                // counted via a prior line/slice. See MessageBody.id docstring
-                // for why duplicates exist in real transcripts.
+                // Anthropic msg_id dedup: skip PER-MESSAGE work (counters,
+                // tokens, cost, model, context, EMITTER, step open, models[*]
+                // map, context-tokens bucket, api_request emit, end-of-msg
+                // classifier's cost accumulation) when this API response was
+                // already counted via a prior line/slice. Claude Code 2.1+
+                // splits ONE API response's content blocks across multiple
+                // JSONL lines that share the same msg_id, so the per-message
+                // counters MUST run once per msg_id. CONTENT BLOCKS
+                // (tool_use, text, thinking) are walked on EVERY chunk
+                // regardless and deduped at block level via `seenToolUseIds`
+                // (see below) — the older "continue on msg_id seen" gate
+                // would drop 60% of tool_uses on real transcripts.
                 const msgId = line.message.id;
+                let isFirstChunkOfMsg = true;
                 if (typeof msgId === "string" && msgId.length > 0) {
                     if (seenAssistantMessageIds.has(msgId)) {
-                        // Duplicate API response re-emit — silently skip.
-                        continue;
+                        isFirstChunkOfMsg = false;
+                    }
+                    else {
+                        seenAssistantMessageIds.add(msgId);
+                        newAssistantMessageIdsThisSlice.push(msgId);
                     }
-                    seenAssistantMessageIds.add(msgId);
-                    newAssistantMessageIdsThisSlice.push(msgId);
-                }
-                assistantResponseCount += 1;
-                assistantTurnIndex += 1;
-                // Track timestamp for response-time gap to the next user message.
-                if (tsMillis !== null) {
-                    lastAssistantMs = tsMillis;
                 }
-                // Per-turn: bump assistant_messages + last_activity_time.
-                // Per-step: every assistant message starts a new step. If a
-                // prior step was open in this turn, close it (push to
-                // completed_steps) before opening the new one. Step start_time
-                // is this assistant's timestamp (or lastTimestamp fallback for
-                // determinism when ts is missing — same rule as openTurn).
-                if (currentTurn !== null) {
-                    currentTurn.assistant_messages += 1;
-                    if (typeof tsString === "string" && tsString.length > 0) {
-                        currentTurn.last_activity_time = tsString;
+                // msgCost + advisorCostThisMsg are computed inside the
+                // per-message gate but consumed by the end-of-message
+                // classifier which runs on every chunk (retry-detection
+                // mutates msgBuckets-driven flags per chunk). Hoist to outer
+                // scope so they retain their value across the gate; default
+                // to 0 on subsequent chunks so `currentTurn.cost_usd += ...`
+                // doesn't double-count.
+                let msgCost = 0;
+                let advisorCostThisMsg = 0;
+                if (isFirstChunkOfMsg) {
+                    assistantResponseCount += 1;
+                    assistantTurnIndex += 1;
+                    // Track timestamp for response-time gap to the next user message.
+                    if (tsMillis !== null) {
+                        lastAssistantMs = tsMillis;
                     }
-                    if (currentTurn.current_step !== undefined) {
-                        currentTurn.completed_steps.push(currentTurn.current_step);
+                    // Per-turn: bump assistant_messages + last_activity_time.
+                    // Per-step: every assistant message starts a new step. If a
+                    // prior step was open in this turn, close it (push to
+                    // completed_steps) before opening the new one. Step start_time
+                    // is this assistant's timestamp (or lastTimestamp fallback for
+                    // determinism when ts is missing — same rule as openTurn).
+                    if (currentTurn !== null) {
+                        currentTurn.assistant_messages += 1;
+                        if (typeof tsString === "string" && tsString.length > 0) {
+                            currentTurn.last_activity_time = tsString;
+                        }
+                        if (currentTurn.current_step !== undefined) {
+                            currentTurn.completed_steps.push(currentTurn.current_step);
+                        }
+                        const stepStart = typeof tsString === "string" && tsString.length > 0
+                            ? tsString
+                            : lastTimestamp;
+                        currentTurn.current_step = openStep(currentTurn.next_step_index, stepStart);
+                        currentTurn.next_step_index += 1;
                     }
-                    const stepStart = typeof tsString === "string" && tsString.length > 0
-                        ? tsString
-                        : lastTimestamp;
-                    currentTurn.current_step = openStep(currentTurn.next_step_index, stepStart);
-                    currentTurn.next_step_index += 1;
-                }
-                const model = line.message.model;
-                const usage = line.message.usage;
-                // Tokens — session-wide totals
-                const msgInput = usage?.input_tokens ?? 0;
-                const msgOutput = usage?.output_tokens ?? 0;
-                const msgCacheCreation = usage?.cache_creation_input_tokens ?? 0;
-                const msgCacheRead = usage?.cache_read_input_tokens ?? 0;
-                // Cache-creation 5m / 1h split (Anthropic ephemeral tiers). When
-                // present, used in cost calc to bill 1h tokens at the higher
-                // rate; falls back to a single sum at 5m rate when absent.
-                const msgCC5m = usage?.cache_creation?.ephemeral_5m_input_tokens ?? 0;
-                const msgCC1h = usage?.cache_creation?.ephemeral_1h_input_tokens ?? 0;
-                const hasCcSplit = (msgCC5m + msgCC1h) > 0;
-                // Server tool use (web_search currently the only billable)
-                const msgWebSearchReqs = usage?.server_tool_use?.web_search_requests ?? 0;
-                // Fast mode tier (Opus 4.6 only — 6× regular rate)
-                const msgSpeed = usage?.speed;
-                inputTokens += msgInput;
-                outputTokens += msgOutput;
-                cacheCreationTokens += msgCacheCreation;
-                cacheReadTokens += msgCacheRead;
-                // Per-turn token totals — same additive rule as session-level.
-                // Per-step: mirror onto the just-opened step.
-                if (currentTurn !== null) {
-                    currentTurn.input_tokens += msgInput;
-                    currentTurn.output_tokens += msgOutput;
-                    currentTurn.cache_creation_tokens += msgCacheCreation;
-                    currentTurn.cache_read_tokens += msgCacheRead;
-                    if (currentTurn.current_step !== undefined) {
-                        currentTurn.current_step.input_tokens += msgInput;
-                        currentTurn.current_step.output_tokens += msgOutput;
-                        currentTurn.current_step.cache_creation_tokens += msgCacheCreation;
-                        currentTurn.current_step.cache_read_tokens += msgCacheRead;
+                    // Normalize bracketed runtime suffixes (e.g. `claude-opus-4-7[1m]`
+                    // → `claude-opus-4-7`) at the single capture site so every
+                    // downstream use ships a consistent canonical id: `api_request.model`,
+                    // `session_analytics.models[<key>]` map keys, `session_turn_analytics`
+                    // / `session_turn_step_analytics` per-turn / per-step `models`
+                    // map keys. Without this, `session_status.model` (already
+                    // normalized at clients/claude/hooks/session-status.ts:222
+                    // via `normalizeModelId`) emitted `claude-opus-4-7` while
+                    // `api_request.model` and `models[*]` keys shipped raw
+                    // `claude-opus-4-7[1m]` — backend dashboards joining
+                    // `api_request` ↔ `session_status` on `model` saw two
+                    // strings for one model, and `Σ session_analytics.models[*]`
+                    // didn't reconcile cross-event. The `[…]` suffix is
+                    // redundant on the wire — context-window size carries the
+                    // effective window through `session_status.context_window`.
+                    const rawModel = line.message.model;
+                    const model = rawModel === undefined
+                        ? undefined
+                        : rawModel.replace(/\[[^\]]*\]/g, "").trim();
+                    const usage = line.message.usage;
+                    // Tokens — session-wide totals
+                    const msgInput = usage?.input_tokens ?? 0;
+                    const msgOutput = usage?.output_tokens ?? 0;
+                    const msgCacheCreation = usage?.cache_creation_input_tokens ?? 0;
+                    const msgCacheRead = usage?.cache_read_input_tokens ?? 0;
+                    // Cache-creation 5m / 1h split (Anthropic ephemeral tiers). When
+                    // present, used in cost calc to bill 1h tokens at the higher
+                    // rate; falls back to a single sum at 5m rate when absent.
+                    const msgCC5m = usage?.cache_creation?.ephemeral_5m_input_tokens ?? 0;
+                    const msgCC1h = usage?.cache_creation?.ephemeral_1h_input_tokens ?? 0;
+                    const hasCcSplit = (msgCC5m + msgCC1h) > 0;
+                    // Server tool use (web_search currently the only billable)
+                    const msgWebSearchReqs = usage?.server_tool_use?.web_search_requests ?? 0;
+                    // Fast mode tier (Opus 4.6 only — 6× regular rate)
+                    const msgSpeed = usage?.speed;
+                    inputTokens += msgInput;
+                    outputTokens += msgOutput;
+                    cacheCreationTokens += msgCacheCreation;
+                    cacheReadTokens += msgCacheRead;
+                    // Per-turn token totals — same additive rule as session-level.
+                    // Per-step: mirror onto the just-opened step.
+                    if (currentTurn !== null) {
+                        currentTurn.input_tokens += msgInput;
+                        currentTurn.output_tokens += msgOutput;
+                        currentTurn.cache_creation_tokens += msgCacheCreation;
+                        currentTurn.cache_read_tokens += msgCacheRead;
+                        if (currentTurn.current_step !== undefined) {
+                            currentTurn.current_step.input_tokens += msgInput;
+                            currentTurn.current_step.output_tokens += msgOutput;
+                            currentTurn.current_step.cache_creation_tokens += msgCacheCreation;
+                            currentTurn.current_step.cache_read_tokens += msgCacheRead;
+                        }
                     }
-                }
-                // Per-message cost — looked up by model id (family fallback +
-                // fast-mode tier when speed=="fast" on Opus 4.6). Unknown
-                // family contributes 0. computeMessageCostUsd handles the
-                // 5m/1h cache split + web_search add-on.
-                const pricing = typeof model === "string" && model.length > 0
-                    ? (0, pricing_1.lookupPricingForUsage)(model, msgSpeed)
-                    : null;
-                const msgCost = (0, pricing_1.computeMessageCostUsd)({
-                    input_tokens: msgInput,
-                    output_tokens: msgOutput,
-                    cache_creation_tokens: msgCacheCreation,
-                    cache_read_tokens: msgCacheRead,
-                    ...(hasCcSplit ? {
-                        cache_creation_5m_tokens: msgCC5m,
-                        cache_creation_1h_tokens: msgCC1h,
-                    } : {}),
-                    web_search_requests: msgWebSearchReqs,
-                }, pricing);
-                costUsd += msgCost;
-                // Per-API-request event emission. One record per non-duplicate
-                // assistant line — covers both successful API responses and
-                // terminal failure synthetic placeholders (`isApiErrorMessage`).
-                // Body-only struct; emit wraps with the Event envelope.
-                //
-                // Field semantics verified against real transcripts:
-                //   - request_id: top-level `requestId` ONLY on success lines
-                //     (failure lines carry no join key → null).
-                //   - error: top-level `error` ONLY on failure lines.
-                //   - status_code: top-level `apiErrorStatus` rarely set even
-                //     on failures (~5% — only explicit HTTP errors like 429).
-                //   - speed: `usage.speed` typically "standard"; null on
-                //     synthetic-failure placeholder messages.
-                //   - duration: NOT in transcript at all → always null here
-                //     (transcript-derived). Java-side runtime emitters fill
-                //     this with real per-call latency.
-                //   - cost_usd: derived via pricing × tokens (= 0 on failures
-                //     since tokens are zero).
-                const isApiErrorLine = line.isApiErrorMessage === true;
-                const apiRequestId = typeof line.requestId === "string" && line.requestId.length > 0
-                    ? line.requestId
-                    : null;
-                const apiErrorStr = isApiErrorLine && typeof line.error === "string"
-                    ? line.error
-                    : null;
-                const apiStatusCode = isApiErrorLine && typeof line.apiErrorStatus === "number"
-                    ? line.apiErrorStatus
-                    : null;
-                const apiSpeed = typeof msgSpeed === "string" && msgSpeed.length > 0
-                    ? msgSpeed
-                    : null;
-                const apiTimestampMs = tsMillis ?? Date.now();
-                // Event.id source: transcript line's top-level `uuid`. Verified
-                // 100% presence on real transcripts (success + failure). Falls
-                // back to a deterministic UUID-shaped id derived from
-                // sha256(session_id|msg_id|timestamp) when uuid is missing
-                // (defensive — never observed in production data; Cursor
-                // transcripts have no uuid either way and don't reach this
-                // path because they're skipped at emit-time).
-                const apiEventId = typeof line.uuid === "string" && line.uuid.length > 0
-                    ? line.uuid
-                    : formatHexAsUuid((0, node_crypto_1.createHash)("sha256")
-                        .update(`api_request:${input.sessionId}:${msgId ?? "anon"}:${apiTimestampMs}`)
-                        .digest("hex")
-                        .slice(0, 32));
-                apiRequestEvents.push({
-                    id: apiEventId,
-                    timestamp_ms: apiTimestampMs,
-                    request_id: apiRequestId,
-                    success: !isApiErrorLine,
-                    error: apiErrorStr,
-                    status_code: apiStatusCode,
-                    model: typeof model === "string" && model.length > 0 ? model : "<unknown>",
-                    speed: apiSpeed,
-                    input_tokens: msgInput,
-                    output_tokens: msgOutput,
-                    cache_read_tokens: msgCacheRead,
-                    cache_creation_tokens: msgCacheCreation,
-                    cost_usd: msgCost,
-                    duration: null,
-                });
-                // Advisor sub-call recursion. `usage.iterations` may carry
-                // entries typed `"advisor_message"` whose tokens are billed
-                // separately — they're NOT included in the parent usage.
-                // Each advisor sub-call goes to unattributed_cost (no per-tool
-                // attribution; advisor is a server-side recursive call,
-                // priced at its own model's rate). Other iteration types
-                // (notably `"message"` which mirrors the parent) are skipped.
-                let advisorCostThisMsg = 0;
-                const iterations = usage?.iterations;
-                if (Array.isArray(iterations)) {
-                    for (const it of iterations) {
-                        if (it.type !== "advisor_message") {
-                            continue;
+                    // Per-message cost — looked up by model id (family fallback +
+                    // fast-mode tier when speed=="fast" on Opus 4.6). Unknown
+                    // family contributes 0. computeMessageCostUsd handles the
+                    // 5m/1h cache split + web_search add-on.
+                    const pricing = typeof model === "string" && model.length > 0
+                        ? (0, pricing_1.lookupPricingForUsage)(model, msgSpeed)
+                        : null;
+                    // Assignment (not declaration) — msgCost was hoisted to outer
+                    // scope so the end-of-message classifier (which runs on every
+                    // chunk) can read it; on subsequent chunks the gate keeps
+                    // msgCost at 0 so cost isn't double-counted.
+                    msgCost = (0, pricing_1.computeMessageCostUsd)({
+                        input_tokens: msgInput,
+                        output_tokens: msgOutput,
+                        cache_creation_tokens: msgCacheCreation,
+                        cache_read_tokens: msgCacheRead,
+                        ...(hasCcSplit ? {
+                            cache_creation_5m_tokens: msgCC5m,
+                            cache_creation_1h_tokens: msgCC1h,
+                        } : {}),
+                        web_search_requests: msgWebSearchReqs,
+                    }, pricing);
+                    costUsd += msgCost;
+                    // Per-API-request event emission. One record per non-duplicate
+                    // assistant line — covers both successful API responses and
+                    // terminal failure synthetic placeholders (`isApiErrorMessage`).
+                    // Body-only struct; emit wraps with the Event envelope.
+                    //
+                    // Field semantics verified against real transcripts:
+                    //   - request_id: top-level `requestId` ONLY on success lines
+                    //     (failure lines carry no join key → null).
+                    //   - error: top-level `error` ONLY on failure lines.
+                    //   - status_code: top-level `apiErrorStatus` rarely set even
+                    //     on failures (~5% — only explicit HTTP errors like 429).
+                    //   - speed: `usage.speed` typically "standard"; null on
+                    //     synthetic-failure placeholder messages.
+                    //   - duration: NOT in transcript at all → always null here
+                    //     (transcript-derived). Server-side runtime emitters fill
+                    //     this with real per-call latency.
+                    //   - cost_usd: derived via pricing × tokens (= 0 on failures
+                    //     since tokens are zero).
+                    const isApiErrorLine = line.isApiErrorMessage === true;
+                    const apiRequestId = typeof line.requestId === "string" && line.requestId.length > 0
+                        ? line.requestId
+                        : null;
+                    const apiErrorStr = isApiErrorLine && typeof line.error === "string"
+                        ? line.error
+                        : null;
+                    const apiStatusCode = isApiErrorLine && typeof line.apiErrorStatus === "number"
+                        ? line.apiErrorStatus
+                        : null;
+                    const apiSpeed = typeof msgSpeed === "string" && msgSpeed.length > 0
+                        ? msgSpeed
+                        : null;
+                    const apiTimestampMs = tsMillis ?? Date.now();
+                    // Event.id source: transcript line's top-level `uuid`. Verified
+                    // 100% presence on real transcripts (success + failure). Falls
+                    // back to a deterministic UUID-shaped id derived from
+                    // sha256(session_id|msg_id|timestamp) when uuid is missing
+                    // (defensive — never observed in production data; Cursor
+                    // transcripts have no uuid either way and don't reach this
+                    // path because they're skipped at emit-time).
+                    const apiEventId = typeof line.uuid === "string" && line.uuid.length > 0
+                        ? line.uuid
+                        : (0, event_1.formatHexAsUuid)((0, node_crypto_1.createHash)("sha256")
+                            .update(`api_request:${input.sessionId}:${msgId ?? "anon"}:${apiTimestampMs}`)
+                            .digest("hex")
+                            .slice(0, 32));
+                    apiRequestEvents.push({
+                        id: apiEventId,
+                        timestamp_ms: apiTimestampMs,
+                        request_id: apiRequestId,
+                        success: !isApiErrorLine,
+                        error: apiErrorStr,
+                        status_code: apiStatusCode,
+                        model: typeof model === "string" && model.length > 0 ? model : "<unknown>",
+                        speed: apiSpeed,
+                        input_tokens: msgInput,
+                        output_tokens: msgOutput,
+                        cache_read_tokens: msgCacheRead,
+                        cache_creation_tokens: msgCacheCreation,
+                        cost_usd: msgCost,
+                        duration: null,
+                    });
+                    // Advisor sub-call recursion. `usage.iterations` may carry
+                    // entries typed `"advisor_message"` whose tokens are billed
+                    // separately — they're NOT included in the parent usage.
+                    // Each advisor sub-call goes to unattributed_cost (no per-tool
+                    // attribution; advisor is a server-side recursive call,
+                    // priced at its own model's rate). Other iteration types
+                    // (notably `"message"` which mirrors the parent) are skipped.
+                    // `advisorCostThisMsg` is declared in the outer scope (above
+                    // the isFirstChunkOfMsg gate) for the same reason as
+                    // msgCost — end-of-message classifier reads it on every
+                    // chunk; subsequent chunks see 0 (gate not entered).
+                    // Track advisor token totals across iterations so they can
+                    // be folded into session/turn/step usage AFTER the loop —
+                    // mirrors how `advisorCostThisMsg` gets folded into
+                    // `costUsd` at line ~1820. Without this fold, per-model
+                    // sums diverge from session totals (round 86a fixed cost
+                    // parity but left token parity broken):
+                    //   Σ models[*].input_tokens > session.usage.input_tokens
+                    // by exactly `advisorInputThisMsg`, same for output/cache.
+                    // Backend dashboards reconciling "tokens by model" vs
+                    // "session usage" see the divergence.
+                    let advisorInputThisMsg = 0;
+                    let advisorOutputThisMsg = 0;
+                    let advisorCacheCreationThisMsg = 0;
+                    let advisorCacheReadThisMsg = 0;
+                    const iterations = usage?.iterations;
+                    if (Array.isArray(iterations)) {
+                        for (const it of iterations) {
+                            if (it.type !== "advisor_message") {
+                                continue;
+                            }
+                            const advModel = it.model;
+                            const advPricing = typeof advModel === "string" && advModel.length > 0
+                                ? (0, pricing_1.lookupPricing)(advModel)
+                                : null;
+                            const advCC5m = it.cache_creation?.ephemeral_5m_input_tokens ?? 0;
+                            const advCC1h = it.cache_creation?.ephemeral_1h_input_tokens ?? 0;
+                            const advHasSplit = (advCC5m + advCC1h) > 0;
+                            const advInput = it.input_tokens ?? 0;
+                            const advOutput = it.output_tokens ?? 0;
+                            const advCacheCreation = it.cache_creation_input_tokens ?? 0;
+                            const advCacheRead = it.cache_read_input_tokens ?? 0;
+                            const advCost = (0, pricing_1.computeMessageCostUsd)({
+                                input_tokens: advInput,
+                                output_tokens: advOutput,
+                                cache_creation_tokens: advCacheCreation,
+                                cache_read_tokens: advCacheRead,
+                                ...(advHasSplit ? {
+                                    cache_creation_5m_tokens: advCC5m,
+                                    cache_creation_1h_tokens: advCC1h,
+                                } : {}),
+                            }, advPricing);
+                            advisorCostThisMsg += advCost;
+                            advisorInputThisMsg += advInput;
+                            advisorOutputThisMsg += advOutput;
+                            advisorCacheCreationThisMsg += advCacheCreation;
+                            advisorCacheReadThisMsg += advCacheRead;
+                            // Route advisor cost + tokens into the advisor's
+                            // OWN per-model breakdown. Without this, session
+                            // `usage.cost_usd` includes advisor (line below)
+                            // but `Σ models[*].cost_usd` excludes it — backend
+                            // "cost by model" SQL would underreport by
+                            // exactly `advisorCostThisMsg` on every session
+                            // that triggered advisor sub-calls.
+                            if (typeof advModel === "string" && advModel.length > 0) {
+                                const advSlot = models[advModel] ?? {
+                                    count: 0,
+                                    input_tokens: 0,
+                                    output_tokens: 0,
+                                    cache_creation_tokens: 0,
+                                    cache_read_tokens: 0,
+                                    cost_usd: 0,
+                                };
+                                advSlot.count += 1;
+                                advSlot.input_tokens += advInput;
+                                advSlot.output_tokens += advOutput;
+                                advSlot.cache_creation_tokens += advCacheCreation;
+                                advSlot.cache_read_tokens += advCacheRead;
+                                advSlot.cost_usd += advCost;
+                                models[advModel] = advSlot;
+                                if (currentTurn !== null) {
+                                    const advTurnSlot = currentTurn.models[advModel] ?? {
+                                        count: 0,
+                                        input_tokens: 0,
+                                        output_tokens: 0,
+                                        cache_creation_tokens: 0,
+                                        cache_read_tokens: 0,
+                                        cost_usd: 0,
+                                    };
+                                    advTurnSlot.count += 1;
+                                    advTurnSlot.input_tokens += advInput;
+                                    advTurnSlot.output_tokens += advOutput;
+                                    advTurnSlot.cache_creation_tokens += advCacheCreation;
+                                    advTurnSlot.cache_read_tokens += advCacheRead;
+                                    advTurnSlot.cost_usd += advCost;
+                                    currentTurn.models[advModel] = advTurnSlot;
+                                    if (currentTurn.current_step !== undefined) {
+                                        const advStepSlot = currentTurn.current_step.models[advModel] ?? {
+                                            count: 0,
+                                            input_tokens: 0,
+                                            output_tokens: 0,
+                                            cache_creation_tokens: 0,
+                                            cache_read_tokens: 0,
+                                            cost_usd: 0,
+                                        };
+                                        advStepSlot.count += 1;
+                                        advStepSlot.input_tokens += advInput;
+                                        advStepSlot.output_tokens += advOutput;
+                                        advStepSlot.cache_creation_tokens += advCacheCreation;
+                                        advStepSlot.cache_read_tokens += advCacheRead;
+                                        advStepSlot.cost_usd += advCost;
+                                        currentTurn.current_step.models[advModel] = advStepSlot;
+                                    }
+                                }
+                            }
                         }
-                        const advModel = it.model;
-                        const advPricing = typeof advModel === "string" && advModel.length > 0
-                            ? (0, pricing_1.lookupPricing)(advModel)
-                            : null;
-                        const advCC5m = it.cache_creation?.ephemeral_5m_input_tokens ?? 0;
-                        const advCC1h = it.cache_creation?.ephemeral_1h_input_tokens ?? 0;
-                        const advHasSplit = (advCC5m + advCC1h) > 0;
-                        const advCost = (0, pricing_1.computeMessageCostUsd)({
-                            input_tokens: it.input_tokens ?? 0,
-                            output_tokens: it.output_tokens ?? 0,
-                            cache_creation_tokens: it.cache_creation_input_tokens ?? 0,
-                            cache_read_tokens: it.cache_read_input_tokens ?? 0,
-                            ...(advHasSplit ? {
-                                cache_creation_5m_tokens: advCC5m,
-                                cache_creation_1h_tokens: advCC1h,
-                            } : {}),
-                        }, advPricing);
-                        advisorCostThisMsg += advCost;
                     }
-                }
-                costUsd += advisorCostThisMsg;
-                // Per-model usage breakdown — element-wise additive across deltas
-                // in the merge step. Empty / missing model name skipped (no
-                // attribution possible).
-                if (typeof model === "string" && model.length > 0) {
-                    const slot = models[model] ?? {
-                        count: 0,
-                        input_tokens: 0,
-                        output_tokens: 0,
-                        cache_creation_tokens: 0,
-                        cache_read_tokens: 0,
-                        cost_usd: 0,
-                    };
-                    slot.count += 1;
-                    slot.input_tokens += msgInput;
-                    slot.output_tokens += msgOutput;
-                    slot.cache_creation_tokens += msgCacheCreation;
-                    slot.cache_read_tokens += msgCacheRead;
-                    slot.cost_usd += msgCost;
-                    models[model] = slot;
-                    // Per-turn parallel — same additive rule. Per-step too.
+                    costUsd += advisorCostThisMsg;
+                    // Fold advisor TOKEN totals into session/turn/step usage
+                    // alongside the cost fold above. Without this, per-model
+                    // sums diverge from session totals: Σ models[*].input_tokens
+                    // > session.usage.input_tokens by exactly the advisor
+                    // tokens (round 86a fixed cost parity but missed the
+                    // matching token parity).
+                    inputTokens += advisorInputThisMsg;
+                    outputTokens += advisorOutputThisMsg;
+                    cacheCreationTokens += advisorCacheCreationThisMsg;
+                    cacheReadTokens += advisorCacheReadThisMsg;
                     if (currentTurn !== null) {
-                        const turnSlot = currentTurn.models[model] ?? {
+                        currentTurn.input_tokens += advisorInputThisMsg;
+                        currentTurn.output_tokens += advisorOutputThisMsg;
+                        currentTurn.cache_creation_tokens += advisorCacheCreationThisMsg;
+                        currentTurn.cache_read_tokens += advisorCacheReadThisMsg;
+                        if (currentTurn.current_step !== undefined) {
+                            currentTurn.current_step.input_tokens += advisorInputThisMsg;
+                            currentTurn.current_step.output_tokens += advisorOutputThisMsg;
+                            currentTurn.current_step.cache_creation_tokens += advisorCacheCreationThisMsg;
+                            currentTurn.current_step.cache_read_tokens += advisorCacheReadThisMsg;
+                        }
+                    }
+                    // Per-model usage breakdown — element-wise additive across deltas
+                    // in the merge step. Empty / missing model name skipped (no
+                    // attribution possible).
+                    if (typeof model === "string" && model.length > 0) {
+                        const slot = models[model] ?? {
                             count: 0,
                             input_tokens: 0,
                             output_tokens: 0,
@@ -1377,15 +1548,16 @@ function projectDelta(input) {
                             cache_read_tokens: 0,
                             cost_usd: 0,
                         };
-                        turnSlot.count += 1;
-                        turnSlot.input_tokens += msgInput;
-                        turnSlot.output_tokens += msgOutput;
-                        turnSlot.cache_creation_tokens += msgCacheCreation;
-                        turnSlot.cache_read_tokens += msgCacheRead;
-                        turnSlot.cost_usd += msgCost;
-                        currentTurn.models[model] = turnSlot;
-                        if (currentTurn.current_step !== undefined) {
-                            const stepSlot = currentTurn.current_step.models[model] ?? {
+                        slot.count += 1;
+                        slot.input_tokens += msgInput;
+                        slot.output_tokens += msgOutput;
+                        slot.cache_creation_tokens += msgCacheCreation;
+                        slot.cache_read_tokens += msgCacheRead;
+                        slot.cost_usd += msgCost;
+                        models[model] = slot;
+                        // Per-turn parallel — same additive rule. Per-step too.
+                        if (currentTurn !== null) {
+                            const turnSlot = currentTurn.models[model] ?? {
                                 count: 0,
                                 input_tokens: 0,
                                 output_tokens: 0,
@@ -1393,70 +1565,96 @@ function projectDelta(input) {
                                 cache_read_tokens: 0,
                                 cost_usd: 0,
                             };
-                            stepSlot.count += 1;
-                            stepSlot.input_tokens += msgInput;
-                            stepSlot.output_tokens += msgOutput;
-                            stepSlot.cache_creation_tokens += msgCacheCreation;
-                            stepSlot.cache_read_tokens += msgCacheRead;
-                            stepSlot.cost_usd += msgCost;
-                            currentTurn.current_step.models[model] = stepSlot;
+                            turnSlot.count += 1;
+                            turnSlot.input_tokens += msgInput;
+                            turnSlot.output_tokens += msgOutput;
+                            turnSlot.cache_creation_tokens += msgCacheCreation;
+                            turnSlot.cache_read_tokens += msgCacheRead;
+                            turnSlot.cost_usd += msgCost;
+                            currentTurn.models[model] = turnSlot;
+                            if (currentTurn.current_step !== undefined) {
+                                const stepSlot = currentTurn.current_step.models[model] ?? {
+                                    count: 0,
+                                    input_tokens: 0,
+                                    output_tokens: 0,
+                                    cache_creation_tokens: 0,
+                                    cache_read_tokens: 0,
+                                    cost_usd: 0,
+                                };
+                                stepSlot.count += 1;
+                                stepSlot.input_tokens += msgInput;
+                                stepSlot.output_tokens += msgOutput;
+                                stepSlot.cache_creation_tokens += msgCacheCreation;
+                                stepSlot.cache_read_tokens += msgCacheRead;
+                                stepSlot.cost_usd += msgCost;
+                                currentTurn.current_step.models[model] = stepSlot;
+                            }
                         }
                     }
-                }
-                // Context-tokens distribution (turn-bucketed)
-                if (usage !== undefined) {
-                    const ctx = msgInput + msgCacheCreation + msgCacheRead;
-                    if (ctx > 0) {
-                        hasAssistantWithUsage = true;
-                        const bucket = turnBucket(assistantTurnIndex);
-                        const slot = contextTokensBuckets[bucket]
-                            ?? { sum: 0, count: 0 };
-                        slot.sum += ctx;
-                        slot.count += 1;
-                        contextTokensBuckets[bucket] = slot;
-                        contextTokensLatest = ctx;
-                        if (ctx > contextTokensPeak) {
-                            contextTokensPeak = ctx;
-                        }
-                        // Per-turn samples — append in order; backend can
-                        // reconstruct session-level buckets by concatenating
-                        // every turn's samples in turn_index order.
-                        // Per-step: single scalar (one sample per step since a
-                        // step is bounded by exactly one assistant message).
-                        if (currentTurn !== null) {
-                            currentTurn.context_tokens_samples.push(ctx);
-                            currentTurn.context_tokens_latest = ctx;
-                            if (ctx > currentTurn.context_tokens_peak) {
-                                currentTurn.context_tokens_peak = ctx;
+                    // Context-tokens distribution (turn-bucketed)
+                    if (usage !== undefined) {
+                        const ctx = msgInput + msgCacheCreation + msgCacheRead;
+                        if (ctx > 0) {
+                            hasAssistantWithUsage = true;
+                            const bucket = turnBucket(assistantTurnIndex);
+                            const slot = contextTokensBuckets[bucket]
+                                ?? { sum: 0, count: 0 };
+                            slot.sum += ctx;
+                            slot.count += 1;
+                            contextTokensBuckets[bucket] = slot;
+                            contextTokensLatest = ctx;
+                            if (ctx > contextTokensPeak) {
+                                contextTokensPeak = ctx;
                             }
-                            if (currentTurn.current_step !== undefined) {
-                                currentTurn.current_step.context_tokens = ctx;
+                            // Per-turn samples — append in order; backend can
+                            // reconstruct session-level buckets by concatenating
+                            // every turn's samples in turn_index order.
+                            // Per-step: single scalar (one sample per step since a
+                            // step is bounded by exactly one assistant message).
+                            if (currentTurn !== null) {
+                                currentTurn.context_tokens_samples.push(ctx);
+                                currentTurn.context_tokens_latest = ctx;
+                                if (ctx > currentTurn.context_tokens_peak) {
+                                    currentTurn.context_tokens_peak = ctx;
+                                }
+                                if (currentTurn.current_step !== undefined) {
+                                    currentTurn.current_step.context_tokens = ctx;
+                                }
                             }
                         }
                     }
-                }
-                // ── Per-tool consumer: no-op ──────────────────────────────
-                // Per-tool token / cost attribution does not exist. tool_result
-                // bytes are recorded directly on `tools[T].output_size` at the
-                // tool_result handler in the user-msg branch (no consumer
-                // assistant N+1 attribution step needed). Anthropic-exact
-                // tokens (msgInput, msgCacheCreation, msgCacheRead, msgOutput)
-                // continue to flow into session/turn/step usage totals + per-
-                // model cost. priorUserMsgTextBytes / hasCcSplit / msgCC5m /
-                // msgCC1h / msgWebSearchReqs / advisorCostThisMsg references
-                // exist for backward-compat with state shape but are unused
-                // by per-tool attribution. msgWebSearchReqs cost still adds
-                // to the session msgCost via computeMessageCostUsd above.
-                void msgInput;
-                void msgCacheCreation;
-                void msgCacheRead;
-                void hasCcSplit;
-                void msgCC5m;
-                void msgCC1h;
-                void msgWebSearchReqs;
-                void advisorCostThisMsg;
-                void priorUserMsgTextBytes;
-                resultedToolUseIds = [];
+                    // ── Per-tool consumer: no-op ──────────────────────────────
+                    // Per-tool token / cost attribution does not exist. tool_result
+                    // bytes are recorded directly on `tools[T].output_size` at the
+                    // tool_result handler in the user-msg branch (no consumer
+                    // assistant N+1 attribution step needed). Anthropic-exact
+                    // tokens (msgInput, msgCacheCreation, msgCacheRead, msgOutput)
+                    // continue to flow into session/turn/step usage totals + per-
+                    // model cost. priorUserMsgTextBytes / hasCcSplit / msgCC5m /
+                    // msgCC1h / msgWebSearchReqs / advisorCostThisMsg references
+                    // exist for backward-compat with state shape but are unused
+                    // by per-tool attribution. msgWebSearchReqs cost still adds
+                    // to the session msgCost via computeMessageCostUsd above.
+                    void msgInput;
+                    void msgCacheCreation;
+                    void msgCacheRead;
+                    void hasCcSplit;
+                    void msgCC5m;
+                    void msgCC1h;
+                    void msgWebSearchReqs;
+                    void advisorCostThisMsg;
+                    void priorUserMsgTextBytes;
+                    resultedToolUseIds = [];
+                } // end of `if (isFirstChunkOfMsg)` — per-message scalar work
+                // Snapshot of `seenToolUseIds` taken at the start of this
+                // chunk's content-block walks. Both Loop 1 (input_size
+                // attribution) and Loop 2 (count + classifier flags) use
+                // this snapshot to dedup — without it, Loop 1's add to the
+                // running set would cause Loop 2 to skip the same id on
+                // its own pass. New ids found in this chunk are committed
+                // to the running set + `newToolUseIdsThisSlice` after both
+                // loops finish.
+                const seenToolUseIdsAtChunkStart = new Set(seenToolUseIds);
                 // Walk content blocks for tool_use entries.
                 // ── Per-tool emitter: byte counter ──────────────────────────
                 // Each tool_use bumps the corresponding tool/mcp_server/skill/
@@ -1483,6 +1681,12 @@ function projectDelta(input) {
                             || block.id.length === 0) {
                             continue;
                         }
+                        // tool_use_id dedup — skip if this tool_use was
+                        // already counted in a prior chunk of this msg_id
+                        // (or in a prior slice persisted via state).
+                        if (seenToolUseIdsAtChunkStart.has(block.id)) {
+                            continue;
+                        }
                         const inputJsonBytes = Buffer.byteLength(JSON.stringify(block.input ?? {}), "utf-8");
                         // Sub-classification — same mutual-exclusion rules as before.
                         let bashBinary;
@@ -1527,7 +1731,9 @@ function projectDelta(input) {
                         pendingToolUses[block.id] = pending;
                     }
                 }
-                void msgOutput; // output side is not per-tool attributed
+                // Note: msgOutput is consumed inside the per-message gate
+                // above (outputTokens accumulator). Its `void` no-op silencer
+                // moved into the gate alongside the other locals.
                 // Per-message tool-bucket flag accumulator for the classifier
                 // retry state machine. Computed locally within this assistant
                 // message; merged into currentTurn at the end.
@@ -1539,6 +1745,17 @@ function projectDelta(input) {
                         }
                         const block = blk;
                         if (block.type === "tool_use" && typeof block.name === "string") {
+                            // tool_use_id dedup — skip if already counted in
+                            // a prior chunk of this msg_id (snapshot was taken
+                            // before Loop 1 ran so Loop 1's additions don't
+                            // pre-empt Loop 2's processing of the same id).
+                            // Empty/missing id falls through to count (current
+                            // behavior preserved: malformed ids still count).
+                            if (typeof block.id === "string"
+                                && block.id.length > 0
+                                && seenToolUseIdsAtChunkStart.has(block.id)) {
+                                continue;
+                            }
                             const toolName = block.name;
                             // Per-tool breakdown count — also update mcp_servers,
                             // bash_binaries, skills, sub_agents in the same step.
@@ -1667,15 +1884,27 @@ function projectDelta(input) {
                                                     (currentTurn.current_step.file_change_counts[filePath] ?? 0) + 1;
                                             }
                                         }
-                                    }
-                                    const lang = getLanguageFromPath(filePath);
-                                    if (lang !== null) {
-                                        languages[lang] = (languages[lang] ?? 0) + 1;
-                                        if (currentTurn !== null) {
-                                            currentTurn.languages[lang] = (currentTurn.languages[lang] ?? 0) + 1;
-                                            if (currentTurn.current_step !== undefined) {
-                                                currentTurn.current_step.languages[lang] =
-                                                    (currentTurn.current_step.languages[lang] ?? 0) + 1;
+                                        // Language counter is INSIDE the Edit/Write gate so it
+                                        // tracks files actually MODIFIED (parity with Codex
+                                        // `apply_patch` only-counts at projection.ts:863-870).
+                                        // Without the gate, every `Read` (and any future
+                                        // file_path-bearing tool) bumped `languages[lang]` —
+                                        // same logical session shipped
+                                        // `code_changes.{files_modified: 3, languages.TypeScript: 50}`
+                                        // (47 Reads + 3 Edits) on Claude while Codex shipped
+                                        // `{files_modified: 3, languages.TypeScript: 3}`.
+                                        // Backend cross-client `Σ languages` joins broke and the
+                                        // wire was internally inconsistent (50 ≠ 3 for the same
+                                        // category aggregate).
+                                        const lang = getLanguageFromPath(filePath);
+                                        if (lang !== null) {
+                                            languages[lang] = (languages[lang] ?? 0) + 1;
+                                            if (currentTurn !== null) {
+                                                currentTurn.languages[lang] = (currentTurn.languages[lang] ?? 0) + 1;
+                                                if (currentTurn.current_step !== undefined) {
+                                                    currentTurn.current_step.languages[lang] =
+                                                        (currentTurn.current_step.languages[lang] ?? 0) + 1;
+                                                }
                                             }
                                         }
                                     }
@@ -1767,8 +1996,37 @@ function projectDelta(input) {
                         }
                     }
                 }
+                // Commit tool_use_ids processed in this chunk to the
+                // running set + slice output. Runs AFTER both Loop 1 and
+                // Loop 2 so each loop saw the consistent pre-chunk snapshot.
+                // Subsequent chunks of the same msg_id (and the next slice)
+                // will then skip these ids via `seenToolUseIdsAtChunkStart`.
+                if (Array.isArray(content)) {
+                    for (const blk of content) {
+                        if (blk === null || typeof blk !== "object") {
+                            continue;
+                        }
+                        const block = blk;
+                        if (block.type !== "tool_use"
+                            || typeof block.id !== "string"
+                            || block.id.length === 0) {
+                            continue;
+                        }
+                        if (!seenToolUseIds.has(block.id)) {
+                            seenToolUseIds.add(block.id);
+                            newToolUseIdsThisSlice.push(block.id);
+                        }
+                    }
+                }
                 // End-of-message classifier update: retry detection +
-                // per-turn cost accumulation. Only if we have an open turn.
+                // per-turn cost accumulation. Retry detection runs on every
+                // chunk (msgBuckets reflects this chunk's tool_uses); cost
+                // accumulation is gated by `msgCost` being non-zero, which
+                // only happens on the first chunk of a msg_id (subsequent
+                // chunks keep msgCost at its outer-scope default of 0 since
+                // the per-message gate is closed). Same effect as an explicit
+                // `if (isFirstChunkOfMsg)` gate but without re-introducing
+                // the dependency on the flag here.
                 if (currentTurn !== null) {
                     if (msgBuckets.edit) {
                         if (currentTurn.saw_bash_after_edit) {
@@ -1780,9 +2038,18 @@ function projectDelta(input) {
                     if (msgBuckets.bash && currentTurn.saw_edit_pending_bash) {
                         currentTurn.saw_bash_after_edit = true;
                     }
-                    currentTurn.cost_usd += msgCost;
+                    // Include advisor sub-call cost (`advisorCostThisMsg`,
+                    // computed above with the parent's msgCost). Session-level
+                    // `costUsd` adds it at line ~1747; turn-level must mirror
+                    // or backend's reconstruction invariant breaks:
+                    // `Σ SessionTurnAnalytics.usage.cost_usd` would be less
+                    // than `SessionAnalytics.usage.cost_usd` for any session
+                    // that triggered server-side advisor sub-calls. On
+                    // subsequent chunks msgCost = advisorCostThisMsg = 0
+                    // (per-message gate not entered), so this is a no-op.
+                    currentTurn.cost_usd += msgCost + advisorCostThisMsg;
                     if (currentTurn.current_step !== undefined) {
-                        currentTurn.current_step.cost_usd += msgCost;
+                        currentTurn.current_step.cost_usd += msgCost + advisorCostThisMsg;
                     }
                 }
             }
@@ -2213,12 +2480,22 @@ function projectDeltaInternal(input) {
     // (set if a turn straddled the prior slice boundary).
     let nextTurnIndex = input.priorNextTurnIndex ?? 1;
     let hasOpenTurn = input.priorCurrentTurn !== undefined;
-    // Anthropic msg_id dedup — must mirror projectDelta exactly so file_path
-    // counts / distinct paths don't pick up duplicated assistant lines (the
-    // same API response can be persisted on multiple JSONL lines; see
-    // MessageBody.id docstring).
+    // Anthropic msg_id dedup — mirrors projectDelta. Used to track WHICH
+    // msg_ids are new in this slice for `new_assistant_message_ids`
+    // emission (merge appends to state.internal.seen_assistant_message_ids).
+    // Does NOT gate content-block processing — same streaming-split
+    // semantic applies here: a single API response's content blocks may
+    // be split across multiple JSONL lines sharing the same msg_id but
+    // carrying DIFFERENT tool_use blocks per chunk. Per-block dedup uses
+    // `seenToolUseIds` (below).
     const seenAssistantMessageIds = new Set(input.priorSeenAssistantMessageIds ?? []);
     const newAssistantMessageIdsThisSlice = [];
+    // tool_use_id dedup — mirrors projectDelta. file_path counters
+    // (file_path_change_counts, distinct_file_paths_seen) must not
+    // double-count when a single Edit/Write tool_use re-appears across
+    // streaming-split chunks or true-duplicate re-emits.
+    const seenToolUseIds = new Set(input.priorSeenToolUseIds ?? []);
+    const newToolUseIdsThisSlice = [];
     for (const line of input.lines) {
         const lineTsMs = tsMs(line.timestamp);
         if (lineTsMs !== null) {
@@ -2250,21 +2527,26 @@ function projectDeltaInternal(input) {
         if (line.type !== "assistant" || line.message === undefined) {
             continue;
         }
-        // Apply the same msg_id dedup as projectDelta so distinct/file_path
-        // counts stay consistent. We do this AFTER the latest-ts update
-        // because timestamp tracking is harmless to repeat (same ts).
+        // msg_id tracking — record on first occurrence per slice so
+        // `new_assistant_message_ids` is emitted in the return. Unlike
+        // the pre-fix code (which `continue`'d here, dropping content
+        // blocks of subsequent chunks), we now walk content blocks on
+        // EVERY chunk and let `seenToolUseIds` handle block-level dedup.
         const msgIdInternal = line.message.id;
         if (typeof msgIdInternal === "string" && msgIdInternal.length > 0) {
-            if (seenAssistantMessageIds.has(msgIdInternal)) {
-                continue;
+            if (!seenAssistantMessageIds.has(msgIdInternal)) {
+                seenAssistantMessageIds.add(msgIdInternal);
+                newAssistantMessageIdsThisSlice.push(msgIdInternal);
             }
-            seenAssistantMessageIds.add(msgIdInternal);
-            newAssistantMessageIdsThisSlice.push(msgIdInternal);
         }
         const content = line.message.content;
         if (!Array.isArray(content)) {
             continue;
         }
+        // Snapshot seenToolUseIds so loop iterations within this chunk
+        // can dedup against the pre-chunk state — symmetric with
+        // projectDelta's `seenToolUseIdsAtChunkStart`.
+        const seenToolUseIdsAtChunkStart = new Set(seenToolUseIds);
         for (const blk of content) {
             if (blk === null || typeof blk !== "object") {
                 continue;
@@ -2273,7 +2555,20 @@ function projectDeltaInternal(input) {
             if (block.type !== "tool_use" || typeof block.name !== "string") {
                 continue;
             }
+            if (typeof block.id !== "string" || block.id.length === 0) {
+                continue;
+            }
+            // tool_use_id dedup — skip if seen in a prior chunk or slice.
+            if (seenToolUseIdsAtChunkStart.has(block.id)) {
+                continue;
+            }
             if (block.name !== "Edit" && block.name !== "Write") {
+                // Track the id even for non-file tool_uses so cross-slice
+                // dedup catches them (symmetry with projectDelta).
+                if (!seenToolUseIds.has(block.id)) {
+                    seenToolUseIds.add(block.id);
+                    newToolUseIdsThisSlice.push(block.id);
+                }
                 continue;
             }
             const fp = block.input?.file_path;
@@ -2281,6 +2576,12 @@ function projectDeltaInternal(input) {
                 distinct.add(fp);
                 filePathChangeCounts[fp] = (filePathChangeCounts[fp] ?? 0) + 1;
             }
+            // Commit this Edit/Write tool_use_id to running set + slice
+            // output so the next chunk/slice skips it.
+            if (!seenToolUseIds.has(block.id)) {
+                seenToolUseIds.add(block.id);
+                newToolUseIdsThisSlice.push(block.id);
+            }
         }
     }
     return {
@@ -2292,6 +2593,9 @@ function projectDeltaInternal(input) {
         ...(newAssistantMessageIdsThisSlice.length > 0
             ? { new_assistant_message_ids: newAssistantMessageIdsThisSlice }
             : {}),
+        ...(newToolUseIdsThisSlice.length > 0
+            ? { new_tool_use_ids: newToolUseIdsThisSlice }
+            : {}),
     };
 }
 //# sourceMappingURL=projection.js.map