@ironbee-ai/cli 0.6.1 → 0.7.0

package/dist/import/claude/events/file-change.d.ts

@@ -0,0 +1,28 @@
+/**
+ * IronBee CLI — Import file_change derivation.
+ *
+ * One `file_change` event per `Write`/`Edit` tool_use. Filters via the
+ * current project config's verifyPatterns / ignoredVerifyPatterns (since
+ * historical config values are unrecoverable, we use the current snapshot).
+ *
+ * Operation heuristic: live mode uses pre-tool-use `existsSync`, which we
+ * cannot replay. We inspect the matched `tool_result.content` for a
+ * "created"/"updated" marker and default to "update" on miss.
+ */
+import { FileChangeAction } from "../../../hooks/core/actions";
+import { IronBeeConfig } from "../../../lib/config";
+import { RawToolUse, RawToolResult } from "./tool-call";
+export interface BuildFileChangeOpts {
+    sessionId: string;
+    projectName: string;
+    /** Parent turn's activity_id. */
+    activityId: string;
+    /** ISO timestamp from the assistant line. */
+    timestamp: string;
+    toolUse: RawToolUse;
+    toolResult: RawToolResult | null;
+    config: IronBeeConfig;
+}
+/** Returns null when the tool_use is not a Write/Edit, or the file is filtered. */
+export declare function buildFileChange(opts: BuildFileChangeOpts): FileChangeAction | null;
+//# sourceMappingURL=file-change.d.ts.map

package/dist/import/claude/events/file-change.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"file-change.d.ts","sourceRoot":"","sources":["../../../../src/import/claude/events/file-change.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EAAE,gBAAgB,EAAuB,MAAM,6BAA6B,CAAC;AAEpF,OAAO,EAAE,aAAa,EAAwB,MAAM,qBAAqB,CAAC;AAE1E,OAAO,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAExD,MAAM,WAAW,mBAAmB;IAChC,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;IACpB,iCAAiC;IACjC,UAAU,EAAE,MAAM,CAAC;IACnB,6CAA6C;IAC7C,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,UAAU,CAAC;IACpB,UAAU,EAAE,aAAa,GAAG,IAAI,CAAC;IACjC,MAAM,EAAE,aAAa,CAAC;CACzB;AAED,mFAAmF;AACnF,wBAAgB,eAAe,CAAC,IAAI,EAAE,mBAAmB,GAAG,gBAAgB,GAAG,IAAI,CAuDlF"}

package/dist/import/claude/events/file-change.js

