@aixle/insights 0.2.0 → 0.2.1

package/dist/readers/claude.d.ts

@@ -1,6 +1,21 @@
 import type { IngestPayload } from "../lib/index.js";
 import { type PricingTable } from "../pricing.js";
 import { type RiskLevel } from "../risk-scanner.js";
+export type ClaudeDerivativeEventType = "edit" | "commit" | "test" | "tool_use";
+export interface ClaudeToolUseBlock {
+    id?: string;
+    name: string;
+    input?: Record<string, unknown>;
+}
+export interface ClaudeCollectedToolUse {
+    id: string;
+    name: string;
+    eventType: ClaudeDerivativeEventType;
+    summary: string;
+}
+export declare function classifyToolUse(block: ClaudeToolUseBlock): ClaudeDerivativeEventType | null;
+export declare function scrubBashCommand(cmd: string): string;
+export declare function summarizeToolUse(block: ClaudeToolUseBlock): string;
 /** True when prompt text alone matches known local-command injection markers. */
 export declare function isClaudeLocalCommandNoisePrompt(promptText: string): boolean;
 /**
@@ -41,9 +56,19 @@ export interface ClaudeTranscriptTurn {
     riskLevel: RiskLevel;
     riskScore: number;
     riskCategories: string[];
+    toolUses: ClaudeCollectedToolUse[];
+    navToolCalls: number;
+    totalToolCalls: number;
+    /**
+     * Fingerprint of the turn's content (prompt + assistant text + tool-use set).
+     * A turn keeps the same turnId as Claude appends more tool_use blocks to it,
+     * so sync compares this hash to detect appended derivatives and re-emit them
+     * instead of skipping the turn forever on its unchanged id (DB90DV-259).
+     */
+    contentHash: string;
 }
