spiracha 1.5.0 → 2.1.0

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

@@ -0,0 +1,291 @@
+import type { ParsedCodexTranscript } from '@spiracha/lib/codex-browser-types';
+import { createServerFn } from '@tanstack/react-start';
+import { z } from 'zod';
+
+const projectSchema = z.object({
+    project: z.string().min(1),
+});
+
+const deleteProjectSchema = z.object({
+    deleteSessionFiles: z.boolean().default(false),
+    project: z.string().min(1),
+});
+
+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),
+});
+
+const deleteThreadsSchema = z.object({
+    deleteSessionFiles: z.boolean().default(false),
+    threadIds: z.array(z.string().min(1)).min(1),
+});
+
+const analyticsSchema = z.object({
+    project: z.string().min(1).nullable(),
+});
+
+const exportSchema = z.object({
+    convertToProjectRoot: z.boolean(),
+    includeCommentary: z.boolean(),
+    includeMetadata: z.boolean(),
+    includeTools: z.boolean(),
+    outputFormat: z.enum(['md', 'txt']),
+    redactUsername: z.boolean(),
+    threadId: z.string().min(1),
+    zipArchive: z.boolean().default(false),
+});
+
+const exportThreadsSchema = z.object({
+    convertToProjectRoot: z.boolean(),
+    includeCommentary: z.boolean(),
+    includeMetadata: z.boolean(),
+    includeTools: z.boolean(),
+    outputFormat: z.enum(['md', 'txt']),
+    redactUsername: z.boolean(),
+    threadIds: z.array(z.string().min(1)).min(1),
+    zipArchive: z.boolean().default(true),
+});
+
+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 () => {
+    const { getCodexDashboardSummary } = await import('@spiracha/lib/codex-browser-db');
+    return getCodexDashboardSummary(await getDbPath());
+});
+
+export const listProjectsFn = createServerFn({ method: 'GET' }).handler(async () => {
+    const { listCodexProjects } = await import('@spiracha/lib/codex-browser-db');
+    return listCodexProjects(await getDbPath());
+});
+
+export const listProjectThreadsFn = createServerFn({ method: 'GET' })
+    .validator(projectSchema)
+    .handler(async ({ data }) => {
+        const { listProjectThreads } = await import('@spiracha/lib/codex-browser-db');
+        return listProjectThreads(await getDbPath(), data.project, {
+            includeTranscriptStats: false,
+        });
+    });
+
+export const getThreadSnapshotFn = createServerFn({ method: 'GET' })
+    .validator(threadSnapshotSchema)
+    .handler(async ({ data }) => {
+        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 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,
+            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 }) => {
+        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: await getDbPath(),
+            project: data.project,
+        });
+    });
+
+export const exportThreadFn = createServerFn({ method: 'POST' })
+    .validator(exportSchema)
+    .handler(async ({ data }) => {
+        const { renderCodexThreadDownload } = await import('@spiracha/lib/codex-browser-export');
+        return renderCodexThreadDownload({
+            dbPath: await getDbPath(),
+            includeCommentary: data.includeCommentary,
+            includeMetadata: data.includeMetadata,
+            includeTools: data.includeTools,
+            outputFormat: data.outputFormat,
+            pathDisplaySettings: {
+                convertToProjectRoot: data.convertToProjectRoot,
+                redactUsername: data.redactUsername,
+            },
+            threadId: data.threadId,
+            zipArchive: data.zipArchive,
+        });
+    });
+
+export const exportThreadsFn = createServerFn({ method: 'POST' })
+    .validator(exportThreadsSchema)
+    .handler(async ({ data }) => {
+        const { renderCodexThreadsDownload } = await import('@spiracha/lib/codex-browser-export');
+        return renderCodexThreadsDownload({
+            dbPath: await getDbPath(),
+            includeCommentary: data.includeCommentary,
+            includeMetadata: data.includeMetadata,
+            includeTools: data.includeTools,
+            outputFormat: data.outputFormat,
+            pathDisplaySettings: {
+                convertToProjectRoot: data.convertToProjectRoot,
+                redactUsername: data.redactUsername,
+            },
+            threadIds: data.threadIds,
+            zipArchive: data.zipArchive,
+        });
+    });
+
+export const deleteThreadFn = createServerFn({ method: 'POST' })
+    .validator(deleteThreadSchema)
+    .handler(async ({ data }) => {
+        const { deleteCodexThread } = await import('@spiracha/lib/codex-browser-db');
+        return deleteCodexThread(await getDbPath(), data.threadId, {
+            deleteSessionFiles: data.deleteSessionFiles,
+        });
+    });
+
+export const deleteThreadsFn = createServerFn({ method: 'POST' })
+    .validator(deleteThreadsSchema)
+    .handler(async ({ data }) => {
+        const { deleteCodexThreads } = await import('@spiracha/lib/codex-browser-db');
+        return deleteCodexThreads(await getDbPath(), data.threadIds, {
+            deleteSessionFiles: data.deleteSessionFiles,
+        });
+    });
+
+export const deleteProjectFn = createServerFn({ method: 'POST' })
+    .validator(deleteProjectSchema)
+    .handler(async ({ data }) => {
+        const { deleteCodexProject } = await import('@spiracha/lib/codex-browser-db');
+        return deleteCodexProject(await getDbPath(), data.project, {
+            deleteSessionFiles: data.deleteSessionFiles,
+        });
+    });
+
+export const recoverProjectThreadsFn = createServerFn({ method: 'POST' })
+    .validator(projectSchema)
+    .handler(async ({ data }) => {
+        const { recoverCodexProjectThreads } = await import('@spiracha/lib/codex-thread-recovery');
+        return recoverCodexProjectThreads(await getDbPath(), data.project);
+    });

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