@@ -0,0 +1,112 @@
+"use strict";
+/**
+ * IronBee CLI — Import file_change derivation.
+ *
+ * One `file_change` event per `Write`/`Edit` tool_use. Filters via the
+ * current project config's verifyPatterns / ignoredVerifyPatterns (since
+ * historical config values are unrecoverable, we use the current snapshot).
+ *
+ * Operation heuristic: live mode uses pre-tool-use `existsSync`, which we
+ * cannot replay. We inspect the matched `tool_result.content` for a
+ * "created"/"updated" marker and default to "update" on miss.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildFileChange = buildFileChange;
+const file_diff_1 = require("../../../hooks/core/file-diff");
+const config_1 = require("../../../lib/config");
+const ids_1 = require("../../ids");
+/** Returns null when the tool_use is not a Write/Edit, or the file is filtered. */
+function buildFileChange(opts) {
+    const { sessionId, projectName, activityId, timestamp, toolUse, toolResult, config } = opts;
+    const toolName = toolUse.name;
+    if (toolName !== "Write" && toolName !== "Edit") {
+        return null;
+    }
+    const filePath = readString(toolUse.input, "file_path");
+    if (filePath === undefined) {
+        return null;
+    }
+    if (!(0, config_1.requiresVerification)(filePath, config)) {
+        return null;
+    }
+    let operation;
+    let linesAdded;
+    let linesRemoved;
+    if (toolName === "Edit") {
+        const oldStr = readString(toolUse.input, "old_string") ?? "";
+        const newStr = readString(toolUse.input, "new_string") ?? "";
+        const counts = (0, file_diff_1.diffLineCounts)(oldStr, newStr);
+        operation = "update";
+        linesAdded = counts.added;
+        linesRemoved = counts.removed;
+    }
+    else {
+        // Write
+        const content = readString(toolUse.input, "content") ?? "";
+        operation = inferOperationFromResult(toolResult);
+        linesAdded = (0, file_diff_1.countLines)(content);
+        linesRemoved = null; // we don't pre-read prior content; matches live behavior
+    }
+    const tsMs = Date.parse(timestamp);
+    // Import has no fix cycles, so `fix_id` is OMITTED from the wire payload
+    // (matches live mode's behavior when no fix is active — `getActiveFixId`
+    // returns undefined and JSON.stringify drops the key). Earlier we set
+    // `fix_id: ""` literally, which made it past TS `FixAwareEvent.fix_id:
+    // string` typing but was rejected by the collector's schema validator
+    // (Java side likely has `@NotBlank` on the field). The cast lets us
+    // satisfy the TS type without emitting the empty value on the wire.
+    const event = {
+        id: (0, ids_1.deriveFileChangeEventId)(sessionId, toolUse.id),
+        type: "file_change",
+        timestamp: Number.isFinite(tsMs) ? tsMs : Date.now(),
+        session_id: sessionId,
+        project_name: projectName,
+        activity_id: activityId,
+        tool_name: toolName,
+        file_path: filePath,
+        operation,
+        lines_added: linesAdded,
+        lines_removed: linesRemoved,
+    };
+    return event;
+}
+/**
+ * Operation heuristic for `Write`. Inspects the matched
+ * `tool_result.content` text for "created"/"File created"/"updated" markers.
+ * Defaults to `"update"` on miss (the safer fallback — we'd rather mislabel
+ * a create as update than the reverse, since "update" is the dominant case
+ * in real sessions). Always returns a definite operation.
+ */
+function inferOperationFromResult(result) {
+    if (result === null || result.is_error) {
+        return "update";
+    }
+    const text = stringifyContent(result.content).toLowerCase();
+    if (text.includes("file created") || text.includes("created successfully")) {
+        return "create";
+    }
+    return "update";
+}
+function stringifyContent(content) {
+    if (typeof content === "string") {
+        return content;
+    }
+    if (Array.isArray(content)) {
+        const parts = [];
+        for (const block of content) {
+            if (block !== null && typeof block === "object") {
+                const text = block.text;
+                if (typeof text === "string") {
+                    parts.push(text);
+                }
+            }
+        }
+        return parts.join("\n");
+    }
+    return "";
+}
+function readString(input, key) {
+    const value = input[key];
+    return typeof value === "string" ? value : undefined;
+}
+//# sourceMappingURL=file-change.js.map

package/dist/import/claude/events/file-change.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"file-change.js","sourceRoot":"","sources":["../../../../src/import/claude/events/file-change.ts"],"names":[],"mappings":"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"}

package/dist/import/claude/events/tool-call.d.ts

