@aixle/insights 0.1.1 → 0.2.1-staging

package/dist/pricing.js

@@ -2,7 +2,7 @@
  * Model pricing table and cost calculation for @aixle/insights.
  *
  * Default rates source: https://platform.claude.com/docs/en/about-claude/pricing
- * Rates last verified: 2026-05-04
+ * Rates last verified: 2026-06-17
  */
 /**
  * Default pricing table (USD per million tokens).
@@ -14,7 +14,20 @@
  * breakdown is a future improvement.
  */
 export const DEFAULT_PRICING = {
-    // Opus 4.7/4.6/4.5 — $5 input / $25 output
+    // Fable 5 — $10 input / $50 output
+    "claude-fable-5": {
+        input_per_mtok: 10.0,
+        output_per_mtok: 50.0,
+        cache_write_per_mtok: 12.5,
+        cache_read_per_mtok: 1.0,
+    },
+    // Opus 4.8/4.7/4.6/4.5 — $5 input / $25 output
+    "claude-opus-4-8": {
+        input_per_mtok: 5.0,
+        output_per_mtok: 25.0,
+        cache_write_per_mtok: 6.25,
+        cache_read_per_mtok: 0.5,
+    },
     "claude-opus-4-7": {
         input_per_mtok: 5.0,
         output_per_mtok: 25.0,
@@ -47,26 +60,26 @@ export const DEFAULT_PRICING = {
         cache_read_per_mtok: 1.5,
     },
     // Sonnet 4.x family — $3 input / $15 output
-    "claude-sonnet-4": {
+    "claude-sonnet-4-6": {
         input_per_mtok: 3.0,
         output_per_mtok: 15.0,
         cache_write_per_mtok: 3.75,
         cache_read_per_mtok: 0.3,
     },
-    "claude-sonnet-4-6": {
+    "claude-sonnet-4-5": {
         input_per_mtok: 3.0,
         output_per_mtok: 15.0,
         cache_write_per_mtok: 3.75,
         cache_read_per_mtok: 0.3,
     },
-    "claude-sonnet-4-5-20251001": {
+    "claude-sonnet-4": {
         input_per_mtok: 3.0,
         output_per_mtok: 15.0,
         cache_write_per_mtok: 3.75,
         cache_read_per_mtok: 0.3,
     },
     // Haiku 4.5 — $1 input / $5 output
-    "claude-haiku-4-5-20251001": {
+    "claude-haiku-4-5": {
         input_per_mtok: 1.0,
         output_per_mtok: 5.0,
         cache_write_per_mtok: 1.25,
@@ -110,6 +123,22 @@ export function mergePricing(base, overrides) {
     }
     return result;
 }
+/**
+ * Strips a trailing -YYYYMMDD date suffix to produce the bare model key used
+ * in the pricing table. Returns the original ID when:
+ *  - it has no date suffix, OR
+ *  - the bare form is not in the table (i.e. the dated form IS the canonical key,
+ *    like legacy "claude-3-5-sonnet-20241022").
+ */
+export function normalizeModelId(model, pricing) {
+    if (pricing[model])
+        return model;
+    const match = model.match(/^(.+)-(\d{8})$/);
+    if (!match)
+        return model;
+    const bare = match[1];
+    return pricing[bare] ? bare : model;
+}
 /** Returns true only when all four rate fields are finite numbers. */
 function hasValidRates(rates) {
     return (Number.isFinite(rates.input_per_mtok) &&
@@ -120,7 +149,8 @@ function hasValidRates(rates) {
 export function calculateCost(model, baseInputTokens, outputTokens, cacheWriteTokens, cacheReadTokens, pricing) {
     if (!model)
         return null;
-    const rates = pricing[model];
+    const resolved = normalizeModelId(model, pricing);
+    const rates = pricing[resolved];
     if (!rates || !hasValidRates(rates))
         return null;
     const raw = (baseInputTokens * rates.input_per_mtok +
@@ -138,7 +168,8 @@ export function calculateCost(model, baseInputTokens, outputTokens, cacheWriteTo
 export function getCostWarning(model, pricing) {
     if (!model)
         return null;
-    const rates = pricing[model];
+    const resolved = normalizeModelId(model, pricing);
+    const rates = pricing[resolved];
     if (!rates) {
         return `Model "${model}" not in pricing table — cost_usd will be null. Extend DEFAULT_PRICING or add future pricing overrides when supported.`;
     }

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,13 @@ export interface ClaudeTranscriptTurn {
     riskLevel: RiskLevel;
     riskScore: number;
     riskCategories: string[];
+    toolUses: ClaudeCollectedToolUse[];
+    navToolCalls: number;
+    totalToolCalls: number;
+    messageIds: 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 +76,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 +87,39 @@ 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;
+        message_ids?: string[];
+    };
+}
+/** 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 +127,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

@@ -6,6 +6,83 @@ 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);
+}
+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=…)
+        .replace(/\b([A-Za-z_][A-Za-z0-9_]*)\s*=\s*\S+/g, (match, name) => isSecretEnvName(name) ? `${name}=[REDACTED]` : match)
+        // --password=, --token=, --secret=, --api-key= flags
+        .replace(/(--(?:password|token|secret|api[-_]?key|access[-_]?key|auth[-_]?key)=)\S+/gi, "$1[REDACTED]")
+        // -p / --password <value> flag-value pairs
+        .replace(/((?:^|\s)-p\s+)\S+/g, "$1[REDACTED]")
+        // AWS CLI --profile (may embed customer identifiers)
+        .replace(/(--profile\s+)\S+/g, "$1[REDACTED]")
+        // Cloud CLI credential flags: --access-key-id, --secret-access-key, --service-account-key
+        .replace(/(--(?:access-key-id|secret-access-key|service-account-key|client-secret)\s+)\S+/gi, "$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,6 +202,10 @@ function newTurn(sessionId, turnIndex, filePath, fileSize, occurredAt, promptId)
         riskLevel: "low",
         riskScore: 0,
         riskCategories: [],
+        toolUses: [],
+        navToolCalls: 0,
+        totalToolCalls: 0,
+        messageIds: [],
         persisted: false,
     };
 }
@@ -141,6 +222,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 = [];
@@ -254,9 +370,13 @@ export async function parseTranscriptFile(filePath, verbose = false) {
                 }
                 if (entry.message.model)
                     currentTurn.model = entry.message.model;
+                if (entry.message.id && !currentTurn.messageIds.includes(entry.message.id)) {
+                    currentTurn.messageIds.push(entry.message.id);
+                }
                 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);
             }
         }
     }
@@ -273,7 +393,7 @@ export async function parseTranscriptFile(filePath, verbose = false) {
     flushCurrentTurn();
     return finalizedTurns.map(({ persisted: _persisted, ...turn }) => 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,18 +420,50 @@ 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,
+            message_ids: turn.messageIds.length > 0 ? turn.messageIds : undefined,
         },
     };
     if (turn.model)
         payload.model = turn.model;
-    if (turn.tokensIn > 0)
-        payload.tokens_in = turn.tokensIn;
+    if (baseInputTokens > 0)
+        payload.tokens_in = baseInputTokens;
     if (turn.tokensOut > 0)
         payload.tokens_out = turn.tokensOut;
-    if (turn.tokensIn > 0 || turn.tokensOut > 0) {
-        payload.tokens_total = turn.tokensIn + turn.tokensOut;
+    if (baseInputTokens > 0 || turn.tokensOut > 0) {
+        payload.tokens_total = baseInputTokens + turn.tokensOut;
     }
     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-sqlite.d.ts

@@ -0,0 +1,23 @@
+import Database from "better-sqlite3";
+export type CursorSqliteOpenFailureReason = "missing" | "outside_root" | "native_binding" | "unknown";
+export type CursorSqliteOpenResult = {
+    ok: true;
+    db: Database.Database;
+} | {
+    ok: false;
+    reason: CursorSqliteOpenFailureReason;
+    message: string;
+};
+export type CursorSqlitePathResult = {
+    ok: true;
+    path: string;
+} | {
+    ok: false;
+    reason: CursorSqliteOpenFailureReason;
+    message: string;
+};
+export interface CursorSqliteOpenOptions {
+    rootDir?: string;
+}
+export declare function openCursorSqliteReadonly(dbPath: string, options?: CursorSqliteOpenOptions): CursorSqliteOpenResult;
+export declare function resolveCursorSqlitePath(dbPath: string, options?: CursorSqliteOpenOptions): CursorSqlitePathResult;

package/dist/readers/cursor-sqlite.js

@@ -0,0 +1,68 @@
+import { existsSync, realpathSync } from "node:fs";
+import { resolve, sep } from "node:path";
+import Database from "better-sqlite3";
+function validatedRealPathWithinRoot(path, rootDir) {
+    const realPath = realpathSync(path);
+    const realRoot = realpathSync(rootDir);
+    if (realPath === realRoot)
+        return realPath;
+    const rootWithSep = realRoot.endsWith(sep) ? realRoot : `${realRoot}${sep}`;
+    return realPath.startsWith(rootWithSep) ? realPath : null;
+}
+function isNativeBindingError(message) {
+    return (message.includes("Could not locate the bindings file") ||
+        message.includes("better_sqlite3.node") ||
+        message.includes("dlopen"));
+}
+export function openCursorSqliteReadonly(dbPath, options = {}) {
+    const resolved = resolveCursorSqlitePath(dbPath, options);
+    if (!resolved.ok)
+        return resolved;
+    try {
+        const db = new Database(resolved.path, { readonly: true, fileMustExist: true });
+        return { ok: true, db };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return {
+            ok: false,
+            reason: isNativeBindingError(message) ? "native_binding" : "unknown",
+            message,
+        };
+    }
+}
+export function resolveCursorSqlitePath(dbPath, options = {}) {
+    const normalizedPath = resolve(dbPath);
+    if (!existsSync(normalizedPath)) {
+        return {
+            ok: false,
+            reason: "missing",
+            message: `Database file does not exist: ${normalizedPath}`,
+        };
+    }
+    const { rootDir } = options;
+    let pathToOpen = normalizedPath;
+    if (rootDir) {
+        const normalizedRoot = resolve(rootDir);
+        try {
+            const realPath = validatedRealPathWithinRoot(normalizedPath, normalizedRoot);
+            if (realPath === null) {
+                return {
+                    ok: false,
+                    reason: "outside_root",
+                    message: `Database path escapes root: ${normalizedPath}`,
+                };
+            }
+            pathToOpen = realPath;
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            return {
+                ok: false,
+                reason: "unknown",
+                message,
+            };
+        }
+    }
+    return { ok: true, path: pathToOpen };
+}

package/dist/readers/cursor.d.ts

@@ -2,7 +2,7 @@ import type { IngestPayload } from "../lib/index.js";
 import { type RiskLevel } from "../risk-scanner.js";
 export declare function cursorUserDir(): string;
 /** Smoke-test better-sqlite3 against the global Cursor state DB (CUR-V02 / verify scripts). */
-export declare function probeCursorGlobalStateDb(verbose?: boolean): boolean;
+export declare function probeCursorGlobalStateDb(verbose?: boolean, baseDir?: string): boolean;
 export declare function findCursorDbs(baseDir?: string): string[];
 export interface CursorRow {
     requestId?: string | null;
@@ -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 {
@@ -83,7 +85,7 @@ export interface PricingConfig {
     chat_output_per_mtok: number;
 }
 export declare const DEFAULT_CURSOR_PRICING: PricingConfig;
-export type Db90CursorPayloadMetadata = {
+export type CursorPayloadMetadata = {
     session_id?: string;
     cursor_session_id: string | null;
     workspace: string;
@@ -109,8 +111,9 @@ 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 {
+export interface CursorPayload extends IngestPayload {
     tool_name: "cursor";
     event_type: "completion" | "chat" | "commit";
     model: string;
@@ -119,16 +122,16 @@ export interface CursorDb90Payload extends IngestPayload {
     cost_usd: number;
     occurred_at: string;
     project_id?: string;
-    metadata: Db90CursorPayloadMetadata;
+    metadata: CursorPayloadMetadata;
 }
 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?: CursorPayloadMetadata["model_resolution"]): CursorPayload[];
 /**
  * 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 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 mapRecentCommit(entry: RecentCommitSnapshot, projectId?: string, pricing?: PricingConfig, model?: string, modelResolution?: CursorPayloadMetadata["model_resolution"]): CursorPayload | null;
+export declare function mapEvent(row: CursorRow, workspacePath: string, projectId?: string, pricing?: PricingConfig): CursorPayload | null;
+export declare function mapTranscriptTurn(turn: CursorTranscriptTurn, projectId?: string, pricing?: PricingConfig, model?: string, modelResolution?: CursorPayloadMetadata["model_resolution"]): CursorPayload;
 export {};