spiracha 2.0.0 → 2.1.0

package/apps/ui/src/lib/claude-code-server.ts

@@ -1,6 +1,10 @@
 import { createServerFn } from '@tanstack/react-start';
 import { z } from 'zod';
-import { renderSourceSessionDownload } from './source-session-export-server';
+import { renderSourceSessionDownload, renderSourceSessionsDownload } from './source-session-export-server';
+
+const LARGE_CLAUDE_CODE_SESSION_SIZE_BYTES = 8 * 1024 * 1024;
+const CLAUDE_CODE_DETAIL_PREVIEW_ENTRY_LIMIT = 400;
+const CLAUDE_CODE_DETAIL_PREVIEW_LEADING_ENTRY_LIMIT = 100;
 
 const workspaceSchema = z.object({
     workspaceKey: z.string().min(1),
@@ -19,6 +23,19 @@ const exportSessionSchema = z.object({
     zipArchive: z.boolean().default(false),
 });
 
+const exportSessionsSchema = z.object({
+    includeCommentary: z.boolean().default(true),
+    includeMetadata: z.boolean().default(true),
+    includeTools: z.boolean().default(true),
+    outputFormat: z.enum(['md', 'txt']).default('md'),
+    sessionIds: z.array(z.string().min(1)).min(1),
+    zipArchive: z.boolean().default(true),
+});
+
+const deleteSessionsSchema = z.object({
+    sessionIds: z.array(z.string().min(1)).min(1),
+});
+
 export const listClaudeCodeWorkspacesFn = createServerFn({ method: 'GET' }).handler(async () => {
     const { listClaudeCodeWorkspaceGroups } = await import('@spiracha/lib/claude-code-db');
     return listClaudeCodeWorkspaceGroups();
@@ -32,21 +49,112 @@ export const listClaudeCodeSessionsFn = createServerFn({ method: 'GET' })
     });
 
 const loadClaudeCodeSessionTranscript = async (sessionId: string) => {
+    const { runWithTranscriptLoadLimit } = await import('@spiracha/lib/transcript-load-limiter');
     const { readClaudeCodeSessionTranscript, resolveClaudeCodeProjectsDir } = await import(
         '@spiracha/lib/claude-code-db'
     );
-    const transcript = await readClaudeCodeSessionTranscript(resolveClaudeCodeProjectsDir(), sessionId);
-    if (!transcript) {
-        throw new Error(`Claude Code session not found: ${sessionId}`);
+    const projectsDir = resolveClaudeCodeProjectsDir();
+    return runWithTranscriptLoadLimit(
+        async () => {
+            const transcript = await readClaudeCodeSessionTranscript(projectsDir, sessionId);
+            if (!transcript) {
+                throw new Error(`Claude Code session not found: ${sessionId}`);
+            }
+
+            return transcript;
+        },
+        {
+            id: sessionId,
+            path: projectsDir,
+            source: 'claude-code-ui',
+        },
+    );
+};
+
+export const buildClaudeCodeSessionDetailPreview = (
+    transcript: Awaited<ReturnType<typeof loadClaudeCodeSessionTranscript>>,
+) => {
+    if (transcript.entries.length <= CLAUDE_CODE_DETAIL_PREVIEW_ENTRY_LIMIT) {
+        return transcript;
     }
 
-    return transcript;
+    const trailingEntryLimit = CLAUDE_CODE_DETAIL_PREVIEW_ENTRY_LIMIT - CLAUDE_CODE_DETAIL_PREVIEW_LEADING_ENTRY_LIMIT;
+    return {
+        ...transcript,
+        entries: [
+            ...transcript.entries.slice(0, CLAUDE_CODE_DETAIL_PREVIEW_LEADING_ENTRY_LIMIT),
+            ...transcript.entries.slice(-trailingEntryLimit),
+        ].map((entry) => ({
+            ...entry,
+            parts: entry.parts.map((part) => ({ ...part, raw: {} })),
+            raw: {},
+        })),
+        isPartial: true,
+        omittedEntryCount: transcript.entries.length - CLAUDE_CODE_DETAIL_PREVIEW_ENTRY_LIMIT,
+        rawEvents: [],
+        rawPayloadsOmitted: true,
+    };
+};
+
+export const loadClaudeCodeSessionDetail = async (sessionId: string) => {
+    const { runWithTranscriptLoadLimit } = await import('@spiracha/lib/transcript-load-limiter');
+    const { readClaudeCodeSessionTranscript, resolveClaudeCodeProjectsDir } = await import(
+        '@spiracha/lib/claude-code-db'
+    );
+    const projectsDir = resolveClaudeCodeProjectsDir();
+    return runWithTranscriptLoadLimit(
+        async () => {
+            const transcript = await readClaudeCodeSessionTranscript(projectsDir, sessionId, {
+                maxRawPayloadFileSizeBytes: LARGE_CLAUDE_CODE_SESSION_SIZE_BYTES,
+            });
+            if (!transcript) {
+                throw new Error(`Claude Code session not found: ${sessionId}`);
+            }
+
+            return buildClaudeCodeSessionDetailPreview(transcript);
+        },
+        {
+            id: sessionId,
+            path: projectsDir,
+            source: 'claude-code-ui-detail',
+        },
+    );
+};
+
+export const loadClaudeCodeSessionFullDetail = async (sessionId: string) => {
+    const { runWithTranscriptLoadLimit } = await import('@spiracha/lib/transcript-load-limiter');
+    const { readClaudeCodeSessionTranscript, resolveClaudeCodeProjectsDir } = await import(
+        '@spiracha/lib/claude-code-db'
+    );
+    const projectsDir = resolveClaudeCodeProjectsDir();
+    return runWithTranscriptLoadLimit(
+        async () => {
+            const transcript = await readClaudeCodeSessionTranscript(projectsDir, sessionId, {
+                includeRawPayloads: false,
+            });
+            if (!transcript) {
+                throw new Error(`Claude Code session not found: ${sessionId}`);
+            }
+            return transcript;
+        },
+        {
+            id: sessionId,
+            path: projectsDir,
+            source: 'claude-code-ui-full-detail',
+        },
+    );
 };
 
 export const getClaudeCodeSessionDetailFn = createServerFn({ method: 'GET' })
     .validator(sessionSchema)
     .handler(async ({ data }) => {
-        return loadClaudeCodeSessionTranscript(data.sessionId);
+        return loadClaudeCodeSessionDetail(data.sessionId);
+    });
+
+export const getClaudeCodeSessionTranscriptFn = createServerFn({ method: 'GET' })
+    .validator(sessionSchema)
+    .handler(async ({ data }) => {
+        return loadClaudeCodeSessionFullDetail(data.sessionId);
     });
 
 export const exportClaudeCodeSessionFn = createServerFn({ method: 'POST' })
@@ -67,9 +175,69 @@ export const exportClaudeCodeSessionFn = createServerFn({ method: 'POST' })
 
         return renderSourceSessionDownload({
             content,
+            cwd: transcript.session.cwd ?? transcript.session.worktree,
             fallbackBaseName: 'claude-code-session',
-            fileBaseName: transcript.session.title || transcript.session.sessionId,
             outputFormat: data.outputFormat,
+            sessionId: transcript.session.sessionId,
+            updatedAtMs: transcript.session.lastActiveAtMs,
             zipArchive: data.zipArchive,
         });
     });
+
+export const exportClaudeCodeSessionsFn = createServerFn({ method: 'POST' })
+    .validator(exportSessionsSchema)
+    .handler(async ({ data }) => {
+        const { renderClaudeCodeTranscript } = await import('@spiracha/lib/claude-code-transcript');
+        const entries = await Promise.all(
+            data.sessionIds.map(async (sessionId) => {
+                const transcript = await loadClaudeCodeSessionTranscript(sessionId);
+                const content = renderClaudeCodeTranscript(transcript, {
+                    includeCommentary: data.includeCommentary,
+                    includeMetadata: data.includeMetadata,
+                    includeTools: data.includeTools,
+                    outputFormat: data.outputFormat,
+                });
+
+                if (!content) {
+                    throw new Error(`Claude Code session has no exportable content: ${sessionId}`);
+                }
+
+                return {
+                    content,
+                    cwd: transcript.session.cwd ?? transcript.session.worktree,
+                    fallbackBaseName: 'claude-code-session',
+                    fileBaseName: transcript.session.title || transcript.session.sessionId,
+                    sessionId: transcript.session.sessionId,
+                    updatedAtMs: transcript.session.lastActiveAtMs,
+                };
+            }),
+        );
+
+        return renderSourceSessionsDownload({
+            entries,
+            fallbackBaseName: 'claude-code-sessions',
+            outputFormat: data.outputFormat,
+            zipArchive: data.zipArchive,
+        });
+    });
+
+export const deleteClaudeCodeSessionFn = createServerFn({ method: 'POST' })
+    .validator(sessionSchema)
+    .handler(async ({ data }) => {
+        const { deleteClaudeCodeSession, resolveClaudeCodeProjectsDir } = await import('@spiracha/lib/claude-code-db');
+        return deleteClaudeCodeSession(resolveClaudeCodeProjectsDir(), data.sessionId);
+    });
+
+export const deleteClaudeCodeSessionsFn = createServerFn({ method: 'POST' })
+    .validator(deleteSessionsSchema)
+    .handler(async ({ data }) => {
+        const { deleteClaudeCodeSession, resolveClaudeCodeProjectsDir } = await import('@spiracha/lib/claude-code-db');
+        const projectsDir = resolveClaudeCodeProjectsDir();
+        const results = await Promise.all(
+            data.sessionIds.map((sessionId) => deleteClaudeCodeSession(projectsDir, sessionId)),
+        );
+        return {
+            deletedFiles: [...new Set(results.flatMap((result) => result.deletedFiles))],
+            deletedSessionIds: [...new Set(results.flatMap((result) => result.deletedSessionIds))],
+        };
+    });

package/apps/ui/src/lib/claude-code-transcript-events.ts

@@ -3,7 +3,10 @@ import type {
     ClaudeCodeTranscriptEntry,
     ClaudeCodeTranscriptPart,
 } from '@spiracha/lib/claude-code-exporter-types';
-import { getClaudeCodeAssistantMessagePhase } from '@spiracha/lib/claude-code-transcript-phase';
+import {
+    getClaudeCodeAssistantMessagePhase,
+    isClaudeCodeSyntheticTranscriptEntry,
+} from '@spiracha/lib/claude-code-transcript-phase';
 import type { ThreadEvent, ThreadTranscriptStats } from '@spiracha/lib/codex-browser-types';
 import type { JsonValue } from '@spiracha/lib/shared';
 import { getThreadTranscriptStats } from './thread-transcript-stats';
@@ -141,6 +144,10 @@ export const claudeCodeTranscriptToThreadEvents = (transcript: ClaudeCodeSession
     const events: ThreadEvent[] = [];
     let sequence = 0;
     for (const entry of transcript.entries) {
+        if (isClaudeCodeSyntheticTranscriptEntry(entry)) {
+            continue;
+        }
+
         for (const part of entry.parts) {
             events.push(...partToEvents(entry, part, sequence));
             sequence += 1;

package/apps/ui/src/lib/codex-queries.ts

@@ -5,10 +5,18 @@ import {
     getDashboardSummaryFn,
     getThreadSnapshotFn,
     getThreadTranscriptFn,
+    getThreadTranscriptPreviewFn,
     listProjectsFn,
     listProjectThreadsFn,
 } from './codex-server';
 
+type ThreadTranscriptFilters = {
+    showCommentary: boolean;
+    showExtraEvents: boolean;
+    showToolCalls: boolean;
+    showUserMessages: boolean;
+};
+
 const retrySqliteQuery = (failureCount: number, error: unknown) => {
     return failureCount < 3 && isRetryableSqliteError(error);
 };
@@ -41,10 +49,18 @@ export const projectThreadsQueryOptions = (project: string) =>
         retryDelay,
     });
 
-export const threadSnapshotQueryOptions = (threadId: string) =>
+export const threadSnapshotQueryOptions = (threadId: string, filters?: ThreadTranscriptFilters) =>
+    queryOptions({
+        queryFn: () => getThreadSnapshotFn({ data: { filters, threadId } }),
+        queryKey: ['thread', threadId, filters ?? 'all'],
+        retry: retrySqliteQuery,
+        retryDelay,
+    });
+
+export const threadTranscriptPreviewQueryOptions = (threadId: string, filters?: ThreadTranscriptFilters) =>
     queryOptions({
-        queryFn: () => getThreadSnapshotFn({ data: { threadId } }),
-        queryKey: ['thread', threadId],
+        queryFn: () => getThreadTranscriptPreviewFn({ data: { filters, threadId } }),
+        queryKey: ['thread-transcript-preview', threadId, filters ?? 'all'],
         retry: retrySqliteQuery,
         retryDelay,
     });

package/apps/ui/src/lib/codex-server.ts

@@ -1,21 +1,4 @@
-import { getCodexAnalytics } from '@spiracha/lib/codex-analytics';
-import {
-    deleteCodexProject,
-    deleteCodexThread,
-    deleteCodexThreads,
-    getCodexDashboardSummary,
-    getThreadBrowseData,
-    listCodexProjects,
-    listProjectThreads,
-    resolveCodexThreadDbPath,
-} from '@spiracha/lib/codex-browser-db';
-import { renderCodexThreadDownload, renderCodexThreadsDownload } from '@spiracha/lib/codex-browser-export';
-import {
-    getCachedParsedCodexTranscript,
-    getCachedThreadTranscriptPreview,
-    getThreadRolloutLoadState,
-} from '@spiracha/lib/codex-thread-cache';
-import { recoverCodexProjectThreads } from '@spiracha/lib/codex-thread-recovery';
+import type { ParsedCodexTranscript } from '@spiracha/lib/codex-browser-types';
 import { createServerFn } from '@tanstack/react-start';
 import { z } from 'zod';
 
@@ -32,6 +15,18 @@ const threadSchema = z.object({
     threadId: z.string().min(1),
 });
 
+const transcriptFiltersSchema = z.object({
+    showCommentary: z.boolean(),
+    showExtraEvents: z.boolean(),
+    showToolCalls: z.boolean(),
+    showUserMessages: z.boolean(),
+});
+
+const threadSnapshotSchema = z.object({
+    filters: transcriptFiltersSchema.optional(),
+    threadId: z.string().min(1),
+});
+
 const deleteThreadSchema = z.object({
     deleteSessionFiles: z.boolean().default(false),
     threadId: z.string().min(1),
@@ -68,76 +63,157 @@ const exportThreadsSchema = z.object({
     zipArchive: z.boolean().default(true),
 });
 
-const getDbPath = () => process.env.SPIRACHA_CODEX_DB?.trim() || resolveCodexThreadDbPath();
+const getDbPath = async () => {
+    const configuredDbPath = process.env.SPIRACHA_CODEX_DB?.trim();
+    if (configuredDbPath) {
+        return configuredDbPath;
+    }
+
+    const { resolveCodexThreadDbPath } = await import('@spiracha/lib/codex-browser-db');
+    return resolveCodexThreadDbPath();
+};
 
 const isMissingFileError = (error: unknown) => {
     return error instanceof Error && /ENOENT|no such file/i.test(error.message);
 };
 
+const logCodexThreadLoad = (event: string, details: Record<string, unknown>) => {
+    console.info(`[spiracha:codex-thread] ${event}`, details);
+};
+
 export const getDashboardSummaryFn = createServerFn({ method: 'GET' }).handler(async () => {
-    return getCodexDashboardSummary(getDbPath());
+    const { getCodexDashboardSummary } = await import('@spiracha/lib/codex-browser-db');
+    return getCodexDashboardSummary(await getDbPath());
 });
 
 export const listProjectsFn = createServerFn({ method: 'GET' }).handler(async () => {
-    return listCodexProjects(getDbPath());
+    const { listCodexProjects } = await import('@spiracha/lib/codex-browser-db');
+    return listCodexProjects(await getDbPath());
 });
 
 export const listProjectThreadsFn = createServerFn({ method: 'GET' })
     .validator(projectSchema)
     .handler(async ({ data }) => {
-        return listProjectThreads(getDbPath(), data.project, {
+        const { listProjectThreads } = await import('@spiracha/lib/codex-browser-db');
+        return listProjectThreads(await getDbPath(), data.project, {
             includeTranscriptStats: false,
         });
     });
 
 export const getThreadSnapshotFn = createServerFn({ method: 'GET' })
-    .validator(threadSchema)
+    .validator(threadSnapshotSchema)
     .handler(async ({ data }) => {
-        const dbPath = getDbPath();
+        const startedAt = Date.now();
+        const [{ getThreadBrowseData }, { getThreadRolloutLoadState }] = await Promise.all([
+            import('@spiracha/lib/codex-browser-db'),
+            import('@spiracha/lib/codex-thread-cache'),
+        ]);
+        const dbPath = await getDbPath();
+        logCodexThreadLoad('snapshot_start', {
+            threadId: data.threadId,
+        });
         const browseData = getThreadBrowseData(dbPath, data.threadId);
-        const rollout = await getThreadRolloutLoadState(browseData.thread.rollout_path);
-        let transcript = null;
-        let transcriptState: 'available' | 'deferred' | 'missing' = rollout.shouldDeferTranscriptLoad
-            ? 'deferred'
-            : 'available';
-
-        if (!rollout.shouldDeferTranscriptLoad) {
-            try {
-                transcript = await getCachedParsedCodexTranscript(browseData.thread.rollout_path);
-            } catch (error) {
-                if (!isMissingFileError(error)) {
-                    throw error;
-                }
-
-                transcriptState = 'missing';
+        const transcript: ParsedCodexTranscript | null = null;
+        let rollout: Awaited<ReturnType<typeof getThreadRolloutLoadState>>;
+
+        try {
+            rollout = await getThreadRolloutLoadState(browseData.thread.rollout_path);
+        } catch (error) {
+            if (!isMissingFileError(error)) {
+                throw error;
             }
+
+            rollout = {
+                fileSizeBytes: null,
+                shouldDeferTranscriptLoad: false,
+            };
         }
 
+        const transcriptState: 'available' | 'deferred' | 'missing' =
+            rollout.fileSizeBytes === null ? 'missing' : rollout.shouldDeferTranscriptLoad ? 'deferred' : 'available';
+        logCodexThreadLoad('snapshot_ready', {
+            durationMs: Date.now() - startedAt,
+            fileSizeBytes: rollout.fileSizeBytes,
+            shouldDeferTranscriptLoad: rollout.shouldDeferTranscriptLoad,
+            threadId: data.threadId,
+            transcriptState,
+        });
+
         return {
             ...browseData,
-            availableTools:
-                browseData.dynamicTools.length > 0
-                    ? browseData.dynamicTools
-                    : (transcript?.sessionMeta.dynamicTools ?? []),
+            availableTools: browseData.dynamicTools,
             rollout,
             transcript,
             transcriptState,
         };
     });
 
+export const loadThreadTranscriptPreview = async (
+    threadId: string,
+    filters?: z.infer<typeof transcriptFiltersSchema>,
+) => {
+    const startedAt = Date.now();
+    const [{ getThreadBrowseData }, { getCachedThreadTranscriptPreview }] = await Promise.all([
+        import('@spiracha/lib/codex-browser-db'),
+        import('@spiracha/lib/codex-thread-cache'),
+    ]);
+    const dbPath = await getDbPath();
+    const browseData = getThreadBrowseData(dbPath, threadId);
+    logCodexThreadLoad('preview_start', {
+        rolloutPath: browseData.thread.rollout_path,
+        threadId,
+    });
+    const transcript = await getCachedThreadTranscriptPreview(browseData.thread.rollout_path, {
+        filters,
+    });
+    logCodexThreadLoad('preview_ready', {
+        durationMs: Date.now() - startedAt,
+        eventCount: transcript.events.length,
+        isPartial: transcript.isPartial,
+        threadId,
+    });
+    return transcript;
+};
+
+export const loadThreadTranscript = async (threadId: string) => {
+    const [{ getThreadBrowseData }, { getCachedParsedCodexTranscript }] = await Promise.all([
+        import('@spiracha/lib/codex-browser-db'),
+        import('@spiracha/lib/codex-thread-cache'),
+    ]);
+    const dbPath = await getDbPath();
+    const browseData = getThreadBrowseData(dbPath, threadId);
+    const startedAt = Date.now();
+    logCodexThreadLoad('full_start', {
+        rolloutPath: browseData.thread.rollout_path,
+        threadId,
+    });
+    const transcript = await getCachedParsedCodexTranscript(browseData.thread.rollout_path);
+    logCodexThreadLoad('full_ready', {
+        durationMs: Date.now() - startedAt,
+        eventCount: transcript.events.length,
+        threadId,
+    });
+    return transcript;
+};
+
+export const getThreadTranscriptPreviewFn = createServerFn({ method: 'GET' })
+    .validator(threadSnapshotSchema)
+    .handler(async ({ data }) => {
+        return loadThreadTranscriptPreview(data.threadId, data.filters);
+    });
+
 export const getThreadTranscriptFn = createServerFn({ method: 'GET' })
     .validator(threadSchema)
     .handler(async ({ data }) => {
-        const dbPath = getDbPath();
-        const browseData = getThreadBrowseData(dbPath, data.threadId);
-        return getCachedThreadTranscriptPreview(browseData.thread.rollout_path);
+        return loadThreadTranscript(data.threadId);
     });
 
 export const getAnalyticsFn = createServerFn({ method: 'GET' })
     .validator(analyticsSchema)
     .handler(async ({ data }) => {
+        const { getCodexAnalytics } = await import('@spiracha/lib/codex-analytics');
         return getCodexAnalytics({
-            dbPath: getDbPath(),
+            dbPath: await getDbPath(),
             project: data.project,
         });
     });
@@ -145,8 +221,9 @@ export const getAnalyticsFn = createServerFn({ method: 'GET' })
 export const exportThreadFn = createServerFn({ method: 'POST' })
     .validator(exportSchema)
     .handler(async ({ data }) => {
+        const { renderCodexThreadDownload } = await import('@spiracha/lib/codex-browser-export');
         return renderCodexThreadDownload({
-            dbPath: getDbPath(),
+            dbPath: await getDbPath(),
             includeCommentary: data.includeCommentary,
             includeMetadata: data.includeMetadata,
             includeTools: data.includeTools,
@@ -163,8 +240,9 @@ export const exportThreadFn = createServerFn({ method: 'POST' })
 export const exportThreadsFn = createServerFn({ method: 'POST' })
     .validator(exportThreadsSchema)
     .handler(async ({ data }) => {
+        const { renderCodexThreadsDownload } = await import('@spiracha/lib/codex-browser-export');
         return renderCodexThreadsDownload({
-            dbPath: getDbPath(),
+            dbPath: await getDbPath(),
             includeCommentary: data.includeCommentary,
             includeMetadata: data.includeMetadata,
             includeTools: data.includeTools,
@@ -181,7 +259,8 @@ export const exportThreadsFn = createServerFn({ method: 'POST' })
 export const deleteThreadFn = createServerFn({ method: 'POST' })
     .validator(deleteThreadSchema)
     .handler(async ({ data }) => {
-        return deleteCodexThread(getDbPath(), data.threadId, {
+        const { deleteCodexThread } = await import('@spiracha/lib/codex-browser-db');
+        return deleteCodexThread(await getDbPath(), data.threadId, {
             deleteSessionFiles: data.deleteSessionFiles,
         });
     });
@@ -189,7 +268,8 @@ export const deleteThreadFn = createServerFn({ method: 'POST' })
 export const deleteThreadsFn = createServerFn({ method: 'POST' })
     .validator(deleteThreadsSchema)
     .handler(async ({ data }) => {
-        return deleteCodexThreads(getDbPath(), data.threadIds, {
+        const { deleteCodexThreads } = await import('@spiracha/lib/codex-browser-db');
+        return deleteCodexThreads(await getDbPath(), data.threadIds, {
             deleteSessionFiles: data.deleteSessionFiles,
         });
     });
@@ -197,7 +277,8 @@ export const deleteThreadsFn = createServerFn({ method: 'POST' })
 export const deleteProjectFn = createServerFn({ method: 'POST' })
     .validator(deleteProjectSchema)
     .handler(async ({ data }) => {
-        return deleteCodexProject(getDbPath(), data.project, {
+        const { deleteCodexProject } = await import('@spiracha/lib/codex-browser-db');
+        return deleteCodexProject(await getDbPath(), data.project, {
             deleteSessionFiles: data.deleteSessionFiles,
         });
     });
@@ -205,5 +286,6 @@ export const deleteProjectFn = createServerFn({ method: 'POST' })
 export const recoverProjectThreadsFn = createServerFn({ method: 'POST' })
     .validator(projectSchema)
     .handler(async ({ data }) => {
-        return recoverCodexProjectThreads(getDbPath(), data.project);
+        const { recoverCodexProjectThreads } = await import('@spiracha/lib/codex-thread-recovery');
+        return recoverCodexProjectThreads(await getDbPath(), data.project);
     });

package/apps/ui/src/lib/cursor-server.ts

@@ -3,6 +3,8 @@ import { mkdtemp, rm } from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
 import {
+    buildBatchExportBaseName,
+    buildConversationExportBaseName,
     getExportMimeType,
     resolveUniqueExportFileBaseName,
     sanitizeExportFileName,
@@ -72,12 +74,21 @@ const toSafeExportName = (value: string) => {
 };
 
 const renderCursorZipDownload = async (
-    rendered: Array<{ composerId: string; content: string }>,
+    rendered: Array<{ composerId: string; content: string; cwd: string | null; updatedAtMs: number | null }>,
     outputFormat: 'md' | 'txt',
 ) => {
     const exportDir = await ensureUiExportDir();
     const exportBaseName =
-        rendered.length === 1 ? `${toSafeExportName(rendered[0]!.composerId)}` : `cursor-threads-${rendered.length}`;
+        rendered.length === 1
+            ? buildConversationExportBaseName(
+                  {
+                      cwd: rendered[0]!.cwd,
+                      id: rendered[0]!.composerId,
+                      updatedAtMs: rendered[0]!.updatedAtMs,
+                  },
+                  'cursor-thread',
+              )
+            : buildBatchExportBaseName(rendered, 'cursor');
     const workspaceDir = await mkdtemp(path.join(os.tmpdir(), `${exportBaseName}-`));
     const zipPath = path.join(exportDir, `${exportBaseName}-${randomUUID()}.zip`);
     const usedBaseNames = new Map<string, number>();
@@ -123,13 +134,23 @@ const renderCursorDownload = async (input: {
     outputFormat: 'md' | 'txt';
     zipArchive: boolean;
 }) => {
+    const { runWithTranscriptLoadLimit } = await import('@spiracha/lib/transcript-load-limiter');
     const { readCursorThreadTranscriptWithAgentFiles } = await import('@spiracha/lib/cursor-db');
     const { getCursorGlobalDbPath } = await import('@spiracha/lib/cursor-exporter-types');
     const { renderCursorTranscript } = await import('@spiracha/lib/cursor-transcript');
     const globalDbPath = getCursorGlobalDbPath();
+    const { listCursorWorkspaceGroups } = await import('@spiracha/lib/cursor-db');
+    const workspaceGroups = await listCursorWorkspaceGroups();
     const rendered = await Promise.all(
         input.composerIds.map(async (composerId) => {
-            const transcript = await readCursorThreadTranscriptWithAgentFiles(globalDbPath, composerId);
+            const transcript = await runWithTranscriptLoadLimit(
+                () => readCursorThreadTranscriptWithAgentFiles(globalDbPath, composerId),
+                {
+                    id: composerId,
+                    path: globalDbPath,
+                    source: 'cursor-ui-export',
+                },
+            );
             if (!transcript) {
                 throw new Error(`No transcript found for thread: ${composerId}`);
             }
@@ -145,9 +166,16 @@ const renderCursorDownload = async (input: {
                 throw new Error(`Thread has no exportable content: ${composerId}`);
             }
 
+            const workspace =
+                workspaceGroups.find((candidate) =>
+                    candidate.buckets.some((bucket) => bucket.threadComposerIds.includes(composerId)),
+                ) ?? null;
+
             return {
                 composerId,
                 content,
+                cwd: workspace?.folders[0] ?? null,
+                updatedAtMs: transcript.head.lastUpdatedAtMs,
             };
         }),
     );
@@ -159,7 +187,14 @@ const renderCursorDownload = async (input: {
     if (rendered.length === 1) {
         return {
             content: rendered[0]!.content,
-            fileName: `${toSafeExportName(rendered[0]!.composerId)}.${input.outputFormat}`,
+            fileName: `${buildConversationExportBaseName(
+                {
+                    cwd: rendered[0]!.cwd,
+                    id: rendered[0]!.composerId,
+                    updatedAtMs: rendered[0]!.updatedAtMs,
+                },
+                'cursor-thread',
+            )}.${input.outputFormat}`,
             mimeType: getExportMimeType(input.outputFormat),
             mode: 'download' as const,
         };
@@ -184,6 +219,7 @@ export const listCursorThreadsFn = createServerFn({ method: 'GET' })
 export const getCursorThreadDetailFn = createServerFn({ method: 'GET' })
     .validator(threadSchema)
     .handler(async ({ data }) => {
+        const { runWithTranscriptLoadLimit } = await import('@spiracha/lib/transcript-load-limiter');
         const { readCursorThreadTranscriptWithAgentFiles } = await import('@spiracha/lib/cursor-db');
         const { getCursorGlobalDbPath } = await import('@spiracha/lib/cursor-exporter-types');
         const thread = await findCursorThreadByComposerId(data.composerId);
@@ -191,7 +227,14 @@ export const getCursorThreadDetailFn = createServerFn({ method: 'GET' })
             throw new Error(`Cursor thread not found: ${data.composerId}`);
         }
 
-        const transcript = await readCursorThreadTranscriptWithAgentFiles(getCursorGlobalDbPath(), data.composerId);
+        const transcript = await runWithTranscriptLoadLimit(
+            () => readCursorThreadTranscriptWithAgentFiles(getCursorGlobalDbPath(), data.composerId),
+            {
+                id: data.composerId,
+                path: getCursorGlobalDbPath(),
+                source: 'cursor-ui-detail',
+            },
+        );
         return {
             thread,
             transcript,