@@ -0,0 +1,61 @@
+/**
+ * IronBee CLI — Import tool_call derivation.
+ *
+ * One `tool_call` event per `tool_use` block in any assistant message.
+ *
+ * For `bdt_` / `ndt_` (devtools-MCP) tools: when `_metadata.toolCallId` is
+ * present in the transcript, use it as the event `id`
+ * verbatim. Live MCP-shipped events use the same id, so collector dedup on
+ * `(session_id, id)` collapses live↔import duplicates. For older transcripts
+ * without `toolCallId` (or for any non-devtools tool), fall back to the
+ * deterministic formula from `tool_use.id`.
+ *
+ * `tool_input` is whitelisted via `extractClaudeToolInput` — same projection
+ * the live track-action hook applies. `tool_response` is not shipped on the
+ * wire, only its byte size.
+ *
+ *
+ */
+import { ToolCallAction } from "../../../hooks/core/actions";
+/** Lightly-typed tool_use shape we walk out of the transcript. */
+export interface RawToolUse {
+    /** `tool_use.id` — host-supplied per-call identifier. */
+    id: string;
+    /** Raw tool name with prefix (e.g. `mcp__browser-devtools__bdt_navigation_go-to`). */
+    name: string;
+    /** Raw input — may contain `_metadata` for devtools (bdt_/ndt_) tools. */
+    input: Record<string, unknown>;
+}
+/** Lightly-typed tool_result shape. `null` means no matching result yet. */
+export interface RawToolResult {
+    /** Joined to `tool_use.id`. */
+    tool_use_id: string;
+    /** `is_error: true` is propagated to event.error. */
+    is_error: boolean;
+    /** Content block — string or array. Used for size + error message extraction. */
+    content: unknown;
+}
+export interface BuildToolCallOpts {
+    sessionId: string;
+    projectName: string;
+    /** Parent turn's activity_id (from `deriveActivityId`). */
+    activityId: string;
+    /** ISO timestamp from the assistant line carrying the tool_use. */
+    timestamp: string;
+    toolUse: RawToolUse;
+    /** Matched tool_result for this tool_use, or null when unmatched. */
+    toolResult: RawToolResult | null;
+    /**
+     * Estimated duration in ms. Live mode reads `duration_ms` from the
+     * PostToolUse hook stdin (exact wall-clock per call). Transcripts don't
+     * carry per-tool latency, so the import runner approximates by computing
+     * the bracket between the assistant message timestamp and the next user
+     * message timestamp — accurate for messages with a single tool_use,
+     * approximate (an upper bound) for parallel multi-tool messages. The
+     * runner passes `null` in those ambiguous cases; we forward `null`
+     * verbatim and downstream treats it as "unknown" (NOT zero).
+     */
+    durationMs?: number | null;
+}
+export declare function buildToolCall(opts: BuildToolCallOpts): ToolCallAction;
+//# sourceMappingURL=tool-call.d.ts.map

package/dist/import/claude/events/tool-call.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-call.d.ts","sourceRoot":"","sources":["../../../../src/import/claude/events/tool-call.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAC;AAM7D,kEAAkE;AAClE,MAAM,WAAW,UAAU;IACvB,yDAAyD;IACzD,EAAE,EAAE,MAAM,CAAC;IACX,sFAAsF;IACtF,IAAI,EAAE,MAAM,CAAC;IACb,0EAA0E;IAC1E,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAClC;AAED,4EAA4E;AAC5E,MAAM,WAAW,aAAa;IAC1B,+BAA+B;IAC/B,WAAW,EAAE,MAAM,CAAC;IACpB,qDAAqD;IACrD,QAAQ,EAAE,OAAO,CAAC;IAClB,iFAAiF;IACjF,OAAO,EAAE,OAAO,CAAC;CACpB;AAED,MAAM,WAAW,iBAAiB;IAC9B,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;IACpB,2DAA2D;IAC3D,UAAU,EAAE,MAAM,CAAC;IACnB,mEAAmE;IACnE,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,UAAU,CAAC;IACpB,qEAAqE;IACrE,UAAU,EAAE,aAAa,GAAG,IAAI,CAAC;IACjC;;;;;;;;;OASG;IACH,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAC9B;AAED,wBAAgB,aAAa,CAAC,IAAI,EAAE,iBAAiB,GAAG,cAAc,CAgDrE"}

package/dist/import/claude/events/tool-call.js

