spiracha 2.0.0 → 2.2.0

package/src/lib/cursor-db.ts

@@ -1,5 +1,6 @@
 import { constants, Database } from 'bun:sqlite';
 import { createHash } from 'node:crypto';
+import { existsSync } from 'node:fs';
 import { readdir, stat } from 'node:fs/promises';
 import path from 'node:path';
 import {
@@ -19,7 +20,8 @@ import {
     getCursorWorkspaceStorageDir,
     resolveCursorUserDir,
 } from './cursor-exporter-types';
-import { asNumber, asObject, asString, type JsonValue } from './shared';
+import { buildCursorBubbleKeyLikePattern, isSafeCursorComposerId } from './cursor-id';
+import { asNumber, asObject, asString, type JsonValue, pathExists, toFileUri } from './shared';
 
 type ComposerEntry = Record<string, JsonValue> & {
     composerId?: string;
@@ -34,7 +36,7 @@ export const CURSOR_READONLY_DB_OPEN_FLAGS = constants.SQLITE_OPEN_READONLY | co
 // the constructor never sees it). immutable=1 reads the main database file directly, which works
 // whether or not Cursor is running and whether or not the WAL sidecars are present. The explicit URI
 // flag keeps this portable across SQLite builds where URI filename parsing is not enabled globally.
-export const getCursorReadonlyDbUri = (dbPath: string): string => {
+export const getCursorReadonlyDbUri = (dbPath: string, immutable = true): string => {
     const normalizedPath = dbPath.replace(/\\/gu, '/');
     const absolutePath = normalizedPath.startsWith('/') ? normalizedPath : `/${normalizedPath}`;
     const encodedPath = absolutePath
@@ -42,20 +44,12 @@ export const getCursorReadonlyDbUri = (dbPath: string): string => {
         .map((segment) => (/^[A-Za-z]:$/u.test(segment) ? segment : encodeURIComponent(segment)))
         .join('/');
 
-    return `file://${encodedPath}?immutable=1`;
+    return `file://${encodedPath}?${immutable ? 'immutable=1' : 'mode=ro'}`;
 };
 
 export const openCursorReadonlyDb = (dbPath: string): Database => {
-    return new Database(getCursorReadonlyDbUri(dbPath), CURSOR_READONLY_DB_OPEN_FLAGS);
-};
-
-const pathExists = async (target: string): Promise<boolean> => {
-    try {
-        await stat(target);
-        return true;
-    } catch {
-        return false;
-    }
+    const hasWalSidecars = existsSync(`${dbPath}-wal`) || existsSync(`${dbPath}-shm`);
+    return new Database(getCursorReadonlyDbUri(dbPath, !hasWalSidecars), CURSOR_READONLY_DB_OPEN_FLAGS);
 };
 
 const isMissingOrUnreadableCursorStoreError = (error: unknown): boolean => {
@@ -95,7 +89,12 @@ export const decodeCursorUri = (uri: string): string => {
     }
 
     if (uri.startsWith('file://')) {
-        return decodeURIComponent(uri.slice('file://'.length));
+        const rawPath = uri.slice('file://'.length);
+        try {
+            return decodeURIComponent(rawPath);
+        } catch {
+            return rawPath;
+        }
     }
 
     return uri;
@@ -126,6 +125,11 @@ const parseCodeWorkspaceJson = (text: string): { folders?: Array<{ path?: string
     }
 };
 
+const isMissingCodeWorkspaceFileError = (error: unknown): boolean => {
+    const code = (error as { code?: unknown }).code;
+    return code === 'ENOENT' || code === 'ENOTDIR';
+};
+
 const parseCodeWorkspaceFolders = async (workspaceFilePath: string): Promise<string[]> => {
     if (!workspaceFilePath.endsWith('.code-workspace')) {
         return [];
@@ -149,6 +153,10 @@ const parseCodeWorkspaceFolders = async (workspaceFilePath: string): Promise<str
 
         return folders;
     } catch (error) {
+        if (isMissingCodeWorkspaceFileError(error)) {
+            return [];
+        }
+
         warnCursorDataIssue('invalid_code_workspace_json', {
             error: error instanceof Error ? error.message : String(error),
             workspaceFilePath,
@@ -431,8 +439,10 @@ export const findCursorWorkspaceGroups = (groups: CursorWorkspaceGroup[], query:
 
 const countBubbles = (db: Database, composerId: string): { count: number; bytes: number } => {
     const row = db
-        .query('SELECT COUNT(*) AS count, COALESCE(SUM(length(value)), 0) AS bytes FROM cursorDiskKV WHERE key LIKE ?')
-        .get(`bubbleId:${composerId}:%`) as { count: number; bytes: number };
+        .query(
+            `SELECT COUNT(*) AS count, COALESCE(SUM(length(value)), 0) AS bytes FROM cursorDiskKV WHERE key LIKE ? ESCAPE '\\'`,
+        )
+        .get(buildCursorBubbleKeyLikePattern(composerId)) as { count: number; bytes: number };
     return { bytes: row.bytes, count: row.count };
 };
 
@@ -440,6 +450,10 @@ export const findCursorTranscriptDirs = async (
     composerId: string,
     userDir = resolveCursorUserDir(),
 ): Promise<string[]> => {
+    if (!isSafeCursorComposerId(composerId)) {
+        return [];
+    }
+
     const projectsDir = getCursorProjectsDir(userDir);
     if (!(await pathExists(projectsDir))) {
         return [];
@@ -454,7 +468,13 @@ export const findCursorTranscriptDirs = async (
     }
 
     for (const projectDir of projectDirs) {
-        const transcriptDir = path.join(projectsDir, projectDir, 'agent-transcripts', composerId);
+        const agentTranscriptsDir = path.resolve(projectsDir, projectDir, 'agent-transcripts');
+        const transcriptDir = path.resolve(agentTranscriptsDir, composerId);
+        const relativePath = path.relative(agentTranscriptsDir, transcriptDir);
+        if (!relativePath || relativePath.startsWith(`..${path.sep}`) || path.isAbsolute(relativePath)) {
+            continue;
+        }
+
         if (await pathExists(transcriptDir)) {
             matches.push(transcriptDir);
         }
@@ -639,8 +659,8 @@ const readCursorFileHistoryProjectActivity = async (userDir: string): Promise<Ma
 
 const inferFolderFromBubbles = (db: Database, composerId: string): string | null => {
     const rows = db
-        .query('SELECT value FROM cursorDiskKV WHERE key LIKE ? LIMIT 80')
-        .all(`bubbleId:${composerId}:%`) as Array<{ value: string }>;
+        .query(`SELECT value FROM cursorDiskKV WHERE key LIKE ? ESCAPE '\\' LIMIT 80`)
+        .all(buildCursorBubbleKeyLikePattern(composerId)) as Array<{ value: string }>;
     const paths: string[] = [];
 
     for (const { value } of rows) {
@@ -679,22 +699,32 @@ const readAllHeads = (db: Database, options: CursorDiscoveryOptions = {}): Map<s
                  WHERE key LIKE 'composerData:%'
                     AND COALESCE(json_extract(value, '$.lastUpdatedAt'), 0) >= ?`,
             )
-            .all(options.updatedAfterMs) as Array<{ id: string; value: string }>;
+            .all(options.updatedAfterMs) as Array<{ id: string; value: string | null }>;
 
         return new Map(rows.map((row) => [row.id, parseGlobalHead(row.value)]));
     }
 
     const rows = db
         .query(`SELECT substr(key, 14) AS id, value FROM cursorDiskKV WHERE key LIKE 'composerData:%'`)
-        .all() as Array<{ id: string; value: string }>;
+        .all() as Array<{ id: string; value: string | null }>;
 
     return new Map(rows.map((row) => [row.id, parseGlobalHead(row.value)]));
 };
 
-const parseGlobalHead = (value: string): GlobalHead => {
-    let parsed: Record<string, JsonValue> = {};
+const parseGlobalHead = (value: string | null): GlobalHead => {
+    let parsed: Record<string, JsonValue> | null = {};
+    if (value === null) {
+        return {
+            createdAtMs: null,
+            lastUpdatedAtMs: null,
+            mode: null,
+            name: null,
+            pathHint: null,
+        };
+    }
+
     try {
-        parsed = JSON.parse(value) as Record<string, JsonValue>;
+        parsed = asObject(JSON.parse(value) as JsonValue);
     } catch {
         return {
             createdAtMs: null,
@@ -705,6 +735,16 @@ const parseGlobalHead = (value: string): GlobalHead => {
         };
     }
 
+    if (!parsed) {
+        return {
+            createdAtMs: null,
+            lastUpdatedAtMs: null,
+            mode: null,
+            name: null,
+            pathHint: inferFolderFromBlob(value),
+        };
+    }
+
     return {
         createdAtMs: asNumber(parsed.createdAt ?? null),
         lastUpdatedAtMs: asNumber(parsed.lastUpdatedAt ?? null),
@@ -944,7 +984,7 @@ const buildBucketlessGroup = (key: string, threadCount: number, lastActiveMs: nu
         lastActiveMs,
         needsRecovery: false,
         threadCount,
-        uri: folder ? `file://${folder}` : '',
+        uri: folder ? toFileUri(folder) : '',
     };
 };
 
@@ -1446,8 +1486,8 @@ export const readCursorThreadTranscriptWithAgentFiles = async (
 
 const readAllBubbleIds = (db: Database, composerId: string): string[] => {
     const prefix = `bubbleId:${composerId}:`;
-    const rows = db.query('SELECT key FROM cursorDiskKV WHERE key LIKE ? ORDER BY key ASC').all(`${prefix}%`) as Array<{
-        key: string;
-    }>;
+    const rows = db
+        .query(`SELECT key FROM cursorDiskKV WHERE key LIKE ? ESCAPE '\\' ORDER BY key ASC`)
+        .all(buildCursorBubbleKeyLikePattern(composerId)) as Array<{ key: string }>;
     return rows.map((row) => row.key.slice(prefix.length));
 };

package/src/lib/cursor-id.ts

@@ -0,0 +1,17 @@
+const SAFE_CURSOR_COMPOSER_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,255}$/u;
+
+export const isSafeCursorComposerId = (value: string): boolean => {
+    return SAFE_CURSOR_COMPOSER_ID_PATTERN.test(value) && !value.includes('..');
+};
+
+export const assertSafeCursorComposerId = (value: string): void => {
+    if (!isSafeCursorComposerId(value)) {
+        throw new Error(`Invalid Cursor composer id: ${value}`);
+    }
+};
+
+const escapeSqlLikeValue = (value: string): string => value.replace(/[\\%_]/gu, '\\$&');
+
+export const buildCursorBubbleKeyLikePattern = (composerId: string): string => {
+    return `bubbleId:${escapeSqlLikeValue(composerId)}:%`;
+};

package/src/lib/cursor-recovery.ts

@@ -1,5 +1,8 @@
 import { Database } from 'bun:sqlite';
-import { rm } from 'node:fs/promises';
+import { randomUUID } from 'node:crypto';
+import { readdir, realpath, rm } from 'node:fs/promises';
+import path from 'node:path';
+import { mapWithConcurrency } from './concurrency';
 import {
     findCursorTranscriptDirs,
     invalidateCursorDiscoveryCache,
@@ -16,8 +19,10 @@ import {
     type CursorWorkspaceBucket,
     type CursorWorkspaceGroup,
     getCursorGlobalDbPath,
+    getCursorProjectsDir,
     resolveCursorUserDir,
 } from './cursor-exporter-types';
+import { assertSafeCursorComposerId, buildCursorBubbleKeyLikePattern } from './cursor-id';
 
 type ComposerEntry = {
     composerId?: string;
@@ -49,6 +54,21 @@ export const isCursorRunning = async (): Promise<boolean> => {
 };
 
 const backupStamp = (): string => new Date().toISOString().replace(/[-:]/gu, '').replace(/\..+/u, '').replace('T', '-');
+const CURSOR_BACKUP_RETENTION_COUNT = 5;
+
+const writeRetainedCursorBackup = async (basePath: string, label: string, value: unknown): Promise<string> => {
+    const directory = path.dirname(basePath);
+    const filePrefix = `${path.basename(basePath)}.${label}.`;
+    const backupPath = `${basePath}.${label}.${backupStamp()}.${randomUUID()}.json`;
+    await Bun.write(backupPath, JSON.stringify(value));
+    const backups = (await readdir(directory))
+        .filter((entry) => entry.startsWith(filePrefix) && entry.endsWith('.json'))
+        .sort((left, right) => right.localeCompare(left));
+    await Promise.all(
+        backups.slice(CURSOR_BACKUP_RETENTION_COUNT).map((entry) => rm(path.join(directory, entry), { force: true })),
+    );
+    return backupPath;
+};
 
 // The Cursor global DB can be multiple gigabytes, so copying the whole file per operation is not
 // viable. We instead write small, targeted JSON backups of only the data each operation touches.
@@ -61,22 +81,20 @@ const backupComposerHeaders = async (globalDbPath: string): Promise<string> => {
         db.close();
     }
 
-    const backupPath = `${globalDbPath}.composerHeaders.${backupStamp()}.json`;
-    await Bun.write(backupPath, JSON.stringify(headers));
-    return backupPath;
+    return writeRetainedCursorBackup(globalDbPath, 'composerHeaders', headers);
 };
 
 const backupPrunedThreads = async (globalDbPath: string, composerIds: string[]): Promise<string> => {
     const db = openCursorReadonlyDb(globalDbPath);
     try {
         const dump = composerIds.map((composerId) => ({
-            bubbles: db.query('SELECT key, value FROM cursorDiskKV WHERE key LIKE ?').all(`bubbleId:${composerId}:%`),
+            bubbles: db
+                .query(`SELECT key, value FROM cursorDiskKV WHERE key LIKE ? ESCAPE '\\'`)
+                .all(buildCursorBubbleKeyLikePattern(composerId)),
             composerData: readJsonItemFromKv(db, `composerData:${composerId}`),
             composerId,
         }));
-        const backupPath = `${globalDbPath}.prunedThreads.${backupStamp()}.json`;
-        await Bun.write(backupPath, JSON.stringify(dump));
-        return backupPath;
+        return writeRetainedCursorBackup(globalDbPath, 'prunedThreads', dump);
     } finally {
         db.close();
     }
@@ -227,8 +245,8 @@ const relinkHeaders = (
 
 const countBubbles = (db: Database, composerId: string): number => {
     const row = db
-        .query('SELECT COUNT(*) AS count FROM cursorDiskKV WHERE key LIKE ?')
-        .get(`bubbleId:${composerId}:%`) as { count: number };
+        .query(`SELECT COUNT(*) AS count FROM cursorDiskKV WHERE key LIKE ? ESCAPE '\\'`)
+        .get(buildCursorBubbleKeyLikePattern(composerId)) as { count: number };
     return row.count;
 };
 
@@ -311,9 +329,7 @@ const backupTargetBucketComposerData = async (
     target: CursorWorkspaceBucket,
     snapshot: BucketComposerDataSnapshot,
 ): Promise<string> => {
-    const backupPath = `${target.dbPath}.composerData.${backupStamp()}.json`;
-    await Bun.write(backupPath, JSON.stringify(snapshot));
-    return backupPath;
+    return writeRetainedCursorBackup(target.dbPath, 'composerData', snapshot);
 };
 
 const buildTargetBucketComposerData = (existing: ComposerData, merged: ComposerEntry[]): ComposerData => {
@@ -394,7 +410,9 @@ const removeThreadFromBucket = (db: Database, composerIds: Set<string>): boolean
 };
 
 const pruneGlobalThread = (db: Database, composerId: string): { bubbles: number; composerData: number } => {
-    const bubbleResult = db.run('DELETE FROM cursorDiskKV WHERE key LIKE ?', [`bubbleId:${composerId}:%`]);
+    const bubbleResult = db.run(`DELETE FROM cursorDiskKV WHERE key LIKE ? ESCAPE '\\'`, [
+        buildCursorBubbleKeyLikePattern(composerId),
+    ]);
     const headResult = db.run('DELETE FROM cursorDiskKV WHERE key = ?', [`composerData:${composerId}`]);
     return { bubbles: bubbleResult.changes ?? 0, composerData: headResult.changes ?? 0 };
 };
@@ -420,6 +438,28 @@ export const pruneCursorThreads = async (
     apply: boolean,
     userDir = resolveCursorUserDir(),
 ): Promise<CursorPruneResult> => {
+    const projectsDir = path.resolve(getCursorProjectsDir(userDir));
+    const canonicalProjectsDir = await realpath(projectsDir).catch(() => projectsDir);
+    for (const thread of threads) {
+        assertSafeCursorComposerId(thread.composerId);
+        for (const transcriptDir of thread.transcriptDirs) {
+            const resolvedDir = path.resolve(transcriptDir);
+            const resolvedProjectsDir = path.dirname(path.dirname(path.dirname(resolvedDir)));
+            const canonicalDir = await realpath(resolvedDir).catch(() => resolvedDir);
+            const canonicalRelativePath = path.relative(canonicalProjectsDir, canonicalDir);
+            if (
+                path.basename(resolvedDir) !== thread.composerId ||
+                path.basename(path.dirname(resolvedDir)) !== 'agent-transcripts' ||
+                resolvedProjectsDir !== projectsDir ||
+                !canonicalRelativePath ||
+                canonicalRelativePath.startsWith(`..${path.sep}`) ||
+                path.isAbsolute(canonicalRelativePath)
+            ) {
+                throw new Error(`Unsafe Cursor transcript directory: ${transcriptDir}`);
+            }
+        }
+    }
+
     const composerIds = new Set(threads.map((thread) => thread.composerId));
     const globalDbPath = getCursorGlobalDbPath(userDir);
     const result: CursorPruneResult = {
@@ -444,8 +484,18 @@ export const pruneCursorThreads = async (
     }
 
     await backupPrunedThreads(globalDbPath, [...composerIds]);
-    await pruneGlobalThreads(globalDbPath, threads, composerIds, result);
-    await pruneWorkspaceBuckets(threads, composerIds, result, userDir);
+    const bucketMutation = await pruneWorkspaceBuckets(composerIds, userDir);
+    try {
+        await pruneGlobalThreads(globalDbPath, threads, composerIds, result);
+    } catch (error) {
+        try {
+            await bucketMutation.rollback();
+        } catch (rollbackError) {
+            throw new AggregateError([error, rollbackError], 'Cursor deletion and bucket rollback both failed');
+        }
+        throw error;
+    }
+    result.workspaceBucketsUpdated = bucketMutation.updatedCount;
     await pruneTranscriptDirs(threads, result);
     invalidateCursorDiscoveryCache();
 
@@ -459,25 +509,49 @@ const pruneGlobalThreads = async (
     result: CursorPruneResult,
 ): Promise<void> => {
     const db = new Database(globalDbPath);
+    let transactionStarted = false;
     try {
+        db.exec('PRAGMA busy_timeout = 5000');
+        db.exec('BEGIN IMMEDIATE');
+        transactionStarted = true;
+        let bubblesDeleted = 0;
+        let composerDataDeleted = 0;
         for (const thread of threads) {
             const deleted = pruneGlobalThread(db, thread.composerId);
-            result.bubblesDeleted += deleted.bubbles;
-            result.composerDataDeleted += deleted.composerData;
+            bubblesDeleted += deleted.bubbles;
+            composerDataDeleted += deleted.composerData;
         }
 
-        result.headersRemoved = removeThreadHeaders(db, composerIds);
+        const headersRemoved = removeThreadHeaders(db, composerIds);
+        db.exec('COMMIT');
+        transactionStarted = false;
+        result.bubblesDeleted += bubblesDeleted;
+        result.composerDataDeleted += composerDataDeleted;
+        result.headersRemoved = headersRemoved;
+    } catch (error) {
+        if (transactionStarted) {
+            db.exec('ROLLBACK');
+        }
+        throw error;
     } finally {
         db.close();
     }
 };
 
-const pruneWorkspaceBuckets = async (
-    _threads: CursorThreadSummary[],
-    composerIds: Set<string>,
-    result: CursorPruneResult,
-    userDir: string,
-): Promise<void> => {
+const restoreBucketComposerData = (dbPath: string, snapshot: BucketComposerDataSnapshot): void => {
+    const db = new Database(dbPath);
+    try {
+        if (snapshot.exists) {
+            writeJsonItem(db, COMPOSER_DATA_KEY, snapshot.data);
+        } else {
+            db.run('DELETE FROM ItemTable WHERE key = ?', [COMPOSER_DATA_KEY]);
+        }
+    } finally {
+        db.close();
+    }
+};
+
+const pruneWorkspaceBuckets = async (composerIds: Set<string>, userDir: string) => {
     // Scan every bucket: a thread can live in more than one bucket's composer.composerData (e.g. the
     // current bucket plus the older bucket it was recovered from), so remove it from all of them.
     const groups = await listCursorWorkspaceGroups(userDir);
@@ -488,25 +562,61 @@ const pruneWorkspaceBuckets = async (
         }
     }
 
+    const snapshots = new Map<string, BucketComposerDataSnapshot>();
     for (const dbPath of dbPaths) {
-        const db = new Database(dbPath);
+        const db = openCursorReadonlyDb(dbPath);
         try {
-            if (removeThreadFromBucket(db, composerIds)) {
-                result.workspaceBucketsUpdated += 1;
-            }
+            const data = readJsonItem<ComposerData>(db, COMPOSER_DATA_KEY);
+            snapshots.set(dbPath, { data: data ?? {}, exists: data !== null });
         } finally {
             db.close();
         }
     }
-};
 
-const pruneTranscriptDirs = async (threads: CursorThreadSummary[], result: CursorPruneResult): Promise<void> => {
-    for (const thread of threads) {
-        for (const dir of thread.transcriptDirs) {
-            await rm(dir, { force: true, recursive: true });
-            result.transcriptDirsRemoved += 1;
+    const updatedPaths: string[] = [];
+    const rollback = async () => {
+        const rollbackFailures: unknown[] = [];
+        for (const dbPath of [...updatedPaths].reverse()) {
+            try {
+                restoreBucketComposerData(dbPath, snapshots.get(dbPath)!);
+            } catch (error) {
+                rollbackFailures.push(error);
+            }
+        }
+        if (rollbackFailures.length > 0) {
+            throw new AggregateError(rollbackFailures, 'Failed to restore Cursor workspace buckets');
         }
+    };
+
+    try {
+        for (const dbPath of dbPaths) {
+            const db = new Database(dbPath);
+            try {
+                if (removeThreadFromBucket(db, composerIds)) {
+                    updatedPaths.push(dbPath);
+                }
+            } finally {
+                db.close();
+            }
+        }
+    } catch (error) {
+        try {
+            await rollback();
+        } catch (rollbackError) {
+            throw new AggregateError([error, rollbackError], 'Cursor bucket deletion and rollback both failed');
+        }
+        throw error;
     }
+
+    return { rollback, updatedCount: updatedPaths.length };
+};
+
+const pruneTranscriptDirs = async (threads: CursorThreadSummary[], result: CursorPruneResult): Promise<void> => {
+    const transcriptDirs = threads.flatMap((thread) => thread.transcriptDirs);
+    await mapWithConcurrency(transcriptDirs, 4, async (dir) => {
+        await rm(dir, { force: true, recursive: true });
+    });
+    result.transcriptDirsRemoved = transcriptDirs.length;
 };
 
 // Builds the minimal thread records needed to fully delete the given composer ids (bubble counts for
@@ -521,6 +631,7 @@ export const collectCursorThreadsForDeletion = async (
 
     try {
         for (const composerId of composerIds) {
+            assertSafeCursorComposerId(composerId);
             summaries.push({
                 bubbleBytes: 0,
                 bubbleCount: countBubbles(db, composerId),

package/src/lib/cursor-transcript-phase.ts

@@ -0,0 +1,40 @@
+import type { CursorBubble } from './cursor-exporter-types';
+
+export type CursorMessagePhase = 'commentary' | 'final_answer' | null;
+
+export const getFinalCursorAssistantTextBubbleIds = (bubbles: CursorBubble[]): Set<string> => {
+    const finalBubbleIds = new Set<string>();
+    let latestAssistantTextBubbleId: string | null = null;
+
+    const flushAssistantRun = () => {
+        if (latestAssistantTextBubbleId) {
+            finalBubbleIds.add(latestAssistantTextBubbleId);
+            latestAssistantTextBubbleId = null;
+        }
+    };
+
+    for (const bubble of bubbles) {
+        if (bubble.kind !== 'assistant') {
+            flushAssistantRun();
+            continue;
+        }
+
+        if (bubble.text.trim()) {
+            latestAssistantTextBubbleId = bubble.bubbleId;
+        }
+    }
+
+    flushAssistantRun();
+    return finalBubbleIds;
+};
+
+export const getCursorTextBubblePhase = (
+    bubble: CursorBubble,
+    finalAssistantTextBubbleIds: Set<string>,
+): CursorMessagePhase => {
+    if (bubble.kind !== 'assistant') {
+        return null;
+    }
+
+    return finalAssistantTextBubbleIds.has(bubble.bubbleId) ? 'final_answer' : 'commentary';
+};

package/src/lib/cursor-transcript.ts

@@ -5,6 +5,7 @@ import type {
     CursorThreadTranscript,
     CursorToolCall,
 } from './cursor-exporter-types';
+import { getCursorTextBubblePhase, getFinalCursorAssistantTextBubbleIds } from './cursor-transcript-phase';
 import {
     cleanExtractedText,
     cleanInlineTitle,
@@ -60,6 +61,9 @@ export const renderCursorToolCall = (toolCall: CursorToolCall, outputFormat: Exp
     if (toolCall.status) {
         lines.push(`Status: ${toolCall.status}`);
     }
+    if (toolCall.callId) {
+        lines.push(`Call ID: ${toolCall.callId}`);
+    }
 
     const args = prettyToolArguments(toolCall.argumentsText);
     if (args) {
@@ -79,7 +83,11 @@ const renderUserBubble = (bubble: CursorBubble, outputFormat: ExportFormat): str
     return text ? renderSection('User', text, outputFormat) : '';
 };
 
-const renderAssistantBubble = (bubble: CursorBubble, options: CursorExportOptions): string[] => {
+const renderAssistantBubble = (
+    bubble: CursorBubble,
+    options: CursorExportOptions,
+    finalAssistantTextBubbleIds: Set<string>,
+): string[] => {
     const blocks: string[] = [];
 
     if (options.includeCommentary && bubble.thinking?.trim()) {
@@ -90,7 +98,10 @@ const renderAssistantBubble = (bubble: CursorBubble, options: CursorExportOption
     }
 
     const text = cleanExtractedText(bubble.text).trim();
-    if (text) {
+    if (
+        text &&
+        (getCursorTextBubblePhase(bubble, finalAssistantTextBubbleIds) !== 'commentary' || options.includeCommentary)
+    ) {
         blocks.push(renderSection('Assistant', text, options.outputFormat));
     }
 
@@ -101,14 +112,18 @@ const renderAssistantBubble = (bubble: CursorBubble, options: CursorExportOption
     return blocks;
 };
 
-export const renderCursorBubble = (bubble: CursorBubble, options: CursorExportOptions): string[] => {
+export const renderCursorBubble = (
+    bubble: CursorBubble,
+    options: CursorExportOptions,
+    finalAssistantTextBubbleIds = getFinalCursorAssistantTextBubbleIds([bubble]),
+): string[] => {
     if (bubble.kind === 'user') {
         const block = renderUserBubble(bubble, options.outputFormat);
         return block ? [block] : [];
     }
 
     if (bubble.kind === 'assistant') {
-        return renderAssistantBubble(bubble, options);
+        return renderAssistantBubble(bubble, options, finalAssistantTextBubbleIds);
     }
 
     return [];
@@ -161,9 +176,10 @@ export const renderCursorTranscript = (
     transcript: CursorThreadTranscript,
     options: CursorExportOptions,
 ): string | null => {
+    const finalAssistantTextBubbleIds = getFinalCursorAssistantTextBubbleIds(transcript.bubbles);
     const sections: string[] = [];
     for (const bubble of transcript.bubbles) {
-        sections.push(...renderCursorBubble(bubble, options));
+        sections.push(...renderCursorBubble(bubble, options, finalAssistantTextBubbleIds));
     }
 
     if (sections.length === 0) {