@ironbee-ai/cli 0.6.2 → 0.7.0

package/dist/analytics/projection.js

@@ -0,0 +1,2281 @@
+"use strict";
+/**
+ * IronBee CLI — Analytics Projection
+ *
+ * Projects a slice of host transcript JSONL lines into a delta
+ * `SessionAnalytics`. Operates on a slice (not the full file) so
+ * incremental projection is cheap; emits no content (privacy fence).
+ *
+ * Inputs:
+ *   - parsed transcript lines (already JSON-parsed by transcript.ts)
+ *   - `startingTurnIndex`: 1-based assistant message index for the FIRST
+ *     assistant message in this slice. Used by the turn-bucket logic to
+ *     assign global turn buckets across multiple incremental projections.
+ *
+ * Output: `DeltaAnalytics` — same shape as `AccumulatedAnalytics` plus
+ * delta-local signals merge needs (`has_assistant_with_usage`,
+ * `closing_pending_tool_uses`, `closing_current_turn`).
+ *
+ * Privacy: the function reads everything (Bash command body, Edit
+ * old_string/new_string, Write content, tool_result.content, user msg
+ * text for classifier keyword matching) but emits ONLY counts, categories,
+ * paths, timestamps, byte sizes, and boolean flags. No raw text leaves
+ * this function. Per-tool / per-category attribution operate on the
+ * read-once-locally pattern.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deriveStepId = deriveStepId;
+exports.deriveTurnId = deriveTurnId;
+exports.formatHexAsUuid = formatHexAsUuid;
+exports.deriveSessionAnalyticsEventId = deriveSessionAnalyticsEventId;
+exports.deriveTurnEventId = deriveTurnEventId;
+exports.deriveStepEventId = deriveStepEventId;
+exports.applyBreakdownDelta = applyBreakdownDelta;
+exports.closeTurn = closeTurn;
+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 pricing_1 = require("./pricing");
+const errors_1 = require("./errors");
+const classifier_1 = require("./classifier");
+// ─────────────────────────────────────────────────────────────────────────
+// Constants — keep in sync with /insights:332-349 + 651-677 + 651-677
+// ─────────────────────────────────────────────────────────────────────────
+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",
+};
+const INTERRUPT_MARKER = "[Request interrupted by user";
+// Response-time clamp per /insights:633.
+const RESPONSE_TIME_MIN_SEC = 2;
+const RESPONSE_TIME_MAX_SEC = 3600;
+// Hot files: per-session top-K cap kept in delta. The merge step uses the
+// full path→count map from `internal` to recompute the wire top-K, so
+// this constant doesn't need to match the wire size.
+const DELTA_HOT_FILES_LIMIT = 100;
+// ─────────────────────────────────────────────────────────────────────────
+// Helpers
+// ─────────────────────────────────────────────────────────────────────────
+function getLanguageFromPath(filePath) {
+    const dot = filePath.lastIndexOf(".");
+    if (dot === -1) {
+        return null;
+    }
+    const ext = filePath.slice(dot).toLowerCase();
+    return EXTENSION_TO_LANGUAGE[ext] ?? null;
+}
+/** Skip leading env-var assignments (FOO=bar) when grabbing the binary token. */
+function extractBashBinary(cmd) {
+    const tokens = cmd.trim().split(/\s+/);
+    for (const t of tokens) {
+        if (/^[A-Za-z_][A-Za-z0-9_]*=/.test(t)) {
+            continue;
+        }
+        if (t.length > 0) {
+            return t;
+        }
+    }
+    return undefined;
+}
+/**
+ * "git commit" / "npm install" — first two tokens, but only for known
+ * multi-subcommand CLIs (closed list). For other binaries the second
+ * token may be a user-supplied argument that could carry sensitive
+ * content (e.g., `echo "secret"`); we don't include those.
+ *
+ * Returns just the binary name when the second token isn't a
+ * subcommand-identifier shape (must be alphanumeric, dot, dash, or
+ * underscore — no quotes, slashes, equals).
+ */
+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) {
+        if (/^[A-Za-z_][A-Za-z0-9_]*=/.test(t)) {
+            continue;
+        }
+        stripped.push(t);
+    }
+    if (stripped.length === 0) {
+        return undefined;
+    }
+    const binary = stripped[0];
+    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]}`;
+    }
+    return binary;
+}
+/**
+ * Classify an error response body into one of the closed-list categories.
+ * Reads the content text but only emits the label.
+ */
+function classifyToolError(content) {
+    if (typeof content !== "string") {
+        return "other";
+    }
+    const lower = content.toLowerCase();
+    if (lower.includes("exit code")) {
+        return "command_failed";
+    }
+    if (lower.includes("rejected") || lower.includes("doesn't want")) {
+        return "user_rejected";
+    }
+    if (lower.includes("string to replace not found") || lower.includes("no changes")) {
+        return "edit_failed";
+    }
+    if (lower.includes("modified since read")) {
+        return "file_changed";
+    }
+    if (lower.includes("exceeds maximum") || lower.includes("too large")) {
+        return "file_too_large";
+    }
+    if (lower.includes("file not found") || lower.includes("does not exist")) {
+        return "file_not_found";
+    }
+    return "other";
+}
+function turnBucket(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+";
+}
+/** Normalize timestamp to milliseconds-since-epoch; null if unparseable. */
+function tsMs(ts) {
+    if (typeof ts !== "string" || ts.length === 0) {
+        return null;
+    }
+    const ms = Date.parse(ts);
+    return Number.isNaN(ms) ? null : ms;
+}
+/** Returns true iff this user message carries human-typed text (not just tool_result wrapping). */
+/**
+ * `isMeta: true` is Claude Code's structural marker for host-injected user
+ * messages (slash command bodies, Stop-hook feedback strings, etc.). We do
+ * NOT use this as a filter to skip the line entirely — that would orphan
+ * assistant work in cases like verify-gate retry, where hook feedback
+ * triggers further agent activity. Instead, projection treats isMeta lines
+ * with continuation semantics:
+ *
+ *   - isMeta + currentTurn exists  → continuation (no new turn opens, no
+ *     user_turns++; just extend the open turn's activity window).
+ *   - isMeta + currentTurn is null → opens a NEW turn (used by hook feedback
+ *     after a Stop force-closed the prior turn — retry assistant attributes
+ *     to this new turn).
+ *
+ * This keeps `/ironbee-verify` (no retry) at 1 turn (slash body merges into
+ * the `<command-message>` turn), while a verify-gate retry produces 2 turns
+ * (initial work + retry block) with all assistant work attributed correctly.
+ *
+ * The earlier "isMeta = full skip" approach inadvertently caused retry asst
+ * orphan; "content sniffing" was even worse (fragile against wrapper format
+ * changes). Continuation is the structurally clean middle ground.
+ */
+function isHumanTextUser(line) {
+    if (line.type !== "user" || line.message === undefined) {
+        return false;
+    }
+    const content = line.message.content;
+    if (typeof content === "string") {
+        return content.trim().length > 0;
+    }
+    if (Array.isArray(content)) {
+        for (const block of content) {
+            if (block !== null
+                && typeof block === "object"
+                && block.type === "text"
+                && typeof block.text === "string") {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+/** Returns true iff any block of the user message is `[Request interrupted by user…]`. */
+function isInterruptedUser(line) {
+    if (line.type !== "user" || line.message === undefined) {
+        return false;
+    }
+    const content = line.message.content;
+    if (typeof content === "string") {
+        return content.includes(INTERRUPT_MARKER);
+    }
+    if (Array.isArray(content)) {
+        for (const block of content) {
+            if (block !== null
+                && typeof block === "object"
+                && block.type === "text"
+                && typeof block.text === "string"
+                && block.text.includes(INTERRUPT_MARKER)) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+// ─────────────────────────────────────────────────────────────────────────
+// Per-tool attribution helpers
+// ─────────────────────────────────────────────────────────────────────────
+/** Empty ToolUsage slot — used to lazily seed `tools[name]`. */
+function emptyToolUsage() {
+    return {
+        count: 0,
+        errors: 0,
+        input_size: 0,
+        output_size: 0,
+        approximated_input_tokens: 0,
+        approximated_output_tokens: 0,
+    };
+}
+/**
+ * Map a response-time gap (ms) into one of the 7 canonical buckets used by
+ * downstream analytics. Mirrors Claude Code's `/insights` bucketing so the
+ * backend can render the same histogram without re-bucketing. Same clamp
+ * thresholds as `RESPONSE_TIME_MIN_SEC`/`RESPONSE_TIME_MAX_SEC` — values
+ * that would have been clamped out of `user_response_times_ms` are also
+ * not bucketed here.
+ */
+function responseTimeBucket(ms) {
+    const sec = ms / 1000;
+    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";
+}
+/** Format Date → "YYYY-MM-DD" (local timezone). */
+function formatDateKey(d) {
+    const y = String(d.getFullYear());
+    const m = String(d.getMonth() + 1).padStart(2, "0");
+    const day = String(d.getDate()).padStart(2, "0");
+    return `${y}-${m}-${day}`;
+}
+const WEEKDAY_NAMES = [
+    "sunday", "monday", "tuesday", "wednesday", "thursday", "friday", "saturday",
+];
+/** Format Date → "monday".."sunday" lowercase (local timezone). */
+function formatWeekdayKey(d) {
+    return WEEKDAY_NAMES[d.getDay()];
+}
+/**
+ * Extract MCP server name from a tool name that follows Anthropic's
+ * protocol form `mcp__<server>__<tool>`. Returns the server segment, or
+ * `undefined` for non-MCP tools or malformed names. Local helper to keep
+ * analytics free of client-specific imports.
+ *
+ * Examples:
+ *   `"mcp__browser-devtools__bdt_navigation_go-to"` → `"browser-devtools"`
+ *   `"mcp__node-devtools__ndt_debug_connect"`        → `"node-devtools"`
+ *   `"Read"`                                          → undefined
+ *   `"mcp__broken"`                                   → undefined
+ */
+function extractMcpServer(toolName) {
+    if (!toolName.startsWith("mcp__")) {
+        return undefined;
+    }
+    const rest = toolName.slice("mcp__".length);
+    const sep = rest.indexOf("__");
+    if (sep <= 0) {
+        return undefined;
+    }
+    return rest.slice(0, sep);
+}
+/**
+ * Strip the `mcp__<server>__` prefix from a tool name to get the bare
+ * tool identity. Native tools pass through unchanged. Same convention
+ * as `tool_call` events' `tool_name` field — keeps wire format
+ * symmetric so backend dashboards don't need to special-case MCP keys.
+ *
+ *   `"mcp__browser-devtools__bdt_navigation_go-to"` → `"bdt_navigation_go-to"`
+ *   `"Edit"`                                         → `"Edit"`
+ *   `"mcp__broken"`                                  → `"mcp__broken"` (unchanged)
+ */
+function bareTool(toolName) {
+    if (!toolName.startsWith("mcp__")) {
+        return toolName;
+    }
+    const rest = toolName.slice("mcp__".length);
+    const sep = rest.indexOf("__");
+    if (sep <= 0) {
+        return toolName;
+    }
+    return rest.slice(sep + 2);
+}
+/**
+ * Apply an `update(slot)` mutation to every bucket this tool_use belongs
+ * to. Always updates `tools[bareName]`. Conditionally updates server /
+ * bash binary / skill / sub-agent buckets when the corresponding
+ * sub-classification is present on the pending entry.
+ *
+ * Centralizes the multi-bucket parallel write so the same tool_use's
+ * tokens / cost / count / errors stay in lockstep across views — the
+ * sum of per-server values equals the per-tool sums for that server's
+ * tools, etc.
+ */
+function applyToBuckets(pending, update, buckets) {
+    const bare = bareTool(pending.tool_name);
+    const slotTool = buckets.tools[bare] ?? emptyToolUsage();
+    update(slotTool);
+    buckets.tools[bare] = slotTool;
+    const server = extractMcpServer(pending.tool_name);
+    if (server !== undefined) {
+        const slot = buckets.mcpServers[server] ?? emptyToolUsage();
+        update(slot);
+        buckets.mcpServers[server] = slot;
+    }
+    if (pending.bash_binary !== undefined) {
+        const slot = buckets.bashBinaries[pending.bash_binary] ?? emptyToolUsage();
+        update(slot);
+        buckets.bashBinaries[pending.bash_binary] = slot;
+    }
+    if (pending.skill_name !== undefined) {
+        const slot = buckets.skills[pending.skill_name] ?? emptyToolUsage();
+        update(slot);
+        buckets.skills[pending.skill_name] = slot;
+    }
+    if (pending.sub_agent_type !== undefined) {
+        const slot = buckets.subAgents[pending.sub_agent_type] ?? emptyToolUsage();
+        update(slot);
+        buckets.subAgents[pending.sub_agent_type] = slot;
+    }
+}
+/**
+ * Byte length of a content block for attribution purposes.
+ *   - tool_use → JSON.stringify(input)
+ *   - text     → utf-8 bytes of `text`
+ *   - any other (thinking, etc.) → JSON.stringify(block) as a generic fallback
+ *
+ * This is the unit of share computation for output-side attribution: a
+ * tool_use's share at its emitter assistant message N1 = its bytes /
+ * total bytes across all blocks of N1's content. Non-tool_use blocks
+ * (text, thinking) get their share routed to `unattributed_*`.
+ */
+function blockBytes(block) {
+    if (block.type === "tool_use") {
+        return Buffer.byteLength(JSON.stringify(block.input ?? {}), "utf-8");
+    }
+    if (block.type === "text" && typeof block.text === "string") {
+        return Buffer.byteLength(block.text, "utf-8");
+    }
+    // thinking blocks etc. — fall back to JSON.stringify so their bytes
+    // still feed the denominator (otherwise we'd over-attribute to tools).
+    return Buffer.byteLength(JSON.stringify(block), "utf-8");
+}
+/**
+ * Extract concatenated text from a user message's content blocks. Used
+ * locally inside projection for keyword regex matching — never persisted
+ * or emitted (privacy fence). Returns "" for non-user / non-text msgs.
+ */
+function extractUserMsgText(line) {
+    if (line.type !== "user" || line.message === undefined) {
+        return "";
+    }
+    const content = line.message.content;
+    if (typeof content === "string") {
+        return content;
+    }
+    if (!Array.isArray(content)) {
+        return "";
+    }
+    const parts = [];
+    for (const blk of content) {
+        if (blk === null || typeof blk !== "object") {
+            continue;
+        }
+        const block = blk;
+        if (block.type === "text" && typeof block.text === "string") {
+            parts.push(block.text);
+        }
+    }
+    return parts.join(" ");
+}
+/** Lazy-init the per-category breakdown slot. */
+function emptyCategoryStats() {
+    return { turns: 0, turns_with_edit: 0, turns_with_retry: 0, total_retries: 0, cost_usd: 0 };
+}
+/**
+ * Deterministic turn id — `sha256(session_id|turn_index|start_time)`
+ * sliced to 16 hex chars. Re-emits of the same turn produce the same
+ * id, so backend LWW per `(session_id, turn_id)` is well-defined.
+ */
+/**
+ * Deterministic per-step identifier — `sha256(turn_id|step_index|start_time)`
+ * sliced to 16 hex chars. Same property as {@link deriveTurnId}: same
+ * inputs always map to the same id, so backend LWW per `(session_id,
+ * step_id)` is well-defined and re-emits are idempotent.
+ */
+function deriveStepId(turnId, stepIndex, startTime) {
+    return (0, node_crypto_1.createHash)("sha256")
+        .update(`${turnId}|${stepIndex}|${startTime}`)
+        .digest("hex")
+        .slice(0, 16);
+}
+function deriveTurnId(sessionId, turnIndex, startTime) {
+    return (0, node_crypto_1.createHash)("sha256")
+        .update(`${sessionId}|${turnIndex}|${startTime}`)
+        .digest("hex")
+        .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.
+ */
+function formatHexAsUuid(hex32) {
+    return `${hex32.slice(0, 8)}-${hex32.slice(8, 12)}-${hex32.slice(12, 16)}-`
+        + `${hex32.slice(16, 20)}-${hex32.slice(20, 32)}`;
+}
+/**
+ * Deterministic Event.id for `session_analytics` wire records.
+ * `sha256("session_analytics:" + session_id + ":" + offset)`, formatted as
+ * UUID. Re-emits of the same `(session_id, offset)` produce the same id —
+ * backend treats them as updates to the same logical checkpoint:
+ *   - First Stop @ offset=100 (`is_final=false`)            → row inserted
+ *   - SessionEnd @ offset=100 (carve-out, `is_final=true`)  → ON CONFLICT update
+ *   - Worker re-projects same slice after crash             → ON CONFLICT update
+ * `snapshot_at` is intentionally NOT in the id — it's metadata for
+ * tiebreaking on collision (`UPDATE ... WHERE EXCLUDED.snapshot_at >=
+ * stored.snapshot_at`). This keeps `(session_id, id)` as a uniform dedup
+ * key across all analytics event types.
+ */
+function deriveSessionAnalyticsEventId(sessionId, offset) {
+    const hex = (0, node_crypto_1.createHash)("sha256")
+        .update(`session_analytics:${sessionId}:${offset}`)
+        .digest("hex");
+    return formatHexAsUuid(hex.slice(0, 32));
+}
+/**
+ * Deterministic Event.id for `session_turn_analytics` wire records.
+ * Derives from the turn's deterministic `turn_id` namespaced under the
+ * session — re-emits of the same turn produce the same Event.id.
+ */
+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));
+}
+/**
+ * Deterministic Event.id for `session_turn_step_analytics` wire records.
+ * Same pattern as {@link deriveTurnEventId} — derives from the step's
+ * deterministic `step_id` namespaced under the session. Re-emits idempotent.
+ */
+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));
+}
+/**
+ * Open a fresh turn from the human-user prompt that started it. Computes
+ * keyword flags eagerly from the user-msg text so we don't need to
+ * persist content. Caller threads this into `currentTurn` state.
+ *
+ * Per-turn aggregator maps are seeded empty; the projection walk
+ * mirrors every session-level update onto them (see `applyToBucketsAndTurn`
+ * + the inline `if (currentTurn !== null)` blocks in the assistant /
+ * user / tool_use / tool_result branches).
+ */
+function openTurn(userText, turnIndex, startTime, triggeredBy = "user_msg") {
+    const kw = (0, classifier_1.extractUserMsgKeywords)(userText);
+    return {
+        turn_index: turnIndex,
+        start_time: startTime,
+        triggered_by: triggeredBy,
+        last_activity_time: startTime,
+        kw_debug: kw.debug,
+        kw_feature: kw.feature,
+        kw_refactor: kw.refactor,
+        kw_brainstorm: kw.brainstorm,
+        kw_research: kw.research,
+        kw_file_pattern: kw.file_pattern,
+        kw_script_pattern: kw.script_pattern,
+        kw_url: kw.url,
+        has_edit: false, has_read: false, has_bash: false,
+        has_task: false, has_search: false, has_mcp: false,
+        has_skill: false, has_plan: false,
+        bash_test: false, bash_build: false, bash_install: false, bash_git: false,
+        saw_edit_pending_bash: false,
+        saw_bash_after_edit: false,
+        retries: 0,
+        assistant_messages: 0,
+        tool_calls: 0,
+        was_interrupted: false,
+        input_tokens: 0,
+        output_tokens: 0,
+        cache_creation_tokens: 0,
+        cache_read_tokens: 0,
+        cost_usd: 0,
+        tools: {},
+        mcp_servers: {},
+        bash_binaries: {},
+        bash_subcommands: {},
+        skills: {},
+        sub_agents: {},
+        models: {},
+        languages: {},
+        uses_sub_agent: false,
+        uses_skill: false,
+        uses_mcp: false,
+        uses_web_search: false,
+        uses_web_fetch: false,
+        file_change_counts: {},
+        lines_added: 0,
+        lines_removed: 0,
+        tool_errors: 0,
+        tool_error_categories: {},
+        context_tokens_samples: [],
+        context_tokens_latest: 0,
+        context_tokens_peak: 0,
+        process_errors: {},
+        // Per-step bookkeeping (cross-slice safe). `current_step` opens at
+        // the first assistant message of this turn; closes when the next
+        // assistant arrives (pushed to `completed_steps`) or when the turn
+        // closes. `next_step_index` resets per turn (steps are turn-scoped).
+        completed_steps: [],
+        next_step_index: 1,
+    };
+}
+/**
+ * Deep-copy a {@link CurrentTurnState} so the projection's mutating walk
+ * does not bleed into the caller's `state.internal.current_turn`. The
+ * shallow-copy `{ ...prior }` we used to do shared the inner maps + the
+ * `completed_steps` array (and that array gets `.push()`'d during the
+ * walk), which would otherwise mutate the persisted-state snapshot
+ * mid-emit. Defensive — every persist after this re-derives state, so
+ * the upstream effect never reaches disk; this just keeps the data flow
+ * pure so future code paths cannot reintroduce the pitfall.
+ *
+ * Maps / arrays at depth 1 are cloned. ToolUsage / ModelUsage / file_change
+ * map values themselves are shallow-copied (their fields are primitives).
+ * `current_step` and the entries of `completed_steps` are deep-copied via
+ * {@link cloneStep}.
+ */
+function cloneCurrentTurn(prior) {
+    return {
+        ...prior,
+        tools: cloneToolUsageMap(prior.tools),
+        mcp_servers: cloneToolUsageMap(prior.mcp_servers),
+        bash_binaries: cloneToolUsageMap(prior.bash_binaries),
+        bash_subcommands: { ...prior.bash_subcommands },
+        skills: cloneToolUsageMap(prior.skills),
+        sub_agents: cloneToolUsageMap(prior.sub_agents),
+        models: cloneModelUsageMap(prior.models),
+        languages: { ...prior.languages },
+        file_change_counts: { ...prior.file_change_counts },
+        tool_error_categories: { ...prior.tool_error_categories },
+        context_tokens_samples: [...prior.context_tokens_samples],
+        process_errors: cloneProcessErrors(prior.process_errors),
+        completed_steps: prior.completed_steps.map(cloneStep),
+        current_step: prior.current_step !== undefined ? cloneStep(prior.current_step) : undefined,
+    };
+}
+function cloneStep(prior) {
+    return {
+        ...prior,
+        tools: cloneToolUsageMap(prior.tools),
+        mcp_servers: cloneToolUsageMap(prior.mcp_servers),
+        bash_binaries: cloneToolUsageMap(prior.bash_binaries),
+        bash_subcommands: { ...prior.bash_subcommands },
+        skills: cloneToolUsageMap(prior.skills),
+        sub_agents: cloneToolUsageMap(prior.sub_agents),
+        models: cloneModelUsageMap(prior.models),
+        languages: { ...prior.languages },
+        file_change_counts: { ...prior.file_change_counts },
+        tool_error_categories: { ...prior.tool_error_categories },
+        process_errors: cloneProcessErrors(prior.process_errors),
+    };
+}
+function cloneToolUsageMap(map) {
+    const out = {};
+    for (const [k, v] of Object.entries(map)) {
+        out[k] = { ...v };
+    }
+    return out;
+}
+function cloneModelUsageMap(map) {
+    const out = {};
+    for (const [k, v] of Object.entries(map)) {
+        out[k] = { ...v };
+    }
+    return out;
+}
+function cloneProcessErrors(map) {
+    const out = {};
+    for (const [k, v] of Object.entries(map)) {
+        out[k] = { ...v };
+    }
+    return out;
+}
+/**
+ * Build a fresh in-flight per-step accumulator. Mirrors `openTurn` shape
+ * but step-scoped: every aggregator starts at zero / empty. Caller (the
+ * assistant-branch in the projection walk) records `step_index` and
+ * `start_time` from the opening assistant message.
+ */
+function openStep(stepIndex, startTime) {
+    return {
+        step_index: stepIndex,
+        start_time: startTime,
+        last_activity_time: startTime,
+        tool_calls: 0,
+        was_interrupted: false,
+        input_tokens: 0,
+        output_tokens: 0,
+        cache_creation_tokens: 0,
+        cache_read_tokens: 0,
+        cost_usd: 0,
+        tools: {},
+        mcp_servers: {},
+        bash_binaries: {},
+        bash_subcommands: {},
+        skills: {},
+        sub_agents: {},
+        models: {},
+        languages: {},
+        uses_sub_agent: false,
+        uses_skill: false,
+        uses_mcp: false,
+        uses_web_search: false,
+        uses_web_fetch: false,
+        file_change_counts: {},
+        lines_added: 0,
+        lines_removed: 0,
+        tool_errors: 0,
+        tool_error_categories: {},
+        process_errors: {},
+    };
+}
+/**
+ * Apply a {@link CloseTurnResult}'s `breakdown_delta` onto a category-
+ * breakdown map. Always WRITES A FRESH SLOT — never mutates the existing
+ * one in place. This decouples the post-merge mutation in emit.ts's
+ * finalize block from the slot-reference assumptions of any future
+ * `mergeCategoryBreakdown` refactor.
+ */
+function applyBreakdownDelta(breakdown, r) {
+    const slot = breakdown[r.category] ?? emptyCategoryStats();
+    breakdown[r.category] = {
+        turns: slot.turns + r.breakdown_delta.turns_inc,
+        turns_with_edit: slot.turns_with_edit + r.breakdown_delta.turns_with_edit_inc,
+        turns_with_retry: slot.turns_with_retry + r.turns_with_retry_inc,
+        total_retries: slot.total_retries + r.breakdown_delta.total_retries_inc,
+        cost_usd: slot.cost_usd + r.breakdown_delta.cost_usd_inc,
+    };
+}
+/**
+ * Close a turn — finalizes the per-turn record, runs the classifier,
+ * and produces a fully-built `SessionTurnAnalytics` for the wire plus
+ * the per-category breakdown delta the caller should apply.
+ *
+ * Pure function — does not mutate any input. `opts.endTime` is the
+ * closing event timestamp (next human-user msg, or session_end when
+ * finalizing). `opts.endReason` records which boundary fired so backend
+ * can distinguish normal turn ends from session-end forced closes.
+ */
+function closeTurn(turn, opts) {
+    const { endTime, endReason, sessionId, projectName, transcriptSource } = opts;
+    const category = (0, classifier_1.classifyTurn)({
+        user_msg_keywords: {
+            debug: turn.kw_debug, feature: turn.kw_feature, refactor: turn.kw_refactor,
+            brainstorm: turn.kw_brainstorm, research: turn.kw_research,
+            file_pattern: turn.kw_file_pattern, script_pattern: turn.kw_script_pattern, url: turn.kw_url,
+        },
+        tool_buckets: {
+            edit: turn.has_edit, read: turn.has_read, bash: turn.has_bash,
+            task: turn.has_task, search: turn.has_search, mcp: turn.has_mcp,
+            skill: turn.has_skill, plan: turn.has_plan,
+        },
+        bash_cmd_flags: {
+            test: turn.bash_test, build: turn.bash_build,
+            install: turn.bash_install, git: turn.bash_git,
+        },
+    });
+    const turnHadRetry = turn.retries > 0;
+    // `was_one_shot` means "agent got it right on the first attempt." A
+    // host_inject turn (verify-gate retry continuation, etc.) is BY
+    // DEFINITION not first-try work — it exists only because a prior turn
+    // failed. Gate one_shot on user_msg trigger so retry turns never
+    // inflate session-level "first-try success rate" dashboards.
+    const oneShot = turn.has_edit && !turnHadRetry && turn.triggered_by === "user_msg";
+    // Time math — duration in ms (default unit). Fallbacks keep the
+    // record well-formed even if either timestamp is missing.
+    const startMs = Date.parse(turn.start_time);
+    const endMs = Date.parse(endTime);
+    const startValid = !Number.isNaN(startMs);
+    const endValid = !Number.isNaN(endMs);
+    const duration = startValid && endValid ? Math.max(0, endMs - startMs) : 0;
+    const startHour = startValid ? new Date(startMs).getHours() : 0;
+    const endHour = endValid ? new Date(endMs).getHours() : 0;
+    // Per-turn files_changed — sort desc by change_count, asc by path
+    // tie-break (matches session-level hot_files determinism).
+    const filesChanged = Object.entries(turn.file_change_counts)
+        .map(([path, change_count]) => ({ path, change_count }))
+        .sort((a, b) => {
+        if (b.change_count !== a.change_count) {
+            return b.change_count - a.change_count;
+        }
+        return a.path.localeCompare(b.path);
+    });
+    const turnEvent = {
+        session_id: sessionId,
+        project_name: projectName,
+        schema_version: types_1.SCHEMA_VERSION,
+        transcript_source: transcriptSource,
+        turn_index: turn.turn_index,
+        turn_id: deriveTurnId(sessionId, turn.turn_index, turn.start_time),
+        triggered_by: turn.triggered_by,
+        start_time: turn.start_time,
+        end_time: endTime,
+        end_reason: endReason,
+        start_hour: startHour,
+        end_hour: endHour,
+        duration,
+        category,
+        was_one_shot: oneShot,
+        was_interrupted: turn.was_interrupted,
+        assistant_messages: turn.assistant_messages,
+        tool_calls: turn.tool_calls,
+        retries: turn.retries,
+        // Logical groups
+        usage: {
+            input_tokens: turn.input_tokens,
+            output_tokens: turn.output_tokens,
+            cache_creation_tokens: turn.cache_creation_tokens,
+            cache_read_tokens: turn.cache_read_tokens,
+            cost_usd: turn.cost_usd,
+        },
+        // Per-tool breakdowns (top-level)
+        tools: turn.tools,
+        mcp_servers: turn.mcp_servers,
+        bash_binaries: turn.bash_binaries,
+        skills: turn.skills,
+        sub_agents: turn.sub_agents,
+        models: turn.models,
+        tool_meta: {
+            ...(Object.keys(turn.bash_subcommands).length > 0 ? { bash_subcommands: turn.bash_subcommands } : {}),
+            uses_sub_agent: turn.uses_sub_agent,
+            uses_skill: turn.uses_skill,
+            uses_mcp: turn.uses_mcp,
+            uses_web_search: turn.uses_web_search,
+            uses_web_fetch: turn.uses_web_fetch,
+        },
+        code_changes: {
+            files_modified: filesChanged.length,
+            lines_added: turn.lines_added,
+            lines_removed: turn.lines_removed,
+            hot_files: filesChanged,
+            languages: turn.languages,
+        },
+        errors: {
+            tool_errors_total: turn.tool_errors,
+            tool_error_categories: turn.tool_error_categories,
+            user_interruptions: turn.was_interrupted ? 1 : 0,
+        },
+        process_errors: {
+            has: Object.keys(turn.process_errors).length > 0,
+            items: turn.process_errors,
+        },
+        context_tokens_samples: turn.context_tokens_samples,
+        context_tokens_latest: turn.context_tokens_latest,
+        context_tokens_peak: turn.context_tokens_peak,
+    };
+    // ── Build per-step events ────────────────────────────────────────────
+    // Close the in-flight current_step (if any) by appending it to
+    // completed_steps. closeTurn is a pure function — we operate on a local
+    // copy so the input `turn` is not mutated. Callers that read
+    // `turn.completed_steps` post-close should be aware: those steps live
+    // inside the turn's snapshot and are consumed by this build.
+    const allSteps = turn.current_step !== undefined
+        ? [...turn.completed_steps, turn.current_step]
+        : [...turn.completed_steps];
+    const turnId = turnEvent.turn_id;
+    const stepEvents = allSteps.map((step, idx) => {
+        const isLast = idx === allSteps.length - 1;
+        const stepStartMs = Date.parse(step.start_time);
+        const stepEndStr = step.last_activity_time !== "" ? step.last_activity_time : step.start_time;
+        const stepEndMs = Date.parse(stepEndStr);
+        const stepDuration = !Number.isNaN(stepStartMs) && !Number.isNaN(stepEndMs)
+            ? Math.max(0, stepEndMs - stepStartMs)
+            : 0;
+        const stepStartHour = !Number.isNaN(stepStartMs) ? new Date(stepStartMs).getHours() : 0;
+        const stepEndHour = !Number.isNaN(stepEndMs) ? new Date(stepEndMs).getHours() : 0;
+        // Per-step files_changed — same sort rules as turn-level.
+        const stepFiles = Object.entries(step.file_change_counts)
+            .map(([path, change_count]) => ({ path, change_count }))
+            .sort((a, b) => {
+            if (b.change_count !== a.change_count) {
+                return b.change_count - a.change_count;
+            }
+            return a.path.localeCompare(b.path);
+        });
+        const stepEvent = {
+            session_id: sessionId,
+            project_name: projectName,
+            schema_version: types_1.SCHEMA_VERSION,
+            transcript_source: transcriptSource,
+            turn_id: turnId,
+            turn_index: turn.turn_index,
+            triggered_by: turn.triggered_by,
+            step_id: deriveStepId(turnId, step.step_index, step.start_time),
+            step_index: step.step_index,
+            start_time: step.start_time,
+            end_time: stepEndStr,
+            start_hour: stepStartHour,
+            end_hour: stepEndHour,
+            duration: stepDuration,
+            is_last_step: isLast,
+            ...(isLast ? {
+                turn_end_reason: endReason,
+                turn_end_time: endTime,
+                turn_duration: duration,
+                turn_category: category,
+                turn_was_one_shot: oneShot,
+                turn_was_interrupted: turn.was_interrupted,
+            } : {}),
+            assistant_messages: 1,
+            tool_calls: step.tool_calls,
+            was_interrupted: step.was_interrupted,
+            // Logical groups
+            usage: {
+                input_tokens: step.input_tokens,
+                output_tokens: step.output_tokens,
+                cache_creation_tokens: step.cache_creation_tokens,
+                cache_read_tokens: step.cache_read_tokens,
+                cost_usd: step.cost_usd,
+            },
+            // Per-tool breakdowns (top-level)
+            tools: step.tools,
+            mcp_servers: step.mcp_servers,
+            bash_binaries: step.bash_binaries,
+            skills: step.skills,
+            sub_agents: step.sub_agents,
+            models: step.models,
+            tool_meta: {
+                ...(Object.keys(step.bash_subcommands).length > 0 ? { bash_subcommands: step.bash_subcommands } : {}),
+                uses_sub_agent: step.uses_sub_agent,
+                uses_skill: step.uses_skill,
+                uses_mcp: step.uses_mcp,
+                uses_web_search: step.uses_web_search,
+                uses_web_fetch: step.uses_web_fetch,
+            },
+            code_changes: {
+                files_modified: stepFiles.length,
+                lines_added: step.lines_added,
+                lines_removed: step.lines_removed,
+                hot_files: stepFiles,
+                languages: step.languages,
+            },
+            errors: {
+                tool_errors_total: step.tool_errors,
+                tool_error_categories: step.tool_error_categories,
+                user_interruptions: step.was_interrupted ? 1 : 0,
+            },
+            process_errors: {
+                has: Object.keys(step.process_errors).length > 0,
+                items: step.process_errors,
+            },
+            ...(step.context_tokens !== undefined ? { context_tokens: step.context_tokens } : {}),
+        };
+        return stepEvent;
+    });
+    return {
+        category,
+        turns_with_retry_inc: turnHadRetry ? 1 : 0,
+        one_shot_inc: oneShot ? 1 : 0,
+        breakdown_delta: {
+            turns_inc: 1,
+            turns_with_edit_inc: turn.has_edit ? 1 : 0,
+            total_retries_inc: turn.retries,
+            cost_usd_inc: turn.cost_usd,
+        },
+        turn_event: turnEvent,
+        step_events: stepEvents,
+    };
+}
+/**
+ * Wrapper around {@link applyToBuckets} that ALSO applies the same
+ * mutation onto the per-turn aggregator buckets (when a turn is open).
+ * Keeps session-level and per-turn views in lockstep so the per-turn
+ * sums always reconcile against the session-level rollup.
+ */
+function applyToBucketsAndTurn(pending, update, sliceBuckets, turn) {
+    applyToBuckets(pending, update, sliceBuckets);
+    if (turn !== null) {
+        applyToBuckets(pending, update, {
+            tools: turn.tools,
+            mcpServers: turn.mcp_servers,
+            bashBinaries: turn.bash_binaries,
+            skills: turn.skills,
+            subAgents: turn.sub_agents,
+        });
+        // Mirror onto the in-flight step too, when one is open. Step
+        // attribution follows the same emit-vs-consume rule as turn —
+        // whichever step is current at the mutation point owns the work
+        // (output-side at emit; input-side credit to the step that
+        // consumes the result, even if that's the next step).
+        if (turn.current_step !== undefined) {
+            applyToBuckets(pending, update, {
+                tools: turn.current_step.tools,
+                mcpServers: turn.current_step.mcp_servers,
+                bashBinaries: turn.current_step.bash_binaries,
+                skills: turn.current_step.skills,
+                subAgents: turn.current_step.sub_agents,
+            });
+        }
+    }
+}
+// ─────────────────────────────────────────────────────────────────────────
+// Main projection
+// ─────────────────────────────────────────────────────────────────────────
+function projectDelta(input) {
+    const { lines, startingTurnIndex, sessionId, projectName, transcriptSource } = input;
+    // Counters
+    let userTurns = 0;
+    // Per-API-request collector — one APIRequestAnalytics body per assistant
+    // line we project (success + failure). Drained by emit alongside turn /
+    // step events. Body-only struct; emit wraps with the Event envelope.
+    const apiRequestEvents = [];
+    let assistantResponseCount = 0;
+    let inputTokens = 0;
+    let outputTokens = 0;
+    let cacheCreationTokens = 0;
+    let cacheReadTokens = 0;
+    let costUsd = 0;
+    let toolErrorsTotal = 0;
+    let userInterruptions = 0;
+    let linesAdded = 0;
+    let linesRemoved = 0;
+    // Maps & arrays
+    // (tool_counts removed — derive from `tools[*].count`; bash_binaries
+    // is a ToolUsage map; bash_subcommands stays count-only.)
+    const bashSubcommands = {};
+    const languages = {};
+    const toolErrorCategories = {};
+    const filePathChangeCounts = {};
+    const distinctFilePaths = new Set();
+    // User-activity histograms. Counter-map merge rule (per-key sum) handles
+    // cross-slice aggregation. No per-msg arrays — privacy-clean and cheaper
+    // to merge across long sessions.
+    const responseTimeBuckets = {};
+    const messagesByHour = {};
+    const messagesByDate = {};
+    const messagesByWeekday = {};
+    // user_messages aggregate — count + size (bytes of human-typed text
+    // content) + approximated_tokens (recomputed at delta build).
+    let userMessagesCount = 0;
+    let userMessagesSize = 0;
+    const models = {};
+    // Per-tool attribution state.
+    // `tools` is the per-key delta of tool→usage; `pendingToolUses` is the
+    // in-flight cross-slice state machine (see PendingToolUse type docs).
+    const tools = {};
+    // MCP server roll-up — per-server aggregate of every numeric ToolUsage
+    // field across all tools belonging to that server. Updated alongside
+    // `tools` in every attribution path (output share, input share, count,
+    // errors). Server name extracted from `mcp__<server>__<tool>` prefix.
+    const mcpServers = {};
+    // Per-Bash-binary roll-up — keyed by the first token of each Bash
+    // command body (e.g. "git", "npm", "pytest", "docker").
+    const bashBinariesRich = {};
+    // Per-skill roll-up — keyed by `Skill` tool's `input.skill`.
+    const skills = {};
+    // Per-sub-agent roll-up — keyed by `Agent` / `Task` tool's
+    // `input.subagent_type`.
+    const subAgents = {};
+    const pendingToolUses = {
+        ...(input.priorPendingToolUses ?? {}),
+    };
+    // Unattributed residuals — text content + history-reading + cache.
+    let unattributedInputTokens = 0;
+    let unattributedOutputTokens = 0;
+    let unattributedCacheCreationTokens = 0;
+    let unattributedCacheReadTokens = 0;
+    let unattributedCostUsd = 0;
+    // Per-tool token attribution was previously a two-phase state machine
+    // (emitter / resulted / consumer-applies). The current pipeline is a
+    // simple byte counter — `tool_result` handler writes `output_size`
+    // directly into the bucket and removes the pending entry. The locals
+    // below are kept (always empty / 0) so call sites that still touch
+    // them are harmless; remove together when the call sites are cleaned.
+    let resultedToolUseIds = [];
+    let priorUserMsgTextBytes = 0;
+    // Boolean flags
+    let usesSubAgent = false;
+    let usesSkill = false;
+    let usesMcp = false;
+    let usesWebSearch = false;
+    let usesWebFetch = false;
+    // Bounds
+    let firstTimestamp = "";
+    let lastTimestamp = "";
+    // Context-tokens distribution
+    const contextTokensBuckets = {};
+    let contextTokensLatest = 0;
+    let contextTokensPeak = 0;
+    let hasAssistantWithUsage = false;
+    // Per-projection error capture map. Recurring errors collapse into a
+    // single entry whose `count` increments — same as the merge step does
+    // across deltas. Surfaces parse / format / projector bugs without
+    // flooding the wire.
+    const processErrors = {};
+    // For response-time calculation. Seeded from prior slice (if any) so the
+    // gap from prior-slice's last assistant to this-slice's first human user
+    // is captured.
+    let lastAssistantMs = input.priorLastAssistantTsMs ?? null;
+    let assistantTurnIndex = startingTurnIndex - 1; // bumped on each assistant message
+    // Anthropic API msg_id dedup. Claude Code's transcript writer occasionally
+    // persists the SAME assistant API response across multiple JSONL lines
+    // (different uuids, identical message.id + requestId + usage). Seeded from
+    // prior slices so a duplicate that crosses a slice boundary is still caught.
+    // Reported back via DeltaInternal.seen_assistant_message_ids.
+    const seenAssistantMessageIds = new Set(input.priorSeenAssistantMessageIds ?? []);
+    const newAssistantMessageIdsThisSlice = [];
+    // 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
+    // slice's last message so cross-slice idle is captured correctly. The
+    // raw idle gap can be larger than the project's wall-clock if state was
+    // reset; the merge step clamps `active_minutes ≥ 0`.
+    let priorTsMs = input.priorLastActivityTsMs ?? null;
+    let idleMsInSlice = 0;
+    // Per-turn classifier state. `currentTurn` is null between turns; opens
+    // on a human-user message and closes when the NEXT human-user msg
+    // arrives (or session finalization). Cross-slice continuity comes from
+    // `priorCurrentTurn` — a turn straddling a slice boundary resumes here.
+    const categoryBreakdown = {};
+    let turnsWithRetryInSlice = 0;
+    let oneShotTurnsInSlice = 0;
+    let currentTurn = input.priorCurrentTurn !== undefined
+        ? cloneCurrentTurn(input.priorCurrentTurn)
+        : null;
+    // Monotonic per-session turn index — seed from prior slice's persisted
+    // counter (state.internal.next_turn_index), default 1 on first ever
+    // slice. Each call to openTurn assigns this then increments.
+    let nextTurnIndex = input.priorNextTurnIndex ?? 1;
+    // SessionTurnAnalytics records that closed during this slice. Reported
+    // on the delta; merge appends them to state.internal.pending_turn_events.
+    const completedTurns = [];
+    // SessionTurnStepAnalytics records belonging to closed turns — collected
+    // alongside completedTurns from each closeTurn() result. Same merge path:
+    // appended to state.internal.pending_step_events; emit drains.
+    const completedSteps = [];
+    let lineIndex = -1;
+    for (const line of lines) {
+        lineIndex += 1;
+        // Per-line try/catch — an unexpected transcript shape on one line
+        // must never abort the rest of the slice. Failures are recorded into
+        // `processErrors` (deduped by signature) and surfaced via
+        // `SessionAnalytics.process_errors` so we get visibility into format
+        // drift without silent loss.
+        try {
+            const tsString = line.timestamp;
+            const tsMillis = tsMs(tsString);
+            // Track bounds (first / last timestamp seen — first only set once)
+            if (typeof tsString === "string" && tsString.length > 0) {
+                if (firstTimestamp === "") {
+                    firstTimestamp = tsString;
+                }
+                // last_timestamp is updated per Bounds-latest rule via merge;
+                // we just record the last one we see in this delta.
+                lastTimestamp = tsString;
+            }
+            // Idle attribution: gap-before-human-user counts as user-idle,
+            // every other gap is active (model + tools + agent loop). The
+            // priorTsMs cursor seeds from the prior slice's last_activity_time
+            // so cross-slice gaps land on the correct side.
+            if (tsMillis !== null) {
+                if (priorTsMs !== null && isHumanTextUser(line)) {
+                    const gap = tsMillis - priorTsMs;
+                    if (gap > 0) {
+                        idleMsInSlice += gap;
+                    }
+                }
+                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.
+                const msgId = line.message.id;
+                if (typeof msgId === "string" && msgId.length > 0) {
+                    if (seenAssistantMessageIds.has(msgId)) {
+                        // Duplicate API response re-emit — silently skip.
+                        continue;
+                    }
+                    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;
+                    }
+                    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 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;
+                    }
+                }
+                // 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;
+                        }
+                        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.
+                    if (currentTurn !== null) {
+                        const turnSlot = currentTurn.models[model] ?? {
+                            count: 0,
+                            input_tokens: 0,
+                            output_tokens: 0,
+                            cache_creation_tokens: 0,
+                            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] ?? {
+                                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;
+                            }
+                            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 = [];
+                // Walk content blocks for tool_use entries.
+                // ── Per-tool emitter: byte counter ──────────────────────────
+                // Each tool_use bumps the corresponding tool/mcp_server/skill/
+                // sub_agent/bash_binary bucket's `input_size` by the JSON
+                // byte length of `tool_use.input` (this is the model→tool
+                // direction, hence "input"). Output bytes are recorded later
+                // when the matching tool_result arrives — see the user-msg
+                // branch's tool_result handler (it derives the tool's bucket
+                // via the pending entry and adds to `output_size`). No
+                // per-tool token / cost attribution here.
+                const content = line.message.content;
+                if (Array.isArray(content)) {
+                    const buckets = {
+                        tools, mcpServers, bashBinaries: bashBinariesRich, skills, subAgents,
+                    };
+                    for (const blk of content) {
+                        if (blk === null || typeof blk !== "object") {
+                            continue;
+                        }
+                        const block = blk;
+                        if (block.type !== "tool_use"
+                            || typeof block.name !== "string"
+                            || typeof block.id !== "string"
+                            || block.id.length === 0) {
+                            continue;
+                        }
+                        const inputJsonBytes = Buffer.byteLength(JSON.stringify(block.input ?? {}), "utf-8");
+                        // Sub-classification — same mutual-exclusion rules as before.
+                        let bashBinary;
+                        let skillName;
+                        let subAgentType;
+                        const inp = block.input;
+                        if (inp !== undefined) {
+                            if (block.name === "Bash") {
+                                const cmd = inp.command;
+                                if (typeof cmd === "string") {
+                                    bashBinary = extractBashBinary(cmd);
+                                }
+                            }
+                            else if (block.name === "Skill") {
+                                const sk = inp.skill;
+                                if (typeof sk === "string" && sk.length > 0) {
+                                    skillName = sk;
+                                }
+                            }
+                            else if (block.name === "Agent" || block.name === "Task") {
+                                const sa = inp.subagent_type;
+                                if (typeof sa === "string" && sa.length > 0) {
+                                    subAgentType = sa;
+                                }
+                            }
+                        }
+                        const pending = {
+                            tool_name: block.name,
+                            ...(bashBinary !== undefined ? { bash_binary: bashBinary } : {}),
+                            ...(skillName !== undefined ? { skill_name: skillName } : {}),
+                            ...(subAgentType !== undefined ? { sub_agent_type: subAgentType } : {}),
+                            ...(currentTurn !== null ? { originating_turn_index: currentTurn.turn_index } : {}),
+                        };
+                        applyToBucketsAndTurn(pending, (slot) => {
+                            slot.input_size += inputJsonBytes;
+                            slot.approximated_input_tokens = slot.input_size / pricing_1.BYTES_PER_TOKEN;
+                        }, buckets, currentTurn);
+                        // Pending entry survives until the tool_result lands;
+                        // the user-msg branch's tool_result handler uses it
+                        // to look up which tool/mcp_server/skill/etc. bucket
+                        // the tool_result.content bytes belong to.
+                        pendingToolUses[block.id] = pending;
+                    }
+                }
+                void msgOutput; // output side is not per-tool attributed
+                // Per-message tool-bucket flag accumulator for the classifier
+                // retry state machine. Computed locally within this assistant
+                // message; merged into currentTurn at the end.
+                const msgBuckets = (0, classifier_1.emptyToolBucketFlags)();
+                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.name === "string") {
+                            const toolName = block.name;
+                            // Per-tool breakdown count — also update mcp_servers,
+                            // bash_binaries, skills, sub_agents in the same step.
+                            // Build a lightweight pending-shaped record from this
+                            // tool_use for the multi-bucket helper.
+                            let bashBinaryHere;
+                            let skillNameHere;
+                            let subAgentTypeHere;
+                            const inpHere = block.input;
+                            if (inpHere !== undefined) {
+                                if (toolName === "Bash") {
+                                    const cmdRaw = inpHere.command;
+                                    if (typeof cmdRaw === "string") {
+                                        bashBinaryHere = extractBashBinary(cmdRaw);
+                                    }
+                                }
+                                else if (toolName === "Skill") {
+                                    const skRaw = inpHere.skill;
+                                    if (typeof skRaw === "string" && skRaw.length > 0) {
+                                        skillNameHere = skRaw;
+                                    }
+                                }
+                                else if (toolName === "Agent" || toolName === "Task") {
+                                    const saRaw = inpHere.subagent_type;
+                                    if (typeof saRaw === "string" && saRaw.length > 0) {
+                                        subAgentTypeHere = saRaw;
+                                    }
+                                }
+                            }
+                            const pendingShape = {
+                                tool_name: toolName,
+                                ...(bashBinaryHere !== undefined ? { bash_binary: bashBinaryHere } : {}),
+                                ...(skillNameHere !== undefined ? { skill_name: skillNameHere } : {}),
+                                ...(subAgentTypeHere !== undefined ? { sub_agent_type: subAgentTypeHere } : {}),
+                                ...(currentTurn !== null ? { originating_turn_index: currentTurn.turn_index } : {}),
+                            };
+                            applyToBucketsAndTurn(pendingShape, (slot) => { slot.count += 1; }, { tools, mcpServers, bashBinaries: bashBinariesRich, skills, subAgents }, currentTurn);
+                            // Per-turn: count this tool_use. Mirror onto step.
+                            if (currentTurn !== null) {
+                                currentTurn.tool_calls += 1;
+                                if (currentTurn.current_step !== undefined) {
+                                    currentTurn.current_step.tool_calls += 1;
+                                }
+                            }
+                            // Classifier — update tool-bucket flags for this message
+                            // and the running turn state.
+                            (0, classifier_1.applyToolBucketFlags)(msgBuckets, toolName);
+                            if (currentTurn !== null) {
+                                (0, classifier_1.applyToolBucketFlags)({
+                                    edit: currentTurn.has_edit, read: currentTurn.has_read,
+                                    bash: currentTurn.has_bash, task: currentTurn.has_task,
+                                    search: currentTurn.has_search, mcp: currentTurn.has_mcp,
+                                    skill: currentTurn.has_skill, plan: currentTurn.has_plan,
+                                }, toolName);
+                                // applyToolBucketFlags ORs into a NEW object above —
+                                // we need to re-OR onto currentTurn. Just call again
+                                // directly on a flags-shaped view of currentTurn:
+                                currentTurn.has_edit = currentTurn.has_edit || msgBuckets.edit;
+                                currentTurn.has_read = currentTurn.has_read || msgBuckets.read;
+                                currentTurn.has_bash = currentTurn.has_bash || msgBuckets.bash;
+                                currentTurn.has_task = currentTurn.has_task || msgBuckets.task;
+                                currentTurn.has_search = currentTurn.has_search || msgBuckets.search;
+                                currentTurn.has_mcp = currentTurn.has_mcp || msgBuckets.mcp;
+                                currentTurn.has_skill = currentTurn.has_skill || msgBuckets.skill;
+                                currentTurn.has_plan = currentTurn.has_plan || msgBuckets.plan;
+                            }
+                            if (toolName === "Task" || toolName === "Agent") {
+                                usesSubAgent = true;
+                                if (currentTurn !== null) {
+                                    currentTurn.uses_sub_agent = true;
+                                    if (currentTurn.current_step !== undefined) {
+                                        currentTurn.current_step.uses_sub_agent = true;
+                                    }
+                                }
+                            }
+                            if (toolName === "Skill") {
+                                usesSkill = true;
+                                if (currentTurn !== null) {
+                                    currentTurn.uses_skill = true;
+                                    if (currentTurn.current_step !== undefined) {
+                                        currentTurn.current_step.uses_skill = true;
+                                    }
+                                }
+                            }
+                            if (toolName.startsWith("mcp__")) {
+                                usesMcp = true;
+                                if (currentTurn !== null) {
+                                    currentTurn.uses_mcp = true;
+                                    if (currentTurn.current_step !== undefined) {
+                                        currentTurn.current_step.uses_mcp = true;
+                                    }
+                                }
+                            }
+                            if (toolName === "WebSearch") {
+                                usesWebSearch = true;
+                                if (currentTurn !== null) {
+                                    currentTurn.uses_web_search = true;
+                                    if (currentTurn.current_step !== undefined) {
+                                        currentTurn.current_step.uses_web_search = true;
+                                    }
+                                }
+                            }
+                            if (toolName === "WebFetch") {
+                                usesWebFetch = true;
+                                if (currentTurn !== null) {
+                                    currentTurn.uses_web_fetch = true;
+                                    if (currentTurn.current_step !== undefined) {
+                                        currentTurn.current_step.uses_web_fetch = true;
+                                    }
+                                }
+                            }
+                            const inp = block.input;
+                            if (inp !== undefined) {
+                                // Languages + files_modified — driven by file_path
+                                const filePath = inp.file_path;
+                                if (typeof filePath === "string" && filePath.length > 0) {
+                                    if (toolName === "Edit" || toolName === "Write") {
+                                        distinctFilePaths.add(filePath);
+                                        filePathChangeCounts[filePath] =
+                                            (filePathChangeCounts[filePath] ?? 0) + 1;
+                                        if (currentTurn !== null) {
+                                            currentTurn.file_change_counts[filePath] =
+                                                (currentTurn.file_change_counts[filePath] ?? 0) + 1;
+                                            if (currentTurn.current_step !== undefined) {
+                                                currentTurn.current_step.file_change_counts[filePath] =
+                                                    (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;
+                                            }
+                                        }
+                                    }
+                                }
+                                // Bash — count git_commits / git_pushes via substring,
+                                // but emit only the binary + subcommand labels.
+                                if (toolName === "Bash") {
+                                    const cmd = inp.command;
+                                    if (typeof cmd === "string") {
+                                        // bash_binaries count is incremented above via
+                                        // applyToBuckets — no separate update needed here.
+                                        const sub = extractBashSubcommand(cmd);
+                                        if (sub !== undefined) {
+                                            bashSubcommands[sub] = (bashSubcommands[sub] ?? 0) + 1;
+                                            if (currentTurn !== null) {
+                                                currentTurn.bash_subcommands[sub] =
+                                                    (currentTurn.bash_subcommands[sub] ?? 0) + 1;
+                                                if (currentTurn.current_step !== undefined) {
+                                                    currentTurn.current_step.bash_subcommands[sub] =
+                                                        (currentTurn.current_step.bash_subcommands[sub] ?? 0) + 1;
+                                                }
+                                            }
+                                        }
+                                        // Classifier — scan command body for
+                                        // test/build/install/git keywords. Match
+                                        // outcomes are booleans, not text.
+                                        if (currentTurn !== null) {
+                                            const bashFlags = (0, classifier_1.emptyBashCmdFlags)();
+                                            (0, classifier_1.applyBashCmdFlags)(bashFlags, cmd);
+                                            currentTurn.bash_test = currentTurn.bash_test || bashFlags.test;
+                                            currentTurn.bash_build = currentTurn.bash_build || bashFlags.build;
+                                            currentTurn.bash_install = currentTurn.bash_install || bashFlags.install;
+                                            currentTurn.bash_git = currentTurn.bash_git || bashFlags.git;
+                                        }
+                                    }
+                                }
+                                // Edit — line-diff via the diff package
+                                if (toolName === "Edit") {
+                                    const oldS = inp.old_string;
+                                    const newS = inp.new_string;
+                                    if (typeof oldS === "string" && typeof newS === "string") {
+                                        try {
+                                            for (const chg of (0, diff_1.diffLines)(oldS, newS)) {
+                                                if (chg.added) {
+                                                    linesAdded += chg.count ?? 0;
+                                                    if (currentTurn !== null) {
+                                                        currentTurn.lines_added += chg.count ?? 0;
+                                                        if (currentTurn.current_step !== undefined) {
+                                                            currentTurn.current_step.lines_added += chg.count ?? 0;
+                                                        }
+                                                    }
+                                                }
+                                                else if (chg.removed) {
+                                                    linesRemoved += chg.count ?? 0;
+                                                    if (currentTurn !== null) {
+                                                        currentTurn.lines_removed += chg.count ?? 0;
+                                                        if (currentTurn.current_step !== undefined) {
+                                                            currentTurn.current_step.lines_removed += chg.count ?? 0;
+                                                        }
+                                                    }
+                                                }
+                                            }
+                                        }
+                                        catch (e) {
+                                            logger_1.logger.debug(`projection: diffLines failed: ${e instanceof Error ? e.message : e}`);
+                                        }
+                                    }
+                                }
+                                // Write — count newlines in content (all "added").
+                                if (toolName === "Write") {
+                                    const wc = inp.content;
+                                    if (typeof wc === "string" && wc.length > 0) {
+                                        let nl = 1; // last line counts even without trailing \n
+                                        for (let i = 0; i < wc.length; i++) {
+                                            if (wc.charCodeAt(i) === 0x0a) {
+                                                nl += 1;
+                                            }
+                                        }
+                                        linesAdded += nl;
+                                        if (currentTurn !== null) {
+                                            currentTurn.lines_added += nl;
+                                            if (currentTurn.current_step !== undefined) {
+                                                currentTurn.current_step.lines_added += nl;
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+                // End-of-message classifier update: retry detection +
+                // per-turn cost accumulation. Only if we have an open turn.
+                if (currentTurn !== null) {
+                    if (msgBuckets.edit) {
+                        if (currentTurn.saw_bash_after_edit) {
+                            currentTurn.retries += 1;
+                        }
+                        currentTurn.saw_edit_pending_bash = true;
+                        currentTurn.saw_bash_after_edit = false;
+                    }
+                    if (msgBuckets.bash && currentTurn.saw_edit_pending_bash) {
+                        currentTurn.saw_bash_after_edit = true;
+                    }
+                    currentTurn.cost_usd += msgCost;
+                    if (currentTurn.current_step !== undefined) {
+                        currentTurn.current_step.cost_usd += msgCost;
+                    }
+                }
+            }
+            if (line.type === "user" && line.message !== undefined) {
+                const isHuman = isHumanTextUser(line);
+                const isInterrupted = isInterruptedUser(line);
+                // Attribute `was_interrupted` to the turn that was ACTIVE when
+                // the interrupt arrived — i.e., the soon-to-close prior turn,
+                // not the one this same user msg may about to open. Real
+                // Claude interrupts arrive as text user msgs containing the
+                // INTERRUPT_MARKER, so they trip both `isHumanTextUser` AND
+                // `isInterruptedUser`. Without setting the flag here, the
+                // close/open cycle below would close the wrong turn cleanly
+                // and tag the new (restart) turn instead.
+                if (isInterrupted && currentTurn !== null) {
+                    currentTurn.was_interrupted = true;
+                    if (currentTurn.current_step !== undefined) {
+                        currentTurn.current_step.was_interrupted = true;
+                    }
+                }
+                if (isHuman) {
+                    // isMeta=true + currentTurn open → CONTINUATION semantic.
+                    // Host-injected user msgs (slash command bodies, hook
+                    // feedback) that arrive while a turn is still in-flight
+                    // are part of that turn's logical work — no new boundary.
+                    // Just extend the open turn's activity window so timing
+                    // bookkeeping stays accurate; do NOT increment user_turns
+                    // (it's not a distinct user action).
+                    //
+                    // isMeta=true + currentTurn null → opens a NEW turn. This
+                    // is the hook-feedback-after-Stop path: the prior turn was
+                    // force-closed at Stop, so retry assistant work needs a
+                    // fresh turn to attribute to. Treated as a normal turn
+                    // open below.
+                    const isContinuation = line.isMeta === true && currentTurn !== null;
+                    if (isContinuation) {
+                        if (typeof tsString === "string" && tsString.length > 0 && currentTurn !== null) {
+                            currentTurn.last_activity_time = tsString;
+                            if (currentTurn.current_step !== undefined) {
+                                currentTurn.current_step.last_activity_time = tsString;
+                            }
+                        }
+                    }
+                    else {
+                        // Close the prior turn (if any) — real user msg (or
+                        // isMeta with no current turn) is a turn boundary.
+                        if (currentTurn !== null) {
+                            const closeEndTime = typeof tsString === "string" && tsString.length > 0
+                                ? tsString
+                                : currentTurn.last_activity_time;
+                            const r = closeTurn(currentTurn, {
+                                endTime: closeEndTime,
+                                endReason: "next_user_msg",
+                                sessionId, projectName, transcriptSource,
+                            });
+                            applyBreakdownDelta(categoryBreakdown, r);
+                            turnsWithRetryInSlice += r.turns_with_retry_inc;
+                            oneShotTurnsInSlice += r.one_shot_inc;
+                            completedTurns.push(r.turn_event);
+                            for (const stepEvent of r.step_events) {
+                                completedSteps.push(stepEvent);
+                            }
+                        }
+                        // Determinism: when the user msg has no timestamp (rare in
+                        // real Claude transcripts but allowed by the parser), fall
+                        // back to the most recent ts already seen — never to
+                        // wall-clock now(), which would make projection output
+                        // depend on system time.
+                        const openStartTime = typeof tsString === "string" && tsString.length > 0
+                            ? tsString
+                            : lastTimestamp;
+                        // Triggered_by classification: isMeta lines that
+                        // reach here (continuation impossible because no
+                        // open turn) are host-injected — usually hook
+                        // feedback after a Stop force-close. Tag them so
+                        // the backend can group "real prompt + N retries"
+                        // as one logical user invocation.
+                        const triggeredBy = line.isMeta === true
+                            ? "host_inject"
+                            : "user_msg";
+                        const userMsgText = extractUserMsgText(line);
+                        currentTurn = openTurn(userMsgText, nextTurnIndex, openStartTime, triggeredBy);
+                        nextTurnIndex += 1;
+                        userTurns += 1;
+                        // user_messages aggregate — count + bytes of text content.
+                        // host_inject (isMeta=true) DOES count toward bytes/count
+                        // here too, mirroring user_turns semantic. Backend can
+                        // separate via `triggered_by` on the turn record.
+                        userMessagesCount += 1;
+                        userMessagesSize += Buffer.byteLength(userMsgText, "utf-8");
+                        if (tsMillis !== null) {
+                            const d = new Date(tsMillis);
+                            const hour = d.getHours();
+                            const hourKey = String(hour);
+                            messagesByHour[hourKey] = (messagesByHour[hourKey] ?? 0) + 1;
+                            const dateKey = formatDateKey(d);
+                            messagesByDate[dateKey] = (messagesByDate[dateKey] ?? 0) + 1;
+                            const weekdayKey = formatWeekdayKey(d);
+                            messagesByWeekday[weekdayKey] = (messagesByWeekday[weekdayKey] ?? 0) + 1;
+                            if (lastAssistantMs !== null) {
+                                const gapMs = tsMillis - lastAssistantMs;
+                                const gapSec = gapMs / 1000;
+                                if (gapSec > RESPONSE_TIME_MIN_SEC && gapSec < RESPONSE_TIME_MAX_SEC) {
+                                    const rtBucket = responseTimeBucket(gapMs);
+                                    if (rtBucket !== null) {
+                                        responseTimeBuckets[rtBucket] = (responseTimeBuckets[rtBucket] ?? 0) + 1;
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+                if (isInterrupted) {
+                    userInterruptions += 1;
+                    // (was_interrupted on the per-turn aggregator is already
+                    // set above, BEFORE the close/open cycle, so it lands on
+                    // the interrupted turn rather than the restart turn.)
+                }
+                // Per-turn last_activity_time — every user msg with a ts updates it.
+                // Per-step: same; the user msg with tool_results extends the
+                // current step's activity window (the in-flight assistant's
+                // results are landing right now).
+                if (currentTurn !== null && typeof tsString === "string" && tsString.length > 0) {
+                    currentTurn.last_activity_time = tsString;
+                    if (currentTurn.current_step !== undefined) {
+                        currentTurn.current_step.last_activity_time = tsString;
+                    }
+                }
+                // Walk content for tool_result error categorization + per-tool input
+                // attribution. Each tool_result transitions its pending entry to
+                // phase="resulted"; the consumer assistant message N+1 (next iter)
+                // closes input attribution.
+                const content = line.message.content;
+                const toolResultIdsInThisMsg = [];
+                // Sum of human-typed text bytes in this user msg's content blocks.
+                // String-form content counts whole; structured content counts only
+                // text blocks. tool_result content is excluded (those are tracked
+                // separately as result_bytes per pending tool_use). Used to widen
+                // the cache_creation denominator at CONSUMER PHASE — see comment
+                // there. Privacy: only the byte count is retained, not the text.
+                let userMsgTextBytesInThisMsg = 0;
+                if (typeof content === "string") {
+                    userMsgTextBytesInThisMsg = Buffer.byteLength(content, "utf-8");
+                }
+                if (Array.isArray(content)) {
+                    for (const blk of content) {
+                        if (blk === null || typeof blk !== "object") {
+                            continue;
+                        }
+                        const block = blk;
+                        if (block.type === "text" && typeof block.text === "string") {
+                            userMsgTextBytesInThisMsg += Buffer.byteLength(block.text, "utf-8");
+                        }
+                        if (block.type === "tool_result") {
+                            const tuid = block.tool_use_id;
+                            // Resolve the originating tool_use (in pending) so we can
+                            // attribute per-tool errors. Pending entry is keyed by
+                            // tool_use_id; phase may be "emitted" (just arrived) or
+                            // "resulted" (already saw an earlier result line — rare).
+                            const pendingEntry = typeof tuid === "string"
+                                ? pendingToolUses[tuid]
+                                : undefined;
+                            if (block.is_error === true) {
+                                toolErrorsTotal += 1;
+                                const cat = classifyToolError(block.content);
+                                toolErrorCategories[cat] = (toolErrorCategories[cat] ?? 0) + 1;
+                                // Cross-turn attribution gate: if the pending entry
+                                // was emitted in a DIFFERENT turn (Stop force-closed
+                                // the originator before the result landed), skip
+                                // per-turn attribution — that turn was already
+                                // emitted and its counters are frozen on the wire.
+                                // Session-level totals always increment; backend
+                                // sees Σ turn.errors ≤ session.errors in this case
+                                // (slight under-count rather than wrong attribution).
+                                const sameOriginatingTurn = currentTurn !== null
+                                    && (pendingEntry === undefined
+                                        || pendingEntry.originating_turn_index === undefined
+                                        || pendingEntry.originating_turn_index === currentTurn.turn_index);
+                                if (currentTurn !== null && sameOriginatingTurn) {
+                                    currentTurn.tool_errors += 1;
+                                    currentTurn.tool_error_categories[cat] =
+                                        (currentTurn.tool_error_categories[cat] ?? 0) + 1;
+                                    if (currentTurn.current_step !== undefined) {
+                                        currentTurn.current_step.tool_errors += 1;
+                                        currentTurn.current_step.tool_error_categories[cat] =
+                                            (currentTurn.current_step.tool_error_categories[cat] ?? 0) + 1;
+                                    }
+                                }
+                                // Per-tool error attribution — needs the originating
+                                // tool name from pending. If pending is missing
+                                // (orphan tool_result), skip — we already counted in
+                                // the totals + categories above. Same cross-turn
+                                // gate applies to per-turn slot updates.
+                                if (pendingEntry !== undefined) {
+                                    applyToBucketsAndTurn(pendingEntry, (slot) => { slot.errors += 1; }, { tools, mcpServers, bashBinaries: bashBinariesRich, skills, subAgents }, sameOriginatingTurn ? currentTurn : null);
+                                }
+                            }
+                            // Write output_size directly here. The pending
+                            // entry was created at the per-tool emitter
+                            // (assistant tool_use). We look up the tool's
+                            // bucket via the pending entry and bump its
+                            // output_size by the tool_result content bytes.
+                            // After that the pending entry can be retired —
+                            // no per-tool token / cost attribution downstream.
+                            if (typeof tuid === "string" && tuid.length > 0 && pendingEntry !== undefined) {
+                                const resultBytes = Buffer.byteLength(JSON.stringify(block.content ?? null), "utf-8");
+                                const sameOriginatingTurnForResult = currentTurn !== null
+                                    && (pendingEntry.originating_turn_index === undefined
+                                        || pendingEntry.originating_turn_index === currentTurn.turn_index);
+                                applyToBucketsAndTurn(pendingEntry, (slot) => {
+                                    slot.output_size += resultBytes;
+                                    slot.approximated_output_tokens = slot.output_size / pricing_1.BYTES_PER_TOKEN;
+                                }, { tools, mcpServers, bashBinaries: bashBinariesRich, skills, subAgents }, sameOriginatingTurnForResult ? currentTurn : null);
+                                toolResultIdsInThisMsg.push(tuid);
+                                delete pendingToolUses[tuid];
+                            }
+                            // else: orphan tool_result (no matching emitter in this
+                            // slice or prior pending) — ignore.
+                        }
+                    }
+                }
+                // Pass forward only if THIS user msg actually had tool_results — a
+                // user msg with only human text resets the pending consumer queue
+                // (those tool_results, if any, are already from a prior turn).
+                // priorUserMsgTextBytes tracks the human-typed text bytes that
+                // contributed to N+1's cache_creation alongside the tool_result(s).
+                if (toolResultIdsInThisMsg.length > 0) {
+                    resultedToolUseIds = toolResultIdsInThisMsg;
+                    priorUserMsgTextBytes = userMsgTextBytesInThisMsg;
+                }
+                else {
+                    resultedToolUseIds = [];
+                    priorUserMsgTextBytes = 0;
+                }
+            }
+        }
+        catch (e) {
+            const ctx = `${line.type ?? "unknown"}:line_index=${lineIndex}`;
+            const errTs = new Date().toISOString();
+            (0, errors_1.recordProcessError)(processErrors, e, errTs, ctx);
+            if (currentTurn !== null) {
+                (0, errors_1.recordProcessError)(currentTurn.process_errors, e, errTs, ctx);
+                if (currentTurn.current_step !== undefined) {
+                    (0, errors_1.recordProcessError)(currentTurn.current_step.process_errors, e, errTs, ctx);
+                }
+            }
+            logger_1.logger.debug(`projection: line ${lineIndex} (${line.type ?? "unknown"}) processing failed; skipped: ${e instanceof Error ? e.message : e}`);
+        }
+    }
+    // Build hot_files preview from the delta-local map. The merge step
+    // recomputes the canonical top-K from the full internal map; this
+    // preview is mostly for tests that look at a delta in isolation.
+    const hotFilesEntries = Object.entries(filePathChangeCounts);
+    hotFilesEntries.sort((a, b) => {
+        if (b[1] !== a[1]) {
+            return b[1] - a[1];
+        }
+        return a[0].localeCompare(b[0]);
+    });
+    const hotFiles = hotFilesEntries
+        .slice(0, DELTA_HOT_FILES_LIMIT)
+        .map(([path, count]) => ({
+        path,
+        change_count: count,
+    }));
+    // Recompute duration_minutes from the delta's bounds. Merge will
+    // override using the accumulated bounds, but emitting a sane value
+    // for delta-only consumers is harmless.
+    let durationMinutes = 0;
+    const firstMs = tsMs(firstTimestamp);
+    const lastMs = tsMs(lastTimestamp);
+    if (firstMs !== null && lastMs !== null && lastMs > firstMs) {
+        durationMinutes = Math.round((lastMs - firstMs) / 60000);
+    }
+    // Delta-local active/idle minutes — useful for tests inspecting a single
+    // delta. Cross-slice canonical totals are computed in merge from
+    // `internal.idle_ms_total`. Same rounding semantics.
+    const idleMinutesDelta = Math.round(idleMsInSlice / 60000);
+    const activeMinutesDelta = Math.max(0, durationMinutes - idleMinutesDelta);
+    // Hour-of-day for the delta's bounds. Merge "Static" / "Bounds-latest"
+    // rules in merge.ts will keep accumulated.start_hour from the first
+    // projection and update accumulated.last_activity_hour from the
+    // accumulated.last_activity_time string.
+    const startHourDelta = firstMs !== null ? new Date(firstMs).getHours() : 0;
+    const lastActivityHourDelta = lastMs !== null ? new Date(lastMs).getHours() : 0;
+    // context_tokens.buckets carries `avg = sum/count`. Computed at delta
+    // build; merge recomputes on cross-slice merge to avoid drift.
+    const contextTokensBucketsWithAvg = {};
+    for (const [k, v] of Object.entries(contextTokensBuckets)) {
+        contextTokensBucketsWithAvg[k] = {
+            sum: v.sum,
+            count: v.count,
+            avg: v.count > 0 ? v.sum / v.count : 0,
+        };
+    }
+    const delta = {
+        // Identity / provenance — Static rule: merge keeps accumulated's
+        session_id: sessionId,
+        project_name: projectName,
+        schema_version: types_1.SCHEMA_VERSION,
+        transcript_source: transcriptSource,
+        // Time bounds (flat ISO strings)
+        start_time: firstTimestamp,
+        last_activity_time: lastTimestamp,
+        // Logical groups
+        time: {
+            duration_minutes: durationMinutes,
+            active_minutes: activeMinutesDelta,
+            idle_minutes: idleMinutesDelta,
+            start_hour: startHourDelta,
+            last_activity_hour: lastActivityHourDelta,
+        },
+        turns: {
+            user_count: userTurns,
+            assistant_count: assistantResponseCount,
+            with_retry: turnsWithRetryInSlice,
+            one_shot: oneShotTurnsInSlice,
+        },
+        classification: {
+            // session_type is a delta-local approximation; merge.ts recomputes
+            // it from the merged accumulated values once final bounds are known.
+            category_breakdown: categoryBreakdown,
+            session_type: "general",
+        },
+        usage: {
+            input_tokens: inputTokens,
+            output_tokens: outputTokens,
+            cache_creation_tokens: cacheCreationTokens,
+            cache_read_tokens: cacheReadTokens,
+            cost_usd: costUsd,
+        },
+        // Per-model + user_messages
+        models,
+        user_messages: {
+            count: userMessagesCount,
+            size: userMessagesSize,
+            approximated_tokens: userMessagesSize / pricing_1.BYTES_PER_TOKEN,
+        },
+        // Per-tool breakdown maps (top-level)
+        tools,
+        mcp_servers: mcpServers,
+        skills,
+        sub_agents: subAgents,
+        bash_binaries: bashBinariesRich,
+        // Group rollups
+        tool_meta: {
+            ...(Object.keys(bashSubcommands).length > 0 ? { bash_subcommands: bashSubcommands } : {}),
+            uses_sub_agent: usesSubAgent,
+            uses_skill: usesSkill,
+            uses_mcp: usesMcp,
+            uses_web_search: usesWebSearch,
+            uses_web_fetch: usesWebFetch,
+        },
+        code_changes: {
+            files_modified: distinctFilePaths.size,
+            lines_added: linesAdded,
+            lines_removed: linesRemoved,
+            hot_files: hotFiles,
+            languages,
+        },
+        errors: {
+            tool_errors_total: toolErrorsTotal,
+            tool_error_categories: toolErrorCategories,
+            user_interruptions: userInterruptions,
+        },
+        user_activity: {
+            response_time_buckets: responseTimeBuckets,
+            messages_by_hour: messagesByHour,
+            messages_by_date: messagesByDate,
+            messages_by_weekday: messagesByWeekday,
+        },
+        context_tokens: {
+            latest: contextTokensLatest,
+            peak: contextTokensPeak,
+            buckets: contextTokensBucketsWithAvg,
+        },
+        process_errors: {
+            has: Object.keys(processErrors).length > 0,
+            items: processErrors,
+        },
+        // Delta-local signals for merge (stripped before emit; not in AccumulatedAnalytics)
+        has_assistant_with_usage: hasAssistantWithUsage,
+        closing_pending_tool_uses: pendingToolUses,
+        closing_current_turn: currentTurn,
+        completed_turns: completedTurns,
+        completed_steps: completedSteps,
+        api_request_events: apiRequestEvents,
+    };
+    return delta;
+}
+/**
+ * Re-walk the same lines to extract the per-delta internal aggregation
+ * fields (path→count map + distinct set + last assistant timestamp) the
+ * merge step needs to update `internal.*` on the state file. Kept separate
+ * so the wire-level `DeltaAnalytics` (sent through merge) doesn't carry
+ * these maps.
+ */
+function projectDeltaInternal(input) {
+    const filePathChangeCounts = {};
+    const distinct = new Set();
+    let lastAssistantTsMs;
+    // Idle attribution mirror — same algorithm as projectDelta, computed
+    // here too so the merge step has access to the ms-precision idle gap
+    // without piggy-backing on the wire-level DeltaAnalytics.
+    let priorTsMs = input.priorLastActivityTsMs ?? null;
+    let idleMsDelta = 0;
+    // Mirror of projectDelta's nextTurnIndex — count human-user msgs seen
+    // here so we can report the post-walk counter back to merge.
+    //
+    // Continuation semantic: isMeta=true user msgs that arrive while a turn
+    // is open are continuations (not new turn boundaries) and do NOT advance
+    // the index. We track `hasOpenTurn` here to mirror projectDelta's open-
+    // turn state machine exactly. Initial state comes from `priorCurrentTurn`
+    // (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).
+    const seenAssistantMessageIds = new Set(input.priorSeenAssistantMessageIds ?? []);
+    const newAssistantMessageIdsThisSlice = [];
+    for (const line of input.lines) {
+        const lineTsMs = tsMs(line.timestamp);
+        if (lineTsMs !== null) {
+            if (priorTsMs !== null && isHumanTextUser(line)) {
+                const gap = lineTsMs - priorTsMs;
+                if (gap > 0) {
+                    idleMsDelta += gap;
+                }
+            }
+            priorTsMs = lineTsMs;
+        }
+        if (isHumanTextUser(line)) {
+            const isContinuation = line.isMeta === true && hasOpenTurn;
+            if (!isContinuation) {
+                nextTurnIndex += 1;
+                hasOpenTurn = true;
+            }
+            // (continuation: hasOpenTurn stays true, nextTurnIndex unchanged)
+        }
+        // Track latest assistant timestamp regardless of content blocks —
+        // we only care that there WAS an assistant turn here.
+        if (line.type === "assistant") {
+            if (lineTsMs !== null) {
+                if (lastAssistantTsMs === undefined || lineTsMs > lastAssistantTsMs) {
+                    lastAssistantTsMs = lineTsMs;
+                }
+            }
+        }
+        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).
+        const msgIdInternal = line.message.id;
+        if (typeof msgIdInternal === "string" && msgIdInternal.length > 0) {
+            if (seenAssistantMessageIds.has(msgIdInternal)) {
+                continue;
+            }
+            seenAssistantMessageIds.add(msgIdInternal);
+            newAssistantMessageIdsThisSlice.push(msgIdInternal);
+        }
+        const content = line.message.content;
+        if (!Array.isArray(content)) {
+            continue;
+        }
+        for (const blk of content) {
+            if (blk === null || typeof blk !== "object") {
+                continue;
+            }
+            const block = blk;
+            if (block.type !== "tool_use" || typeof block.name !== "string") {
+                continue;
+            }
+            if (block.name !== "Edit" && block.name !== "Write") {
+                continue;
+            }
+            const fp = block.input?.file_path;
+            if (typeof fp === "string" && fp.length > 0) {
+                distinct.add(fp);
+                filePathChangeCounts[fp] = (filePathChangeCounts[fp] ?? 0) + 1;
+            }
+        }
+    }
+    return {
+        file_path_change_counts: filePathChangeCounts,
+        distinct_file_paths_seen: Array.from(distinct).sort(),
+        last_assistant_ts_ms: lastAssistantTsMs,
+        idle_ms_delta: idleMsDelta,
+        next_turn_index: nextTurnIndex,
+        ...(newAssistantMessageIdsThisSlice.length > 0
+            ? { new_assistant_message_ids: newAssistantMessageIdsThisSlice }
+            : {}),
+    };
+}
+//# sourceMappingURL=projection.js.map