@@ -0,0 +1,119 @@
+"use strict";
+/**
+ * IronBee CLI — Import tool_call derivation.
+ *
+ * One `tool_call` event per `tool_use` block in any assistant message.
+ *
+ * For `bdt_` / `ndt_` (devtools-MCP) tools: when `_metadata.toolCallId` is
+ * present in the transcript, use it as the event `id`
+ * verbatim. Live MCP-shipped events use the same id, so collector dedup on
+ * `(session_id, id)` collapses live↔import duplicates. For older transcripts
+ * without `toolCallId` (or for any non-devtools tool), fall back to the
+ * deterministic formula from `tool_use.id`.
+ *
+ * `tool_input` is whitelisted via `extractClaudeToolInput` — same projection
+ * the live track-action hook applies. `tool_response` is not shipped on the
+ * wire, only its byte size.
+ *
+ *
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildToolCall = buildToolCall;
+const util_1 = require("../../../clients/claude/util");
+const ids_1 = require("../../ids");
+const DEVTOOLS_MCP_SERVERS = new Set(["browser-devtools", "node-devtools"]);
+function buildToolCall(opts) {
+    const { sessionId, projectName, activityId, timestamp, toolUse, toolResult } = opts;
+    const classified = (0, util_1.classifyTool)(toolUse.name, toolUse.input);
+    // Event id: prefer _metadata.toolCallId for devtools (bdt_/ndt_) tools
+    // when present in the transcript; otherwise fall back to
+    // deterministic-from-tool_use_id.
+    const eventId = resolveEventId(sessionId, classified, toolUse);
+    // tool_input projection: whitelist via extractClaudeToolInput. For
+    // browser-devtools/node-devtools tools, util.ts intentionally bypasses
+    // extraction and returns the raw input — that's fine for actions.jsonl
+    // but on the wire we still want it pruned. Since we are NOT going through
+    // the live track-action queue path, we just ship whatever extractClaudeToolInput
+    // returns (matches live wire shape for non-devtools; for devtools, includes
+    // _metadata which collector consumers already tolerate).
+    const projectedInput = (0, util_1.extractClaudeToolInput)(toolUse.name, toolUse.input);
+    const inputSize = byteLengthOf(toolUse.input);
+    const responseSize = toolResult !== null ? byteLengthOf(toolResult.content) : 0;
+    const errorMsg = toolResult !== null && toolResult.is_error
+        ? extractErrorMessage(toolResult.content)
+        : undefined;
+    const tsMs = Date.parse(timestamp);
+    const event = {
+        id: eventId,
+        type: "tool_call",
+        timestamp: Number.isFinite(tsMs) ? tsMs : Date.now(),
+        session_id: sessionId,
+        project_name: projectName,
+        activity_id: activityId,
+        tool_name: classified.tool_name,
+        tool_use_id: toolUse.id,
+        tool_input: projectedInput,
+        tool_input_size: inputSize,
+        tool_response_size: responseSize,
+        duration: opts.durationMs ?? null,
+    };
+    if (classified.tool_type !== null) {
+        event.tool_type = classified.tool_type;
+    }
+    if (classified.mcp_server !== null) {
+        event.mcp_server = classified.mcp_server;
+    }
+    if (errorMsg !== undefined) {
+        event.error = errorMsg;
+    }
+    return event;
+}
+function resolveEventId(sessionId, classified, toolUse) {
+    if (classified.tool_type === "mcp"
+        && classified.mcp_server !== null
+        && DEVTOOLS_MCP_SERVERS.has(classified.mcp_server)) {
+        const meta = toolUse.input._metadata;
+        if (meta !== null && typeof meta === "object") {
+            const toolCallId = meta.toolCallId;
+            if (typeof toolCallId === "string" && toolCallId.length > 0) {
+                return toolCallId;
+            }
+        }
+    }
+    return (0, ids_1.deriveToolCallEventIdFromToolUseId)(sessionId, toolUse.id);
+}
+function byteLengthOf(value) {
+    if (value === undefined || value === null) {
+        return 0;
+    }
+    try {
+        return Buffer.byteLength(JSON.stringify(value), "utf-8");
+    }
+    catch {
+        return 0;
+    }
+}
+function extractErrorMessage(content) {
+    if (typeof content === "string") {
+        return content;
+    }
+    if (Array.isArray(content)) {
+        const parts = [];
+        for (const block of content) {
+            if (block !== null && typeof block === "object") {
+                const text = block.text;
+                if (typeof text === "string") {
+                    parts.push(text);
+                }
+            }
+        }
+        return parts.join("\n");
+    }
+    try {
+        return JSON.stringify(content);
+    }
+    catch {
+        return String(content);
+    }
+}
+//# sourceMappingURL=tool-call.js.map

package/dist/import/claude/events/tool-call.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-call.js","sourceRoot":"","sources":["../../../../src/import/claude/events/tool-call.ts"],"names":[],"mappings":"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"}

package/dist/import/claude/runner.d.ts

@@ -0,0 +1,31 @@
+/**
+ * IronBee CLI — Claude Per-Session Import Runner
+ *
+ * Orchestrates the full import of one Claude transcript:
+ *   1. Skip check (`<projectDir>/.ironbee/sessions/<id>/`).
+ *   2. Run analytics-runner — produces session_analytics + turn + step +
+ *      api_request events.
+ *   3. Walk the Claude transcript separately for non-analytics events:
+ *      session_start, session_end, activity_start/end (per turn,
+ *      host_inject suppressed), tool_call (per tool_use), file_change
+ *      (Write/Edit).
+ *   4. POST all events via the import emitter (transient retry).
+ *   5. Write the marker.
+ *
+ * Claude-specific because the transcript walk depends on Claude's JSONL
+ * shape. When Cursor support lands, a parallel `cursor/runner.ts` will
+ * implement the same `IClientRunner` contract — never mixed in this file.
+ *
+ * Per-session atomicity: on any unrecoverable failure mid-emit,
+ * the marker is NOT written and the session re-attempts on the next
+ * `ironbee import` run.
+ */
+import { ImportResult, ImportTarget } from "../types";
+export interface ClaudeRunnerOpts {
+    target: ImportTarget;
+    force: boolean;
+    /** Events per collector POST; null = use target/default. */
+    batchSize?: number | null;
+}
+export declare function importClaudeSession(opts: ClaudeRunnerOpts): Promise<ImportResult>;
+//# sourceMappingURL=runner.d.ts.map

