spiracha 1.3.3 → 1.5.0

package/src/lib/codex-browser-export.ts

@@ -6,6 +6,7 @@ import { convertSessionFile, writeSessionFileExport } from './codex-exporter-tra
 import type { CodexCliOptions } from './codex-exporter-types';
 import { applyPathTransforms, type PathDisplaySettings } from './path-transforms';
 import { type ExportFormat, getPortablePathBasename } from './shared';
+import { getExportMimeType, sanitizeExportFileName, zipExportDirectory, zipExportFile } from './ui-export-archive';
 import { buildUiExportDownloadUrl, ensureUiExportDir } from './ui-export-files';
 
 type RenderCodexThreadDownloadInput = {
@@ -18,6 +19,7 @@ type RenderCodexThreadDownloadInput = {
     pathDisplaySettings?: Pick<PathDisplaySettings, 'convertToProjectRoot' | 'redactUsername'>;
     publicExportDir?: string;
     threadId: string;
+    zipArchive?: boolean;
 };
 
 type RenderCodexThreadsDownloadInput = Omit<RenderCodexThreadDownloadInput, 'threadId'> & {
@@ -40,14 +42,6 @@ export type CodexThreadDownload =
 
 const LARGE_BROWSER_EXPORT_THRESHOLD_BYTES = 128 * 1024 * 1024;
 
-const toSanitizedFileName = (value: string) => {
-    return value
-        .replace(/[<>:"/\\|?*\u0000-\u001f]/gu, ' ')
-        .replace(/\.\.+/gu, ' ')
-        .replace(/\s+/gu, ' ')
-        .trim();
-};
-
 const formatReadableExportDate = (value: number) => {
     const date = new Date(value);
     const year = date.getUTCFullYear();
@@ -59,7 +53,7 @@ const formatReadableExportDate = (value: number) => {
 };
 
 const buildExportBaseName = (thread: ReturnType<typeof getThreadBrowseData>['thread']) => {
-    const projectName = toSanitizedFileName(getPortablePathBasename(thread.cwd) || 'thread') || 'thread';
+    const projectName = sanitizeExportFileName(getPortablePathBasename(thread.cwd) || 'thread') || 'thread';
     const timestamp = thread.updated_at_ms ?? thread.updated_at * 1000;
     return `${projectName}-${formatReadableExportDate(timestamp)}-${thread.id.slice(0, 8)}`;
 };
@@ -70,7 +64,7 @@ const buildBatchExportBaseName = (threads: Array<ReturnType<typeof getThreadBrow
         throw new Error('No threads selected for export');
     }
 
-    const projectName = toSanitizedFileName(getPortablePathBasename(firstThread.cwd) || 'threads') || 'threads';
+    const projectName = sanitizeExportFileName(getPortablePathBasename(firstThread.cwd) || 'threads') || 'threads';
     const latestTimestamp = Math.max(...threads.map((thread) => thread.updated_at_ms ?? thread.updated_at * 1000));
     return `${projectName}-${formatReadableExportDate(latestTimestamp)}-threads-${threads.length}`;
 };
@@ -111,10 +105,6 @@ const toDownloadOptions = (input: RenderCodexThreadDownloadInput): CodexCliOptio
     };
 };
 
-const getMimeType = (outputFormat: ExportFormat) => {
-    return outputFormat === 'md' ? 'text/markdown; charset=utf-8' : 'text/plain; charset=utf-8';
-};
-
 const resolvePublicExportDir = async (publicExportDir?: string) => {
     if (publicExportDir) {
         await ensureDirectory(publicExportDir);
@@ -140,13 +130,28 @@ const getRolloutSnapshot = async (rolloutPath: string): Promise<RolloutSnapshot>
     };
 };
 
+const isMissingFileError = (error: unknown) => {
+    return error instanceof Error && 'code' in error && error.code === 'ENOENT';
+};
+
+const getExistingRolloutSnapshot = async (threadId: string, rolloutPath: string): Promise<RolloutSnapshot> => {
+    try {
+        return await getRolloutSnapshot(rolloutPath);
+    } catch (error) {
+        if (isMissingFileError(error)) {
+            throw new Error(`Thread ${threadId} rollout file is missing: ${rolloutPath}`, { cause: error });
+        }
+
+        throw error;
+    }
+};
+
 const logExportEvent = (level: 'error' | 'info' | 'warn', event: string, details: Record<string, unknown>) => {
     console[level](`[spiracha:export] ${event}`, details);
 };
 
 const logRolloutChangeIfDetected = (
     threadId: string,
-    rolloutPath: string,
     beforeSnapshot: RolloutSnapshot,
     afterSnapshot: RolloutSnapshot,
 ) => {
@@ -159,7 +164,6 @@ const logRolloutChangeIfDetected = (
         afterSizeBytes: afterSnapshot.sizeBytes,
         beforeMtimeMs: beforeSnapshot.mtimeMs,
         beforeSizeBytes: beforeSnapshot.sizeBytes,
-        rolloutPath,
         threadId,
     });
 };
@@ -175,39 +179,6 @@ const cleanupExportWorkspace = async (workspacePath: string) => {
     }
 };
 