@@ -0,0 +1,37 @@
+import { isRetryableSqliteError } from '@spiracha/lib/sqlite-error';
+import { queryOptions } from '@tanstack/react-query';
+import { getCursorThreadDetailFn, listCursorThreadsFn, listCursorWorkspacesFn } from './cursor-server';
+
+const retrySqliteQuery = (failureCount: number, error: unknown) => {
+    return failureCount < 3 && isRetryableSqliteError(error);
+};
+
+const retryDelay = (attemptIndex: number) => {
+    return [150, 400][attemptIndex] ?? 800;
+};
+
+export const cursorWorkspacesQueryOptions = () =>
+    queryOptions({
+        queryFn: () => listCursorWorkspacesFn(),
+        queryKey: ['cursor-workspaces'],
+        retry: retrySqliteQuery,
+        retryDelay,
+    });
+
+export const cursorThreadsQueryOptions = (workspaceKey: string | null) =>
+    queryOptions({
+        enabled: workspaceKey !== null,
+        queryFn: () => listCursorThreadsFn({ data: { workspaceKey: workspaceKey ?? '' } }),
+        queryKey: ['cursor-threads', workspaceKey ?? 'none'],
+        retry: retrySqliteQuery,
+        retryDelay,
+    });
+
+export const cursorThreadDetailQueryOptions = (composerId: string | null) =>
+    queryOptions({
+        enabled: composerId !== null,
+        queryFn: () => getCursorThreadDetailFn({ data: { composerId: composerId ?? '' } }),
+        queryKey: ['cursor-thread', composerId ?? 'none'],
+        retry: retrySqliteQuery,
+        retryDelay,
+    });

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