package/dist/import/claude/runner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runner.d.ts","sourceRoot":"","sources":["../../../src/import/claude/runner.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAQH,OAAO,EAIH,YAAY,EACZ,YAAY,EACf,MAAM,UAAU,CAAC;AAqBlB,MAAM,WAAW,gBAAgB;IAC7B,MAAM,EAAE,YAAY,CAAC;IACrB,KAAK,EAAE,OAAO,CAAC;IACf,4DAA4D;IAC5D,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAC7B;AAED,wBAAsB,mBAAmB,CAAC,IAAI,EAAE,gBAAgB,GAAG,OAAO,CAAC,YAAY,CAAC,CAoNvF"}

package/dist/import/claude/runner.js

@@ -0,0 +1,280 @@
+"use strict";
+/**
+ * IronBee CLI — Claude Per-Session Import Runner
+ *
+ * Orchestrates the full import of one Claude transcript:
+ *   1. Skip check (`<projectDir>/.ironbee/sessions/<id>/`).
+ *   2. Run analytics-runner — produces session_analytics + turn + step +
+ *      api_request events.
+ *   3. Walk the Claude transcript separately for non-analytics events:
+ *      session_start, session_end, activity_start/end (per turn,
+ *      host_inject suppressed), tool_call (per tool_use), file_change
+ *      (Write/Edit).
+ *   4. POST all events via the import emitter (transient retry).
+ *   5. Write the marker.
+ *
+ * Claude-specific because the transcript walk depends on Claude's JSONL
+ * shape. When Cursor support lands, a parallel `cursor/runner.ts` will
+ * implement the same `IClientRunner` contract — never mixed in this file.
+ *
+ * Per-session atomicity: on any unrecoverable failure mid-emit,
+ * the marker is NOT written and the session re-attempts on the next
+ * `ironbee import` run.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.importClaudeSession = importClaudeSession;
+const fs_1 = require("fs");
+const collector_1 = require("../../lib/collector");
+const config_1 = require("../../lib/config");
+const logger_1 = require("../../lib/logger");
+const transcript_1 = require("../../analytics/transcript");
+const types_1 = require("../types");
+const skip_1 = require("../skip");
+const marker_1 = require("../marker");
+const analytics_runner_1 = require("./analytics-runner");
+const session_1 = require("../events/session");
+const activity_1 = require("../events/activity");
+const tool_call_1 = require("./events/tool-call");
+const file_change_1 = require("./events/file-change");
+const ids_1 = require("../ids");
+const emitter_1 = require("../emitter");
+const transcript_walk_1 = require("./transcript-walk");
+async function importClaudeSession(opts) {
+    const { target, force } = opts;
+    const batchSize = opts.batchSize ?? null;
+    // Analytics events (session_analytics + turn + step + api_request) ride
+    // the existing `analytics` master switch — opt-in by config presence,
+    // opt-out by `analytics.enable: false`. When disabled, import still
+    // emits structural events (session/activity/tool_call/file_change) but
+    // skips analytics-derived emission.
+    const analyticsEnabled = (0, config_1.isAnalyticsEnabled)(target.projectDir);
+    const { sessionId, transcriptPath, projectDir, projectName } = target;
+    if ((0, skip_1.shouldSkip)(projectDir, sessionId, force)) {
+        return {
+            sessionId,
+            status: "skipped",
+            eventsSent: (0, types_1.emptyEventCounts)(),
+            reason: "already tracked",
+        };
+    }
+    try {
+        const collectorTarget = (0, collector_1.getCollectorTarget)(projectDir);
+        const config = (0, config_1.loadConfig)(projectDir);
+        // Step 1 — analytics events.
+        const analytics = (0, analytics_runner_1.runImportAnalytics)({
+            sessionId,
+            projectName,
+            projectDir,
+            transcriptPath,
+        });
+        // Step 2 — non-analytics events. Re-read transcript, walk lines.
+        const fileBytes = (0, fs_1.readFileSync)(transcriptPath);
+        const parsed = (0, transcript_1.parseJsonl)(fileBytes, 0);
+        const transcriptLines = parsed.lines
+            .filter((ln) => ln.parsed !== null)
+            .map((ln) => ln.parsed);
+        const counts = (0, types_1.emptyEventCounts)();
+        const events = [];
+        events.push((0, session_1.buildSessionStart)(target, "claude"));
+        counts.session_start = 1;
+        // Walk BACKWARDS to find the last line carrying a top-level
+        // `timestamp`. Some Claude transcripts end with non-message rows
+        // (`summary`, host telemetry) that don't expose a timestamp; an
+        // earlier version peeked only at the very last line and fell back
+        // to `sessionStartMs`, which produced session_end == session_start
+        // and made session_end appear chronologically before its own
+        // activity_end on the wire.
+        const lastTimestampMs = findLastLineTimestamp(transcriptLines, target.sessionStartMs);
+        const endReason = (0, transcript_walk_1.readSummaryEndReason)(transcriptLines) ?? "unknown";
+        events.push((0, session_1.buildSessionEnd)(target, lastTimestampMs, endReason));
+        counts.session_end = 1;
+        // Use analytics-runner's turn events as authoritative when available.
+        // When `analytics.emitTurnEvents=false` (the default), fall back to
+        // a transcript-derived turn walker so activity_* still emits.
+        const turnBoundaries = analytics.turnEvents.length > 0
+            ? analytics.turnEvents.map((te) => ({
+                turnIndex: te.turn.turn_index,
+                startTime: te.turn.start_time,
+                endTime: te.turn.end_time,
+                triggeredBy: te.turn.triggered_by,
+            }))
+            : (0, transcript_walk_1.deriveTurnBoundariesFromTranscript)(transcriptLines);
+        for (const tb of turnBoundaries) {
+            if (tb.triggeredBy === "host_inject") {
+                continue;
+            }
+            const boundary = {
+                turnIndex: tb.turnIndex,
+                startTime: tb.startTime,
+                endTime: tb.endTime,
+            };
+            events.push((0, activity_1.buildActivityStart)(sessionId, projectName, boundary));
+            events.push((0, activity_1.buildActivityEnd)(sessionId, projectName, boundary));
+            counts.activity_start += 1;
+            counts.activity_end += 1;
+        }
+        const turnLookup = (0, transcript_walk_1.buildTurnLookup)(turnBoundaries);
+        for (let i = 0; i < transcriptLines.length; i++) {
+            const line = transcriptLines[i];
+            if (line.type !== "assistant") {
+                continue;
+            }
+            const lineTimestamp = line.timestamp ?? "";
+            const turnIdx = turnLookup.lookup(lineTimestamp);
+            if (turnIdx === null) {
+                continue;
+            }
+            const tb = turnBoundaries.find((b) => b.turnIndex === turnIdx);
+            if (tb === undefined) {
+                continue;
+            }
+            const activityId = (0, ids_1.deriveActivityId)(sessionId, tb.turnIndex, tb.startTime);
+            const toolUses = (0, transcript_walk_1.extractToolUsesFromLine)(line);
+            if (toolUses.length === 0) {
+                continue;
+            }
+            const nextUser = (0, transcript_walk_1.findNextUserLine)(transcriptLines, i);
+            const resultsByToolUseId = nextUser !== undefined
+                ? (0, transcript_walk_1.extractToolResultsByToolUseId)(nextUser)
+                : new Map();
+            // Bracket-time duration approximation: assistant emits the
+            // tool_use at `lineTimestamp`; the next user message carries
+            // the tool_result with its own timestamp. The delta is the
+            // round-trip from "agent dispatched the tool" to "result was
+            // delivered back". Live mode reads this from `duration_ms` on
+            // PostToolUse stdin — exact per-call. Transcripts don't carry
+            // that, so we use the bracket as a best-effort estimate. We
+            // ONLY apply it when the assistant message has a single
+            // tool_use; with multiple parallel tool_uses the bracket is
+            // an upper bound on the slowest tool (≠ each individual
+            // tool's duration), and overstating per-tool latency would
+            // distort downstream aggregates. In that case duration stays
+            // null (matches "unknown, not zero" semantics).
+            const bracketMs = toolUses.length === 1
+                ? computeBracketMs(lineTimestamp, nextUser)
+                : null;
+            for (const tu of toolUses) {
+                const result = resultsByToolUseId.get(tu.id) ?? null;
+                // Only assign a duration when the tool_result is actually
+                // present in the next user message — without that, the
+                // tool didn't complete (interrupted / session ended) and
+                // any timestamp delta would be a fiction.
+                const durationMs = (bracketMs !== null && result !== null) ? bracketMs : null;
+                events.push((0, tool_call_1.buildToolCall)({
+                    sessionId,
+                    projectName,
+                    activityId,
+                    timestamp: lineTimestamp,
+                    toolUse: tu,
+                    toolResult: result,
+                    durationMs,
+                }));
+                counts.tool_call += 1;
+                const fcEvent = (0, file_change_1.buildFileChange)({
+                    sessionId,
+                    projectName,
+                    activityId,
+                    timestamp: lineTimestamp,
+                    toolUse: tu,
+                    toolResult: result,
+                    config,
+                });
+                if (fcEvent !== null) {
+                    events.push(fcEvent);
+                    counts.file_change += 1;
+                }
+            }
+        }
+        // Add analytics events — gated by `analytics` config master switch.
+        // Even when gated off, we keep the analytics-runner output: (1)
+        // `transcriptOffset` is the marker's source-of-truth, (2) the turn-
+        // boundary lookup we just used for activity_id derivation is more
+        // accurate than the fallback walker. Cost is just ~2× transcript
+        // read; events are dropped before POST.
+        if (analyticsEnabled) {
+            events.push(analytics.sessionAnalytics);
+            counts.session_analytics = 1;
+            for (const te of analytics.turnEvents) {
+                events.push(te);
+            }
+            counts.session_turn_analytics = analytics.turnEvents.length;
+            for (const se of analytics.stepEvents) {
+                events.push(se);
+            }
+            counts.session_turn_step_analytics = analytics.stepEvents.length;
+            for (const are of analytics.apiRequestEvents) {
+                events.push(are);
+            }
+            counts.api_request = analytics.apiRequestEvents.length;
+        }
+        else {
+            logger_1.logger.debug(`import claude-runner: session ${sessionId} — analytics disabled, suppressing ${analytics.turnEvents.length} turn / ${analytics.stepEvents.length} step / ${analytics.apiRequestEvents.length} api_request / 1 session_analytics events`);
+        }
+        // POST.
+        await (0, emitter_1.postEvents)(events, {
+            sessionId,
+            projectDir,
+            target: collectorTarget,
+            ...(batchSize !== null ? { batchSize } : {}),
+        });
+        // Marker.
+        (0, marker_1.writeImportMarker)(projectDir, sessionId, transcriptPath, analytics.transcriptOffset, counts);
+        return {
+            sessionId,
+            status: "imported",
+            eventsSent: counts,
+        };
+    }
+    catch (e) {
+        const reason = e instanceof Error ? e.message : String(e);
+        logger_1.logger.debug(`import claude-runner: session ${sessionId} failed: ${reason}`);
+        return {
+            sessionId,
+            status: "failed",
+            eventsSent: (0, types_1.emptyEventCounts)(),
+            reason,
+        };
+    }
+}
+/**
+ * Bracket time between an assistant tool_use and the matching tool_result
+ * in the next user message. Returns null when either timestamp is missing
+ * or unparseable, or when the next user line is absent. See `runner.ts`
+ * for the full rationale and the single-vs-multi-tool gating decision.
+ */
+function computeBracketMs(assistantTs, nextUser) {
+    if (nextUser === undefined) {
+        return null;
+    }
+    const nextTs = nextUser.timestamp;
+    if (typeof nextTs !== "string") {
+        return null;
+    }
+    const startMs = Date.parse(assistantTs);
+    const endMs = Date.parse(nextTs);
+    if (!Number.isFinite(startMs) || !Number.isFinite(endMs)) {
+        return null;
+    }
+    const delta = endMs - startMs;
+    return delta >= 0 ? delta : null;
+}
+/**
+ * Walk transcript lines from the tail forward and return the first
+ * top-level `timestamp` we find (parsed to epoch ms). Falls back to
+ * `fallbackMs` when no row in the transcript exposes a top-level
+ * timestamp — should never happen with real Claude transcripts but
+ * keeps the contract safe.
+ */
+function findLastLineTimestamp(lines, fallbackMs) {
+    for (let i = lines.length - 1; i >= 0; i--) {
+        const ts = lines[i].timestamp;
+        if (typeof ts === "string") {
+            const ms = Date.parse(ts);
+            if (Number.isFinite(ms)) {
+                return ms;
+            }
+        }
+    }
+    return fallbackMs;
+}
+//# sourceMappingURL=runner.js.map