-const zipExportFile = async (sourcePath: string, zipPath: string) => {
-    const proc = Bun.spawn(['zip', '-9', '-j', zipPath, sourcePath], {
-        stderr: 'pipe',
-        stdout: 'pipe',
-    });
-    const [stdoutText, stderrText, exitCode] = await Promise.all([
-        new Response(proc.stdout).text(),
-        new Response(proc.stderr).text(),
-        proc.exited,
-    ]);
-
-    if (exitCode !== 0) {
-        throw new Error(`zip failed (${exitCode}): ${(stderrText || stdoutText).trim()}`);
-    }
-};
-
-const zipExportDirectory = async (sourceDirectory: string, zipPath: string) => {
-    const proc = Bun.spawn(['zip', '-9', '-r', zipPath, '.'], {
-        cwd: sourceDirectory,
-        stderr: 'pipe',
-        stdout: 'pipe',
-    });
-    const [stdoutText, stderrText, exitCode] = await Promise.all([
-        new Response(proc.stdout).text(),
-        new Response(proc.stderr).text(),
-        proc.exited,
-    ]);
-
-    if (exitCode !== 0) {
-        throw new Error(`zip failed (${exitCode}): ${(stderrText || stdoutText).trim()}`);
-    }
-};
-
 export const renderCodexThreadDownload = async (
     input: RenderCodexThreadDownloadInput,
 ): Promise<CodexThreadDownload> => {
@@ -216,7 +187,7 @@ export const renderCodexThreadDownload = async (
     const extension = input.outputFormat === 'md' ? 'md' : 'txt';
     const fileBaseName = buildExportBaseName(browseData.thread);
     const fileName = `${fileBaseName}.${extension}`;
-    const mimeType = getMimeType(input.outputFormat);
+    const mimeType = getExportMimeType(input.outputFormat);
     const transform = (text: string) =>
         input.pathDisplaySettings
             ? applyPathTransforms(text, {
@@ -224,17 +195,17 @@ export const renderCodexThreadDownload = async (
                   projectPath: browseData.thread.cwd,
               })
             : text;
-    const rolloutSnapshotBefore = await getRolloutSnapshot(browseData.thread.rollout_path);
+    const rolloutSnapshotBefore = await getExistingRolloutSnapshot(input.threadId, browseData.thread.rollout_path);
 
     logExportEvent('info', 'single_start', {
         fileName,
-        rolloutPath: browseData.thread.rollout_path,
         sizeBytes: rolloutSnapshotBefore.sizeBytes,
         threadId: input.threadId,
     });
 
     try {
         if (
+            input.zipArchive ||
             rolloutSnapshotBefore.sizeBytes > (input.largeExportThresholdBytes ?? LARGE_BROWSER_EXPORT_THRESHOLD_BYTES)
         ) {
             const exportBaseName = fileBaseName;
@@ -266,12 +237,7 @@ export const renderCodexThreadDownload = async (
             }
 
             const rolloutSnapshotAfter = await getRolloutSnapshot(browseData.thread.rollout_path);
-            logRolloutChangeIfDetected(
-                input.threadId,
-                browseData.thread.rollout_path,
-                rolloutSnapshotBefore,
-                rolloutSnapshotAfter,
-            );
+            logRolloutChangeIfDetected(input.threadId, rolloutSnapshotBefore, rolloutSnapshotAfter);
 
             const zipStat = await Bun.file(zipPath).stat();
             logExportEvent('info', 'single_zip_ready', {
@@ -307,12 +273,7 @@ export const renderCodexThreadDownload = async (
         }
 
         const rolloutSnapshotAfter = await getRolloutSnapshot(browseData.thread.rollout_path);
-        logRolloutChangeIfDetected(
-            input.threadId,
-            browseData.thread.rollout_path,
-            rolloutSnapshotBefore,
-            rolloutSnapshotAfter,
-        );
+        logRolloutChangeIfDetected(input.threadId, rolloutSnapshotBefore, rolloutSnapshotAfter);
         logExportEvent('info', 'single_inline_ready', {
             durationMs: Date.now() - startedAt,
             fileName,
@@ -362,7 +323,7 @@ export const renderCodexThreadsDownload = async (
 
     try {
         for (const entry of browseEntries) {
-            const rolloutSnapshotBefore = await getRolloutSnapshot(entry.thread.rollout_path);
+            const rolloutSnapshotBefore = await getExistingRolloutSnapshot(entry.thread.id, entry.thread.rollout_path);
             const singleBaseName = buildExportBaseName(entry.thread);
             const uniqueBaseName = buildUniqueBatchEntryBaseName(
                 singleBaseName,
@@ -412,12 +373,7 @@ export const renderCodexThreadsDownload = async (
             }
 
             const rolloutSnapshotAfter = await getRolloutSnapshot(entry.thread.rollout_path);
-            logRolloutChangeIfDetected(
-                entry.thread.id,
-                entry.thread.rollout_path,
-                rolloutSnapshotBefore,
-                rolloutSnapshotAfter,
-            );
+            logRolloutChangeIfDetected(entry.thread.id, rolloutSnapshotBefore, rolloutSnapshotAfter);
         }
 
         await zipExportDirectory(bundleDirectory, zipPath);

package/src/lib/codex-thread-cache.ts

@@ -7,6 +7,10 @@ import { getFileFingerprint, hashCacheKeyParts, withCachedJson } from './ui-cach
 export const LARGE_THREAD_SIZE_BYTES = 100 * 1024 * 1024;
 export const LARGE_THREAD_PREVIEW_EVENT_LIMIT = 200;
 
+const isMissingFileError = (error: unknown) => {
+    return error instanceof Error && 'code' in error && error.code === 'ENOENT';
+};
+
 export const getCachedParsedCodexTranscript = async (sessionFile: string): Promise<ParsedCodexTranscript> => {
     const fingerprint = await getFileFingerprint(sessionFile);
     const key = `thread-${hashCacheKeyParts(path.basename(sessionFile), fingerprint)}`;
@@ -23,7 +27,19 @@ export const getThreadRolloutLoadState = async (
     sessionFile: string,
     largeTranscriptThresholdBytes = LARGE_THREAD_SIZE_BYTES,
 ) => {
-    const metadata = await stat(sessionFile);
+    let metadata: Awaited<ReturnType<typeof stat>>;
+    try {
+        metadata = await stat(sessionFile);
+    } catch (error) {
+        if (isMissingFileError(error)) {
+            return {
+                fileSizeBytes: null,
+                shouldDeferTranscriptLoad: false,
+            };
+        }
+
+        throw error;
+    }
 
     return {
         fileSizeBytes: metadata.size,

package/src/lib/concurrency.ts

@@ -0,0 +1,25 @@
+export const mapWithConcurrency = async <T, TResult>(
+    values: T[],
+    limit: number,
+    mapper: (value: T, index: number) => Promise<TResult>,
+) => {
+    if (values.length === 0) {
+        return [];
+    }
+
+    const requestedLimit = Number.isFinite(limit) ? Math.floor(limit) : 1;
+    const workerLimit = Math.max(1, requestedLimit);
+    const results = new Array<TResult>(values.length);
+    let nextIndex = 0;
+
+    const worker = async () => {
+        while (nextIndex < values.length) {
+            const currentIndex = nextIndex;
+            nextIndex += 1;
+            results[currentIndex] = await mapper(values[currentIndex]!, currentIndex);
+        }
+    };
+
+    await Promise.all(Array.from({ length: Math.min(workerLimit, values.length) }, () => worker()));
+    return results;
+};

package/src/lib/cursor-db.ts

@@ -1,4 +1,5 @@
 import { constants, Database } from 'bun:sqlite';
+import { createHash } from 'node:crypto';
 import { readdir, stat } from 'node:fs/promises';
 import path from 'node:path';
 import {
@@ -109,13 +110,29 @@ const normalizeCursorPath = (value: string): string => {
     return decoded.replace(/\/+$/u, '') || decoded;
 };
 
+const warnCursorDataIssue = (event: string, details: Record<string, unknown>) => {
+    console.warn(`[spiracha:cursor] ${event}`, details);
+};
+
+const stripJsonComments = (value: string): string => {
+    return value.replace(/\/\*[\s\S]*?\*\//gu, '').replace(/(^|\s)\/\/.*$/gmu, '$1');
+};
+
+const parseCodeWorkspaceJson = (text: string): { folders?: Array<{ path?: string }> } => {
+    try {
+        return JSON.parse(text) as { folders?: Array<{ path?: string }> };
+    } catch {
+        return JSON.parse(stripJsonComments(text)) as { folders?: Array<{ path?: string }> };
+    }
+};
+
 const parseCodeWorkspaceFolders = async (workspaceFilePath: string): Promise<string[]> => {
     if (!workspaceFilePath.endsWith('.code-workspace')) {
         return [];
     }
 
     try {
-        const data = (await Bun.file(workspaceFilePath).json()) as { folders?: Array<{ path?: string }> };
+        const data = parseCodeWorkspaceJson(await Bun.file(workspaceFilePath).text());
         const folders: string[] = [];
         for (const entry of data.folders ?? []) {
             const folderPath = entry.path;
@@ -131,18 +148,30 @@ const parseCodeWorkspaceFolders = async (workspaceFilePath: string): Promise<str
         }
 
         return folders;
-    } catch {
+    } catch (error) {
+        warnCursorDataIssue('invalid_code_workspace_json', {
+            error: error instanceof Error ? error.message : String(error),
+            workspaceFilePath,
+        });
         return [];
     }
 };
 
 export const loadGlobalComposerHeaders = (globalDbPath: string): ComposerEntry[] => {
-    const db = openCursorReadonlyDb(globalDbPath);
     try {
-        const data = readItemValue<{ allComposers?: ComposerEntry[] }>(db, COMPOSER_HEADERS_KEY);
-        return data?.allComposers ?? [];
-    } finally {
-        db.close();
+        const db = openCursorReadonlyDb(globalDbPath);
+        try {
+            const data = readItemValue<{ allComposers?: ComposerEntry[] }>(db, COMPOSER_HEADERS_KEY);
+            return data?.allComposers ?? [];
+        } finally {
+            db.close();
+        }
+    } catch (error) {
+        warnCursorDataIssue('global_composer_headers_unavailable', {
+            error: error instanceof Error ? error.message : String(error),
+            globalDbPath,
+        });
+        return [];
     }
 };
 
@@ -1055,6 +1084,274 @@ const isRenderableBubble = (bubble: CursorBubble): boolean => {
     return Boolean(bubble.text.trim() || bubble.thinking?.trim() || bubble.toolCall);
 };
 
+const normalizeBubbleText = (value: string | null): string => {
+    return (value ?? '').replace(/\s+/gu, ' ').trim();
+};
+
+const hashText = (value: string) => createHash('sha1').update(value).digest('hex').slice(0, 12);
+
+const stableStringifyJson = (value: JsonValue): string => {
+    if (Array.isArray(value)) {
+        return `[${value.map(stableStringifyJson).join(',')}]`;
+    }
+
+    if (value && typeof value === 'object') {
+        return `{${Object.keys(value)
+            .sort()
+            .map((key) => `${JSON.stringify(key)}:${stableStringifyJson((value as Record<string, JsonValue>)[key]!)}`)
+            .join(',')}}`;
+    }
+
+    return JSON.stringify(value);
+};
+
+const normalizeToolArgumentsText = (value: string | null): string => {
+    if (!value?.trim()) {
+        return '';
+    }
+
+    try {
+        return stableStringifyJson(JSON.parse(value) as JsonValue);
+    } catch {
+        return normalizeBubbleText(value);
+    }
+};
+
+const hasRenderableTextSuperset = (left: string | null, right: string | null): boolean => {
+    const normalizedLeft = normalizeBubbleText(left);
+    const normalizedRight = normalizeBubbleText(right);
+    if (!normalizedLeft && !normalizedRight) {
+        return true;
+    }
+
+    return (
+        normalizedLeft === normalizedRight ||
+        normalizedLeft.startsWith(normalizedRight) ||
+        normalizedRight.startsWith(normalizedLeft)
+    );
+};
+
+const haveSameToolIdentity = (left: CursorToolCall | null, right: CursorToolCall | null): boolean => {
+    if (!left && !right) {
+        return true;
+    }
+
+    if (!left || !right) {
+        return false;
+    }
+
+    return (
+        left.name === right.name &&
+        normalizeToolArgumentsText(left.argumentsText) === normalizeToolArgumentsText(right.argumentsText)
+    );
+};
+
+const areEquivalentBubbles = (left: CursorBubble, right: CursorBubble): boolean => {
+    return (
+        left.kind === right.kind &&
+        hasRenderableTextSuperset(left.text, right.text) &&
+        Boolean(normalizeBubbleText(left.thinking)) === Boolean(normalizeBubbleText(right.thinking)) &&
+        haveSameToolIdentity(left.toolCall, right.toolCall)
+    );
+};
+
+const findAgentTailStartIndex = (existingBubbles: CursorBubble[], agentBubbles: CursorBubble[]): number => {
+    const maxOverlap = Math.min(existingBubbles.length, agentBubbles.length);
+    // Agent transcript files contain the complete run while SQLite may lag or truncate the tail.
+    // Match the longest SQLite suffix to the agent prefix, then append only the remaining agent tail.
+    for (let overlapLength = maxOverlap; overlapLength > 0; overlapLength -= 1) {
+        const existingStart = existingBubbles.length - overlapLength;
+        const matches = agentBubbles
+            .slice(0, overlapLength)
+            .every((bubble, index) => areEquivalentBubbles(existingBubbles[existingStart + index]!, bubble));
+        if (matches) {
+            return overlapLength;
+        }
+    }
+
+    return 0;
+};
+
+const hasEquivalentBubble = (bubbles: CursorBubble[], candidate: CursorBubble): boolean => {
+    return bubbles.some((bubble) => areEquivalentBubbles(bubble, candidate));
+};
+
+const getAgentTranscriptContentParts = (entry: Record<string, JsonValue>): Record<string, JsonValue>[] => {
+    const message = asObject(entry.message ?? null);
+    const content = message?.content ?? entry.content ?? null;
+    if (Array.isArray(content)) {
+        return content.map((part) => asObject(part)).filter((part): part is Record<string, JsonValue> => Boolean(part));
+    }
+
+    if (typeof content === 'string') {
+        return [{ text: content, type: 'text' }];
+    }
+
+    return [];
+};
+
+const parseAgentTranscriptToolCall = (parts: Record<string, JsonValue>[]): CursorToolCall | null => {
+    const toolUse = parts.find((part) => asString(part.type ?? null) === 'tool_use');
+    if (!toolUse) {
+        return null;
+    }
+
+    const name = asString(toolUse.name ?? null);
+    if (!name) {
+        return null;
+    }
+
+    return {
+        argumentsText: toolUse.input === undefined ? null : JSON.stringify(toolUse.input),
+        callId: asString(toolUse.id ?? null),
+        name,
+        resultText: null,
+        status: null,
+    };
+};
+
+const parseAgentTranscriptBubble = (
+    filePath: string,
+    lineNumber: number,
+    raw: Record<string, JsonValue>,
+): CursorBubble | null => {
+    const message = asObject(raw.message ?? null);
+    const role = asString(raw.role ?? message?.role ?? null);
+    const kind = role === 'user' || role === 'assistant' ? role : 'unknown';
+    const parts = getAgentTranscriptContentParts(raw);
+    const text = parts
+        .filter((part) => asString(part.type ?? null) === 'text')
+        .map((part) => asString(part.text ?? null))
+        .filter((value): value is string => Boolean(value?.trim()))
+        .join('\n\n');
+    const toolCall = parseAgentTranscriptToolCall(parts);
+    const bubble: CursorBubble = {
+        bubbleId: `agent-transcript:${hashText(path.resolve(filePath))}:${path.basename(filePath)}:${lineNumber}`,
+        createdAtMs: null,
+        kind,
+        text,
+        thinking: null,
+        toolCall,
+    };
+
+    return isRenderableBubble(bubble) ? bubble : null;
+};
+
+const readCursorAgentTranscriptFile = async (filePath: string): Promise<CursorBubble[]> => {
+    let text = '';
+    try {
+        text = await Bun.file(filePath).text();
+    } catch (error) {
+        warnCursorDataIssue('agent_transcript_unreadable', {
+            error: error instanceof Error ? error.message : String(error),
+            filePath,
+        });
+        return [];
+    }
+
+    const bubbles: CursorBubble[] = [];
+    for (const [index, line] of text.split(/\n/u).entries()) {
+        if (!line.trim()) {
+            continue;
+        }
+
+        let raw: JsonValue;
+        try {
+            raw = JSON.parse(line) as JsonValue;
+        } catch (error) {
+            warnCursorDataIssue('invalid_agent_transcript_jsonl', {
+                error: error instanceof Error ? error.message : String(error),
+                filePath,
+                lineNumber: index + 1,
+            });
+            continue;
+        }
+
+        const entry = asObject(raw);
+        if (!entry) {
+            continue;
+        }
+
+        const bubble = parseAgentTranscriptBubble(filePath, index + 1, entry);
+        if (bubble) {
+            bubbles.push(bubble);
+        }
+    }
+
+    return bubbles;
+};
+
+const listCursorAgentTranscriptFiles = async (transcriptDir: string, composerId: string): Promise<string[]> => {
+    const preferred = path.join(transcriptDir, `${composerId}.jsonl`);
+    const files = new Set<string>();
+    if (await pathExists(preferred)) {
+        files.add(preferred);
+    }
+
+    let entries: string[] = [];
+    try {
+        entries = await readdir(transcriptDir);
+    } catch {
+        return [...files];
+    }
+
+    for (const entry of entries) {
+        if (entry.endsWith('.jsonl')) {
+            files.add(path.join(transcriptDir, entry));
+        }
+    }
+
+    return [...files].sort();
+};
+
+const readCursorAgentTranscriptBubbles = async (composerId: string, userDir: string): Promise<CursorBubble[]> => {
+    const transcriptDirs = await findCursorTranscriptDirs(composerId, userDir);
+    const bubbles: CursorBubble[] = [];
+    for (const transcriptDir of transcriptDirs.sort()) {
+        const files = await listCursorAgentTranscriptFiles(transcriptDir, composerId);
+        for (const file of files) {
+            bubbles.push(...(await readCursorAgentTranscriptFile(file)));
+        }
+    }
+
+    return bubbles;
+};
+
+const mergeAgentTranscriptTail = (
+    transcript: CursorThreadTranscript,
+    agentBubbles: CursorBubble[],
+): CursorThreadTranscript => {
+    const tailStartIndex = findAgentTailStartIndex(transcript.bubbles, agentBubbles);
+    const seen = [...transcript.bubbles];
+    const appended: CursorBubble[] = [];
+    const candidates = agentBubbles.slice(tailStartIndex);
+    for (const bubble of candidates) {
+        if (hasEquivalentBubble(seen, bubble)) {
+            continue;
+        }
+
+        seen.push(bubble);
+        appended.push(bubble);
+    }
+
+    if (appended.length === 0) {
+        return transcript;
+    }
+
+    return {
+        ...transcript,
+        bubbles: [...transcript.bubbles, ...appended],
+        renderableBubbleCount: transcript.renderableBubbleCount + appended.length,
+    };
+};
+
+const inferCursorUserDirFromGlobalDbPath = (globalDbPath: string): string => {
+    const globalStorageDir = path.dirname(globalDbPath);
+    return path.basename(globalStorageDir) === 'globalStorage'
+        ? path.dirname(globalStorageDir)
+        : resolveCursorUserDir();
+};
+
 export const readCursorThreadTranscript = (globalDbPath: string, composerId: string): CursorThreadTranscript | null => {
     const head = readCursorThreadHead(globalDbPath, composerId);
     if (!head) {
@@ -1087,6 +1384,20 @@ export const readCursorThreadTranscript = (globalDbPath: string, composerId: str
     }
 };
 
+export const readCursorThreadTranscriptWithAgentFiles = async (
+    globalDbPath: string,
+    composerId: string,
+    userDir = inferCursorUserDirFromGlobalDbPath(globalDbPath),
+): Promise<CursorThreadTranscript | null> => {
+    const transcript = readCursorThreadTranscript(globalDbPath, composerId);
+    if (!transcript) {
+        return null;
+    }
+
+    const agentBubbles = await readCursorAgentTranscriptBubbles(composerId, userDir);
+    return mergeAgentTranscriptTail(transcript, agentBubbles);
+};
+
 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<{

package/src/lib/cursor-exporter.ts

@@ -4,7 +4,7 @@ import {
     listCursorThreadsForGroup,
     listCursorWorkspaceGroups,
     readCursorThreadHead,
-    readCursorThreadTranscript,
+    readCursorThreadTranscriptWithAgentFiles,
 } from './cursor-db';
 import {
     type CursorCliOptions,
@@ -115,7 +115,7 @@ const exportSingleThread = async (
     outputDir: string,
     options: CursorCliOptions,
 ): Promise<CursorExportedFile | null> => {
-    const transcript = readCursorThreadTranscript(globalDbPath, thread.composerId);
+    const transcript = await readCursorThreadTranscriptWithAgentFiles(globalDbPath, thread.composerId, options.userDir);
     if (!transcript) {
         return null;
     }