@@ -0,0 +1,315 @@
+import { randomUUID } from 'node:crypto';
+import { mkdtemp, rm } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import {
+    buildBatchExportBaseName,
+    buildConversationExportBaseName,
+    getExportMimeType,
+    resolveUniqueExportFileBaseName,
+    sanitizeExportFileName,
+    zipExportDirectory,
+} from '@spiracha/lib/ui-export-archive';
+import { buildUiExportDownloadUrl, ensureUiExportDir } from '@spiracha/lib/ui-export-files';
+import { createServerFn } from '@tanstack/react-start';
+import { z } from 'zod';
+
+const workspaceSchema = z.object({
+    workspaceKey: z.string().min(1),
+});
+
+const threadSchema = z.object({
+    composerId: z.string().min(1),
+});
+
+const recoverSchema = z.object({
+    apply: z.boolean().default(false),
+    workspaceKey: z.string().min(1),
+});
+
+const exportSchema = z.object({
+    composerId: z.string().min(1),
+    includeCommentary: z.boolean().default(true),
+    includeMetadata: z.boolean().default(true),
+    includeTools: z.boolean().default(true),
+    outputFormat: z.enum(['md', 'txt']).default('md'),
+    zipArchive: z.boolean().default(false),
+});
+
+const exportThreadsSchema = z.object({
+    composerIds: z.array(z.string().min(1)).min(1),
+    includeCommentary: z.boolean().default(true),
+    includeMetadata: z.boolean().default(true),
+    includeTools: z.boolean().default(true),
+    outputFormat: z.enum(['md', 'txt']).default('md'),
+    zipArchive: z.boolean().default(true),
+});
+
+const deleteThreadsSchema = z.object({
+    composerIds: z.array(z.string().min(1)).min(1),
+});
+
+const ensureCursorClosedForWrite = async () => {
+    const { isCursorRunning } = await import('@spiracha/lib/cursor-recovery');
+    if (await isCursorRunning()) {
+        throw new Error(
+            'Quit Cursor before deleting. It rewrites chat history on exit, which can resurrect deleted threads.',
+        );
+    }
+};
+
+const findGroupByKey = async (workspaceKey: string) => {
+    const { listCursorWorkspaceGroups } = await import('@spiracha/lib/cursor-db');
+    const groups = await listCursorWorkspaceGroups();
+    const group = groups.find((candidate) => candidate.key === workspaceKey);
+    if (!group) {
+        throw new Error(`Cursor workspace not found: ${workspaceKey}`);
+    }
+
+    return group;
+};
+
+const toSafeExportName = (value: string) => {
+    return sanitizeExportFileName(value) || 'cursor-thread';
+};
+
+const renderCursorZipDownload = async (
+    rendered: Array<{ composerId: string; content: string; cwd: string | null; updatedAtMs: number | null }>,
+    outputFormat: 'md' | 'txt',
+) => {
+    const exportDir = await ensureUiExportDir();
+    const exportBaseName =
+        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>();
+
+    try {
+        for (const entry of rendered) {
+            const baseName = toSafeExportName(entry.composerId);
+            const fileBaseName = resolveUniqueExportFileBaseName(baseName, usedBaseNames);
+            await Bun.write(path.join(workspaceDir, `${fileBaseName}.${outputFormat}`), entry.content);
+        }
+
+        await zipExportDirectory(workspaceDir, zipPath);
+    } finally {
+        await rm(workspaceDir, { force: true, recursive: true });
+    }
+
+    return {
+        downloadUrl: buildUiExportDownloadUrl(zipPath),
+        fileName: `${exportBaseName}.zip`,
+        mimeType: 'application/zip',
+        mode: 'download_url' as const,
+    };
+};
+
+export const findCursorThreadByComposerId = async (composerId: string) => {
+    const { listCursorThreadsForGroup, listCursorWorkspaceGroups } = await import('@spiracha/lib/cursor-db');
+    for (const group of await listCursorWorkspaceGroups()) {
+        const threads = await listCursorThreadsForGroup(group, undefined, { includeTranscriptDirs: false });
+        const thread = threads.find((candidate) => candidate.composerId === composerId);
+        if (thread) {
+            return thread;
+        }
+    }
+
+    return null;
+};
+
+const renderCursorDownload = async (input: {
+    composerIds: string[];
+    includeCommentary: boolean;
+    includeMetadata: boolean;
+    includeTools: boolean;
+    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 runWithTranscriptLoadLimit(
+                () => readCursorThreadTranscriptWithAgentFiles(globalDbPath, composerId),
+                {
+                    id: composerId,
+                    path: globalDbPath,
+                    source: 'cursor-ui-export',
+                },
+            );
+            if (!transcript) {
+                throw new Error(`No transcript found for thread: ${composerId}`);
+            }
+
+            const content = renderCursorTranscript(transcript, {
+                includeCommentary: input.includeCommentary,
+                includeMetadata: input.includeMetadata,
+                includeTools: input.includeTools,
+                outputFormat: input.outputFormat,
+            });
+
+            if (!content) {
+                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,
+            };
+        }),
+    );
+
+    if (input.zipArchive || rendered.length > 1) {
+        return renderCursorZipDownload(rendered, input.outputFormat);
+    }
+
+    if (rendered.length === 1) {
+        return {
+            content: rendered[0]!.content,
+            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,
+        };
+    }
+
+    throw new Error('No Cursor threads selected for export');
+};
+
+export const listCursorWorkspacesFn = createServerFn({ method: 'GET' }).handler(async () => {
+    const { listCursorWorkspaceGroups } = await import('@spiracha/lib/cursor-db');
+    return listCursorWorkspaceGroups();
+});
+
+export const listCursorThreadsFn = createServerFn({ method: 'GET' })
+    .validator(workspaceSchema)
+    .handler(async ({ data }) => {
+        const { listCursorThreadsForGroup } = await import('@spiracha/lib/cursor-db');
+        const group = await findGroupByKey(data.workspaceKey);
+        return listCursorThreadsForGroup(group, undefined, { includeTranscriptDirs: false });
+    });
+
+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);
+        if (!thread) {
+            throw new Error(`Cursor thread not found: ${data.composerId}`);
+        }
+
+        const transcript = await runWithTranscriptLoadLimit(
+            () => readCursorThreadTranscriptWithAgentFiles(getCursorGlobalDbPath(), data.composerId),
+            {
+                id: data.composerId,
+                path: getCursorGlobalDbPath(),
+                source: 'cursor-ui-detail',
+            },
+        );
+        return {
+            thread,
+            transcript,
+        };
+    });
+
+export const exportCursorThreadFn = createServerFn({ method: 'POST' })
+    .validator(exportSchema)
+    .handler(async ({ data }) => {
+        return await renderCursorDownload({
+            composerIds: [data.composerId],
+            includeCommentary: data.includeCommentary,
+            includeMetadata: data.includeMetadata,
+            includeTools: data.includeTools,
+            outputFormat: data.outputFormat,
+            zipArchive: data.zipArchive,
+        });
+    });
+
+export const exportCursorThreadsFn = createServerFn({ method: 'POST' })
+    .validator(exportThreadsSchema)
+    .handler(async ({ data }) => {
+        return await renderCursorDownload({
+            composerIds: data.composerIds,
+            includeCommentary: data.includeCommentary,
+            includeMetadata: data.includeMetadata,
+            includeTools: data.includeTools,
+            outputFormat: data.outputFormat,
+            zipArchive: data.zipArchive,
+        });
+    });
+
+export const recoverCursorWorkspaceFn = createServerFn({ method: 'POST' })
+    .validator(recoverSchema)
+    .handler(async ({ data }) => {
+        const { isCursorRunning, recoverCursorWorkspaceGroup } = await import('@spiracha/lib/cursor-recovery');
+        const group = await findGroupByKey(data.workspaceKey);
+        // Cursor rewrites composer.composerHeaders on exit, so a write while it is running gets
+        // clobbered. Refuse to apply until Cursor is closed.
+        if (data.apply && (await isCursorRunning())) {
+            throw new Error('Quit Cursor before recovering. It overwrites chat history on exit, undoing the recovery.');
+        }
+
+        return recoverCursorWorkspaceGroup(group, data.apply);
+    });
+
+export const deleteCursorThreadsFn = createServerFn({ method: 'POST' })
+    .validator(deleteThreadsSchema)
+    .handler(async ({ data }) => {
+        const { collectCursorThreadsForDeletion, pruneCursorThreads } = await import('@spiracha/lib/cursor-recovery');
+        await ensureCursorClosedForWrite();
+        const threads = await collectCursorThreadsForDeletion(data.composerIds);
+        return pruneCursorThreads(threads, true);
+    });
+
+export const deleteCursorWorkspaceFn = createServerFn({ method: 'POST' })
+    .validator(workspaceSchema)
+    .handler(async ({ data }) => {
+        const { listCursorThreadsForGroup } = await import('@spiracha/lib/cursor-db');
+        const { collectCursorThreadsForDeletion, pruneCursorThreads } = await import('@spiracha/lib/cursor-recovery');
+        await ensureCursorClosedForWrite();
+        const group = await findGroupByKey(data.workspaceKey);
+        const threads = await listCursorThreadsForGroup(group, undefined, { includeTranscriptDirs: false });
+        const composerIds = threads.map((thread) => thread.composerId);
+        if (composerIds.length === 0) {
+            return {
+                bubblesDeleted: 0,
+                composerDataDeleted: 0,
+                composerIds: [],
+                headersRemoved: 0,
+                transcriptDirsRemoved: 0,
+                workspaceBucketsUpdated: 0,
+            };
+        }
+
+        const deletable = await collectCursorThreadsForDeletion(composerIds);
+        return pruneCursorThreads(deletable, true);
+    });