-/** Payload shape expected by the db90 ingest API. */
-export interface Db90Payload extends IngestPayload {
+/** Payload shape for the parent chat turn (carries full token cost). */
+export interface ClaudePayload extends IngestPayload {
     tool_name: "claude_code";
     event_type: "chat";
     model?: string;
@@ -57,7 +82,7 @@ export interface Db90Payload extends IngestPayload {
         session_id: string;
         claude_session_id: string;
         transcript_source: "claude_jsonl";
-        model: string | null;
+        model?: string | null;
         base_input_tokens: number;
         output_tokens: number;
         cache_write_tokens: number;
@@ -68,10 +93,38 @@ export interface Db90Payload extends IngestPayload {
         prompt_text?: string;
         assistant_text?: string;
         scannable: true;
+        cost_model: "token_count";
+        nav_tool_calls: number;
+        total_tool_calls: number;
+    };
+}
+/** Payload shape for derivative tool-use children (cost_usd: 0, no tokens). */
+export interface ClaudeDerivativePayload extends IngestPayload {
+    tool_name: "claude_code";
+    event_type: ClaudeDerivativeEventType;
+    cost_usd: 0;
+    occurred_at: string;
+    model?: string;
+    project_id?: string;
+    metadata: {
+        session_id: string;
+        claude_session_id: string;
+        transcript_source: "claude_jsonl";
+        cost_model: "derivative";
+        parent_session_id: string;
+        tool_name_inner: string;
+        tool_use_id: string;
+        summary: string;
+        scannable: false;
+        risk_level: "none";
+        risk_categories: string[];
+        risk_score: 0;
     };
 }
+/** Union of all Claude transcript payloads expected by the ingest API. */
+export type ClaudeMappedPayload = ClaudePayload | ClaudeDerivativePayload;
 /** Options for mapTranscriptTurn. */
-export interface ToDb90PayloadOptions {
+export interface ToClaudePayloadOptions {
     projectId?: string | null;
     pricing?: PricingTable;
 }
@@ -79,5 +132,5 @@ export interface ToDb90PayloadOptions {
 export declare function findTranscriptFiles(baseDirs?: string[]): string[];
 /** Streams a JSONL file and splits Claude transcripts into individual turns. */
 export declare function parseTranscriptFile(filePath: string, verbose?: boolean): Promise<ClaudeTranscriptTurn[]>;
-/** Converts a Claude transcript turn to a db90 ingest payload. */
-export declare function mapTranscriptTurn(turn: ClaudeTranscriptTurn, options?: ToDb90PayloadOptions): Db90Payload;
+/** Converts a Claude transcript turn to parent chat and derivative tool-use payloads. */
+export declare function mapTranscriptTurn(turn: ClaudeTranscriptTurn, options?: ToClaudePayloadOptions): ClaudeMappedPayload[];

package/dist/readers/claude.js

@@ -1,4 +1,5 @@
 import { createReadStream, statSync } from "node:fs";
+import { createHash } from "node:crypto";
 import { finished } from "node:stream/promises";
 import { createInterface } from "node:readline";
 import { join } from "node:path";
@@ -6,6 +7,93 @@ import { homedir } from "node:os";
 import { glob } from "glob";
 import { calculateCost } from "../pricing.js";
 import { scanText } from "../risk-scanner.js";
+const NAV_TOOLS = new Set(["Read", "Grep", "Glob", "LS"]);
+const EDIT_TOOLS = new Set(["Edit", "Write", "MultiEdit", "NotebookEdit"]);
+function bashCommand(block) {
+    const c = block.input?.command;
+    return typeof c === "string" ? c : "";
+}
+export function classifyToolUse(block) {
+    if (NAV_TOOLS.has(block.name))
+        return null;
+    if (EDIT_TOOLS.has(block.name))
+        return "edit";
+    if (block.name === "Bash") {
+        const cmd = bashCommand(block);
+        // Require a space or end-of-string after "commit" so "git commit-tree" is not a commit.
+        if (/\bgit\s+commit(\s|$)/.test(cmd))
+            return "commit";
+        if (/\b(rspec|jest|vitest|pytest|phpunit)\b/i.test(cmd))
+            return "test";
+    }
+    return "tool_use";
+}
+/**
+ * Redacts credential-bearing substrings from a Bash command string before egress.
+ *
+ * Claude events carry `scannable: true`, which causes the server's ClassificationActivity
+ * to take Path 2 (classification_activity.rb:30-44) — trusting the CLI verbatim and
+ * skipping server-side sanitization. This function is the single point of trust for
+ * command strings derived from tool_input.command. Any new pattern that reads from
+ * tool_input.command MUST pass through this function before being emitted. See DATA-CURRENT.md §12.
+ */
+/**
+ * True when an env-var name looks credential-bearing.
+ * Long tokens (SECRET/TOKEN/PASSWORD/…) may appear as substrings; short ones
+ * (KEY/PASS/PWD) must be underscore-delimited segments so "monkey" / "keyboard"
+ * are not redacted.
+ */
+function isSecretEnvName(name) {
+    const n = name.toUpperCase();
+    if (/(?:SECRET|TOKEN|PASSWORD|APIKEY|API_KEY)/.test(n))
+        return true;
+    return /(?:^|_)(?:KEY|PASS|PWD)(?:_|$)/.test(n);
+}
+// A credential value that follows a flag or `=`: either a single/double quoted
+// string (which may contain spaces) or an unquoted run of non-space chars.
+const VALUE = String.raw `(?:"[^"]*"|'[^']*'|\S+)`;
+// Secret-bearing long-form flags. Matched with either `=` or a space separator,
+// and the value may be quoted (so `--token "secret value"` is fully redacted).
+const SECRET_FLAGS = "password|token|secret|api[-_]?key|access[-_]?key|auth[-_]?key|" +
+    "access-key-id|secret-access-key|service-account-key|client-secret";
+export function scrubBashCommand(cmd) {
+    return (cmd
+        // Authorization / Bearer / Basic headers (curl -H, fetch headers, etc.)
+        .replace(/\b(Authorization\s*:\s*)(Bearer|Basic|Token)\s+\S+/gi, "$1$2 [REDACTED]")
+        // Inline env-var assignments carrying secrets (AWS_SECRET_ACCESS_KEY=…, db_password="a b").
+        // Value may be quoted so assignments with spaces inside quotes are fully redacted.
+        // eslint-disable-next-line security/detect-non-literal-regexp
+        .replace(new RegExp(String.raw `\b([A-Za-z_][A-Za-z0-9_]*)\s*=\s*${VALUE}`, "g"), (match, name) => isSecretEnvName(name) ? `${name}=[REDACTED]` : match)
+        // Secret flags in both --flag=value and --flag value forms, quoted or bare.
+        // eslint-disable-next-line security/detect-non-literal-regexp
+        .replace(new RegExp(String.raw `(--(?:${SECRET_FLAGS}))(=|\s+)${VALUE}`, "gi"), "$1$2[REDACTED]")
+        // -p / --password <value> flag-value pairs (value may be quoted)
+        // eslint-disable-next-line security/detect-non-literal-regexp
+        .replace(new RegExp(String.raw `((?:^|\s)-p\s+)${VALUE}`, "g"), "$1[REDACTED]")
+        // AWS CLI --profile (may embed customer identifiers)
+        // eslint-disable-next-line security/detect-non-literal-regexp
+        .replace(new RegExp(String.raw `(--profile\s+)${VALUE}`, "g"), "$1[REDACTED]")
+        // curl | sh / curl | bash patterns (remote code execution)
+        .replace(/\|\s*(sh|bash|zsh|dash)\b/g, "| [SHELL REDACTED]"));
+}
+export function summarizeToolUse(block) {
+    const input = block.input ?? {};
+    let raw;
+    if (typeof input.file_path === "string" && input.file_path.trim()) {
+        raw = `${block.name}: ${input.file_path}`;
+    }
+    else if (typeof input.command === "string" && input.command.trim()) {
+        const scrubbed = scrubBashCommand(input.command.trim().replace(/\s+/g, " "));
+        raw = `${block.name}: ${scrubbed}`;
+    }
+    else if (typeof input.pattern === "string") {
+        raw = `${block.name}: ${scrubBashCommand(input.pattern)}`;
+    }
+    else {
+        raw = block.name;
+    }
+    return raw.length <= 256 ? raw : `${raw.slice(0, 253)}...`;
+}
 /** Prompt substrings emitted for local IDE commands — not real user prompts. */
 const LOCAL_COMMAND_NOISE_PROMPT_PATTERNS = [
     /<local-command-caveat\b/i,
@@ -125,9 +213,32 @@ function newTurn(sessionId, turnIndex, filePath, fileSize, occurredAt, promptId)
         riskLevel: "low",
         riskScore: 0,
         riskCategories: [],
+        toolUses: [],
+        navToolCalls: 0,
+        totalToolCalls: 0,
+        contentHash: "",
         persisted: false,
     };
 }
+/**
+ * Stable fingerprint of a turn's emittable content. Includes the tool-use set
+ * (id + name + summary) so appending a tool_use to an already-synced turn
+ * changes the hash and triggers a re-emit (DB90DV-259).
+ */
+function computeTurnContentHash(turn) {
+    const toolFingerprint = turn.toolUses
+        .map((t) => `${t.id}:${t.eventType}:${t.summary}`)
+        .join("
");
+    const material = [
+        turn.model ?? "",
+        turn.tokensIn,
+        turn.tokensOut,
+        turn.promptText,
+        turn.assistantText,
+        toolFingerprint,
+    ].join("");
+    return createHash("sha256").update(material).digest("hex").slice(0, 32);
+}
 function appendText(existing, addition) {
     if (!addition.trim())
         return existing;
@@ -141,6 +252,41 @@ function enrichTurnRisk(turn) {
     turn.riskScore = result.risk_score;
     turn.riskCategories = result.risk_categories;
 }
+function collectToolUsesFromContent(content, turn) {
+    if (!Array.isArray(content))
+        return;
+    let nav = 0;
+    let total = 0;
+    for (const raw of content) {
+        if (typeof raw !== "object" || raw === null)
+            continue;
+        const block = raw;
+        if (block.type !== "tool_use" || typeof block.name !== "string")
+            continue;
+        total += 1;
+        const toolBlock = {
+            id: typeof block.id === "string" ? block.id : undefined,
+            name: block.name,
+            input: typeof block.input === "object" && block.input !== null
+                ? block.input
+                : undefined,
+        };
+        const eventType = classifyToolUse(toolBlock);
+        if (eventType === null) {
+            nav += 1;
+            continue;
+        }
+        const id = toolBlock.id ?? `idx-${turn.toolUses.length}`;
+        turn.toolUses.push({
+            id,
+            name: toolBlock.name,
+            eventType,
+            summary: summarizeToolUse(toolBlock),
+        });
+    }
+    turn.navToolCalls += nav;
+    turn.totalToolCalls += total;
+}
 /** Streams a JSONL file and splits Claude transcripts into individual turns. */
 export async function parseTranscriptFile(filePath, verbose = false) {
     const turns = [];
@@ -257,6 +403,7 @@ export async function parseTranscriptFile(filePath, verbose = false) {
                 currentTurn.occurredAt = timestamp > currentTurn.occurredAt ? timestamp : currentTurn.occurredAt;
                 const text = extractContentText(entry.message.content).join("\n\n").trim();
                 currentTurn.assistantText = appendText(currentTurn.assistantText, text);
+                collectToolUsesFromContent(entry.message.content, currentTurn);
             }
         }
     }
@@ -271,9 +418,12 @@ export async function parseTranscriptFile(filePath, verbose = false) {
         return turns;
     }
     flushCurrentTurn();
-    return finalizedTurns.map(({ persisted: _persisted, ...turn }) => turn);
+    return finalizedTurns.map(({ persisted: _persisted, ...turn }) => ({
+        ...turn,
+        contentHash: computeTurnContentHash(turn),
+    }));
 }
-/** Converts a Claude transcript turn to a db90 ingest payload. */
+/** Converts a Claude transcript turn to parent chat and derivative tool-use payloads. */
 export function mapTranscriptTurn(turn, options) {
     const { projectId, pricing } = options ?? {};
     const baseInputTokens = Math.max(0, turn.tokensIn - turn.cacheWriteTokens - turn.cacheReadTokens);
@@ -300,6 +450,10 @@ export function mapTranscriptTurn(turn, options) {
             prompt_text: turn.promptText || undefined,
             assistant_text: turn.assistantText || undefined,
             scannable: true,
+            cost_model: "token_count",
+            // Zero is intentional: confirms no tool activity on this turn (not an omission).
+            nav_tool_calls: turn.navToolCalls,
+            total_tool_calls: turn.totalToolCalls,
         },
     };
     if (turn.model)
@@ -313,5 +467,32 @@ export function mapTranscriptTurn(turn, options) {
     }
     if (projectId)
         payload.project_id = projectId;
-    return payload;
+    const derivatives = turn.toolUses.map((toolUse) => {
+        const derivative = {
+            tool_name: "claude_code",
+            event_type: toolUse.eventType,
+            cost_usd: 0,
+            occurred_at: turn.occurredAt,
+            metadata: {
+                session_id: `${turn.turnId}:tool:${toolUse.id}`,
+                claude_session_id: turn.sessionId,
+                transcript_source: "claude_jsonl",
+                cost_model: "derivative",
+                parent_session_id: turn.turnId,
+                tool_name_inner: toolUse.name,
+                tool_use_id: toolUse.id,
+                summary: toolUse.summary,
+                scannable: false,
+                risk_level: "none",
+                risk_categories: [],
+                risk_score: 0,
+            },
+        };
+        if (turn.model)
+            derivative.model = turn.model;
+        if (projectId)
+            derivative.project_id = projectId;
+        return derivative;
+    });
+    return [payload, ...derivatives];
 }

package/dist/readers/cursor.d.ts

@@ -46,6 +46,8 @@ interface CursorComposerHeader {
     composerId: string;
     name: string | null;
     workspacePath: string | null;
+    /** Session start (composer.createdAt). Used to spread turns when JSONL lacks per-message times. */
+    createdAt: string | null;
     lastUpdatedAt: string | null;
 }
 export interface CursorTranscriptTurn {
@@ -109,6 +111,7 @@ export type Db90CursorPayloadMetadata = {
     generation_id?: string;
     hook_tool_name?: string;
     duration_ms?: number;
+    model_resolution?: "settings_json" | "state_vscdb" | "unresolved";
 };
 export interface CursorDb90Payload extends IngestPayload {
     tool_name: "cursor";
@@ -122,13 +125,13 @@ export interface CursorDb90Payload extends IngestPayload {
     metadata: Db90CursorPayloadMetadata;
 }
 export declare function toEpochMs(timestamp: number | string | null | undefined): number | null;
-export declare function mapDailyStats(entry: DailyStatsEntry, projectId?: string, pricing?: PricingConfig, model?: string): CursorDb90Payload[];
+export declare function mapDailyStats(entry: DailyStatsEntry, projectId?: string, pricing?: PricingConfig, model?: string, modelResolution?: Db90CursorPayloadMetadata["model_resolution"]): CursorDb90Payload[];
 /**
  * Maps Cursor’s latest-commit snapshot (`aiCodeTracking.recentCommit`) to a single commit-classified event.
  * Cursor only keeps one recent commit row (overwritten on each new commit).
  * Line-cost math still follows the chat-style line proxy (`computeLineCost("chat", …)`); only `event_type` differs.
  */
-export declare function mapRecentCommit(entry: RecentCommitSnapshot, projectId?: string, pricing?: PricingConfig, model?: string): CursorDb90Payload | null;
+export declare function mapRecentCommit(entry: RecentCommitSnapshot, projectId?: string, pricing?: PricingConfig, model?: string, modelResolution?: Db90CursorPayloadMetadata["model_resolution"]): CursorDb90Payload | null;
 export declare function mapEvent(row: CursorRow, workspacePath: string, projectId?: string, pricing?: PricingConfig): CursorDb90Payload | null;
-export declare function mapTranscriptTurn(turn: CursorTranscriptTurn, projectId?: string, pricing?: PricingConfig, model?: string): CursorDb90Payload;
+export declare function mapTranscriptTurn(turn: CursorTranscriptTurn, projectId?: string, pricing?: PricingConfig, model?: string, modelResolution?: Db90CursorPayloadMetadata["model_resolution"]): CursorDb90Payload;
 export {};

package/dist/readers/cursor.js

@@ -74,7 +74,10 @@ export function probeCursorGlobalStateDb(verbose = false, baseDir) {
 export function findCursorDbs(baseDir) {
     const dir = join(baseDir ?? cursorUserDir(), "workspaceStorage");
     try {
-        return glob.sync(join(dir, "**", "cursor.db"));
+        // Pattern stays forward-slash and the directory goes through `cwd`. Building
+        // it with `join` emitted `\` on Windows, and glob treats `\` as an escape
+        // character on every platform, so this silently matched nothing there.
+        return glob.sync("**/cursor.db", { cwd: dir, absolute: true });
     }
     catch {
         return [];
@@ -244,7 +247,14 @@ export function findStateVscDbs(baseDir) {
     const results = [];
     results.push(join(userDir, "globalStorage", "state.vscdb"));
     try {
-        results.push(...glob.sync(join(userDir, "workspaceStorage", "**", "state.vscdb")));
+        // Forward-slash pattern + `cwd`, as above. This one mattered most: the
+        // globalStorage path is pushed unconditionally, so on Windows the function
+        // still returned a result while silently dropping every per-workspace
+        // state.vscdb — partial data loss that looked like working software.
+        results.push(...glob.sync("workspaceStorage/**/state.vscdb", {
+            cwd: userDir,
+            absolute: true,
+        }));
     }
     catch {
         /* ignore */
@@ -447,6 +457,64 @@ function toIsoFromMs(value) {
     const date = new Date(value);
     return Number.isNaN(date.getTime()) ? null : date.toISOString();
 }
+/** Coerce epoch ms/seconds, numeric strings, or ISO-8601 into an ISO timestamp. */
+function coerceTranscriptTimestamp(value) {
+    if (value == null)
+        return null;
+    // Route numbers through toEpochMs (via toIsoString) so epoch *seconds* are scaled
+    // to ms — otherwise e.g. 1720000000 (2024 in seconds) is misread as a 1970 ms value.
+    if (typeof value === "number")
+        return toIsoString(value);
+    if (typeof value !== "string")
+        return null;
+    const trimmed = value.trim();
+    if (!trimmed)
+        return null;
+    const fromEpoch = toIsoString(trimmed);
+    if (fromEpoch)
+        return fromEpoch;
+    const ms = Date.parse(trimmed);
+    if (Number.isNaN(ms))
+        return null;
+    return new Date(ms).toISOString();
+}
+/** Prefer explicit per-line / per-message times when Cursor includes them. */
+function extractLineOccurredAt(entry) {
+    const candidates = [
+        entry.timestamp,
+        entry.createdAt,
+        entry.unixMs,
+        entry.message?.timestamp,
+        entry.message?.createdAt,
+    ];
+    for (const candidate of candidates) {
+        const iso = coerceTranscriptTimestamp(candidate);
+        if (iso)
+            return iso;
+    }
+    return null;
+}
+/**
+ * Spread turns across [start, end] when the JSONL has no per-message times.
+ * Prevents first-sync backfill from collapsing every turn onto lastUpdatedAt/mtime
+ * (DB90DV-605 weekly chart spike).
+ */
+function interpolateTurnOccurredAt(startIso, endIso, index, total, fallbackIso) {
+    if (total <= 0)
+        return fallbackIso;
+    // Single turn: prefer session end (lastUpdatedAt) — matches prior composer-header behavior.
+    if (total === 1)
+        return endIso ?? startIso ?? fallbackIso;
+    const startMs = startIso ? Date.parse(startIso) : NaN;
+    const endMs = endIso ? Date.parse(endIso) : NaN;
+    if (Number.isNaN(startMs) || Number.isNaN(endMs)) {
+        return startIso ?? endIso ?? fallbackIso;
+    }
+    if (endMs <= startMs)
+        return startIso ?? fallbackIso;
+    const ms = startMs + ((endMs - startMs) * index) / (total - 1);
+    return new Date(ms).toISOString();
+}
 function readComposerHeaders(baseDir) {
     const userDir = baseDir ?? cursorUserDir();
     const dbPath = join(userDir, "globalStorage", "state.vscdb");
@@ -491,6 +559,7 @@ function readComposerHeaders(baseDir) {
                 composerId,
                 name: typeof composer.name === "string" ? composer.name : null,
                 workspacePath: typeof uri?.fsPath === "string" ? uri.fsPath : null,
+                createdAt: toIsoFromMs(composer.createdAt),
                 lastUpdatedAt: toIsoFromMs(composer.lastUpdatedAt),
             });
         }
@@ -563,11 +632,15 @@ function workspaceFromTranscriptFile(filePath) {
 const MAX_TRANSCRIPT_BYTES = 50 * 1024 * 1024; // 50 MB
 export async function parseCursorTranscriptFile(filePath, composerHeaders, verbose = false) {
     let fileSize = 0;
-    let occurredAt = new Date().toISOString();
+    let fileMtimeIso = new Date().toISOString();
+    let fileBirthIso = null;
     try {
         const stat = statSync(filePath);
         fileSize = stat.size;
-        occurredAt = stat.mtime.toISOString();
+        fileMtimeIso = stat.mtime.toISOString();
+        if (stat.birthtime && !Number.isNaN(stat.birthtime.getTime()) && stat.birthtime.getTime() > 0) {
+            fileBirthIso = stat.birthtime.toISOString();
+        }
     }
     catch {
         return [];
@@ -580,15 +653,25 @@ export async function parseCursorTranscriptFile(filePath, composerHeaders, verbo
     }
     const sessionId = basename(filePath, ".jsonl");
     const header = composerHeaders.get(sessionId);
-    if (header?.lastUpdatedAt)
-        occurredAt = header.lastUpdatedAt;
-    const turns = [];
+    const sessionFallback = header?.lastUpdatedAt ?? fileMtimeIso;
+    const sessionStart = header?.createdAt ?? fileBirthIso ?? sessionFallback;
+    const sessionEnd = header?.lastUpdatedAt ?? fileMtimeIso;
+    const drafts = [];
     let currentPromptParts = [];
     let currentAssistantParts = [];
+    let currentTurnOccurredAt = null;
     let turnIndex = 0;
     const hasher = createHash("sha256");
     const stream = createReadStream(filePath, { encoding: "utf-8" });
     const rl = createInterface({ input: stream, crlfDelay: Infinity });
+    const noteLineTime = (entry) => {
+        const lineAt = extractLineOccurredAt(entry);
+        if (!lineAt)
+            return;
+        // Prefer the first timestamp in the turn (usually the user message).
+        if (!currentTurnOccurredAt)
+            currentTurnOccurredAt = lineAt;
+    };
     const finalizeTurn = () => {
         const promptText = currentPromptParts.join("\n\n").trim();
         const assistantText = currentAssistantParts.join("\n\n").trim();
@@ -596,14 +679,14 @@ export async function parseCursorTranscriptFile(filePath, composerHeaders, verbo
             return;
         const risk = scanText(promptText);
         turnIndex += 1;
-        turns.push({
+        drafts.push({
             turnId: `${sessionId}:${turnIndex}`,
             sessionId,
             filePath,
             fileSize,
             workspacePath: header?.workspacePath ?? workspaceFromTranscriptFile(filePath),
             composerName: header?.name ?? null,
-            occurredAt,
+            turnOccurredAt: currentTurnOccurredAt,
             promptText,
             assistantText,
             tokensIn: estimateTokens(promptText),
@@ -612,6 +695,7 @@ export async function parseCursorTranscriptFile(filePath, composerHeaders, verbo
             riskScore: risk.risk_score,
             riskCategories: risk.risk_categories,
         });
+        currentTurnOccurredAt = null;
     };
     let lineNumber = 0;
     try {
@@ -635,15 +719,26 @@ export async function parseCursorTranscriptFile(filePath, composerHeaders, verbo
             if (texts.length === 0)
                 continue;
             if (entry.role === "user") {
+                // Normalize/filter before noting the time: a whitespace- or wrapper-only line
+                // must not set currentTurnOccurredAt (nor start a new turn) with nothing to append,
+                // otherwise the next real message inherits this stale timestamp.
+                const fragments = texts.map(stripUserQueryWrapper).filter((text) => text.length > 0);
+                if (fragments.length === 0)
+                    continue;
                 if (currentPromptParts.length > 0 || currentAssistantParts.length > 0) {
                     finalizeTurn();
                     currentPromptParts = [];
                     currentAssistantParts = [];
                 }
-                currentPromptParts.push(...texts.map(stripUserQueryWrapper).filter((text) => text.length > 0));
+                noteLineTime(entry);
+                currentPromptParts.push(...fragments);
             }
             else if (entry.role === "assistant") {
-                currentAssistantParts.push(...texts.map((text) => text.trim()).filter((text) => text.length > 0));
+                const fragments = texts.map((text) => text.trim()).filter((text) => text.length > 0);
+                if (fragments.length === 0)
+                    continue;
+                noteLineTime(entry);
+                currentAssistantParts.push(...fragments);
             }
         }
     }
@@ -659,9 +754,16 @@ export async function parseCursorTranscriptFile(filePath, composerHeaders, verbo
     }
     finalizeTurn();
     const contentHash = hasher.digest("hex").slice(0, 32);
-    for (const t of turns)
-        t.contentHash = contentHash;
-    return turns;
+    const total = drafts.length;
+    return drafts.map((draft, index) => {
+        const { turnOccurredAt, ...rest } = draft;
+        return {
+            ...rest,
+            contentHash,
+            occurredAt: turnOccurredAt ??
+                interpolateTurnOccurredAt(sessionStart, sessionEnd, index, total, sessionFallback),
+        };
+    });
 }
 export async function readCursorTranscriptSessions(cursorUserBaseDir, transcriptProjectDirs, verbose = false) {
     const composerHeaders = readComposerHeaders(cursorUserBaseDir);
@@ -730,7 +832,7 @@ function dailyStatsSessionId(date, eventType, modelKey) {
     return `cursor:daily_stats:${date}:${suffix}`;
 }
 function buildPayload(opts) {
-    const { eventType, tokensIn, tokensOut, costUsd, occurredAt, dbPath, date, model = "unknown", modelKey, projectId, costModel = LINE_COST_MODEL, } = opts;
+    const { eventType, tokensIn, tokensOut, costUsd, occurredAt, dbPath, date, model = "unknown", modelResolution, modelKey, projectId, costModel = LINE_COST_MODEL, } = opts;
     const payload = {
         tool_name: "cursor",
         event_type: eventType,
@@ -746,13 +848,14 @@ function buildPayload(opts) {
             cost_model: costModel,
             scannable: false,
             risk_level: "none",
+            ...(modelResolution !== undefined ? { model_resolution: modelResolution } : {}),
         },
     };
     if (projectId)
         payload.project_id = projectId;
     return payload;
 }
-export function mapDailyStats(entry, projectId, pricing = DEFAULT_CURSOR_PRICING, model) {
+export function mapDailyStats(entry, projectId, pricing = DEFAULT_CURSOR_PRICING, model, modelResolution) {
     const { date, value, dbPath } = entry;
     const occurredAt = `${date}T00:00:00.000Z`;
     const results = [];
@@ -773,6 +876,7 @@ export function mapDailyStats(entry, projectId, pricing = DEFAULT_CURSOR_PRICING
             dbPath,
             date,
             model,
+            modelResolution,
             projectId,
         }));
     }
@@ -786,6 +890,7 @@ export function mapDailyStats(entry, projectId, pricing = DEFAULT_CURSOR_PRICING
             dbPath,
             date,
             model,
+            modelResolution,
             projectId,
         }));
     }
@@ -820,7 +925,7 @@ export function mapDailyStats(entry, projectId, pricing = DEFAULT_CURSOR_PRICING
  * Cursor only keeps one recent commit row (overwritten on each new commit).
  * Line-cost math still follows the chat-style line proxy (`computeLineCost("chat", …)`); only `event_type` differs.
  */
-export function mapRecentCommit(entry, projectId, pricing = DEFAULT_CURSOR_PRICING, model) {
+export function mapRecentCommit(entry, projectId, pricing = DEFAULT_CURSOR_PRICING, model, modelResolution) {
     const { value: obj, dbPath } = entry;
     const occurredAt = toIsoString(obj.timestamp);
     if (!occurredAt)
@@ -866,6 +971,7 @@ export function mapRecentCommit(entry, projectId, pricing = DEFAULT_CURSOR_PRICI
                     : undefined,
             scannable: false,
             risk_level: "none",
+            ...(modelResolution !== undefined ? { model_resolution: modelResolution } : {}),
         },
     };
     if (projectId)
@@ -902,7 +1008,7 @@ export function mapEvent(row, workspacePath, projectId, pricing = DEFAULT_CURSOR
         payload.project_id = projectId;
     return payload;
 }
-export function mapTranscriptTurn(turn, projectId, pricing = DEFAULT_CURSOR_PRICING, model) {
+export function mapTranscriptTurn(turn, projectId, pricing = DEFAULT_CURSOR_PRICING, model, modelResolution) {
     const payload = {
         tool_name: "cursor",
         event_type: "chat",
@@ -924,6 +1030,7 @@ export function mapTranscriptTurn(turn, projectId, pricing = DEFAULT_CURSOR_PRIC
             composer_name: turn.composerName ?? undefined,
             prompt_text: turn.promptText || undefined,
             assistant_text: turn.assistantText || undefined,
+            ...(modelResolution !== undefined ? { model_resolution: modelResolution } : {}),
         },
     };
     if (projectId)