spiracha 2.1.0 → 2.2.0

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

@@ -6,14 +6,9 @@ import type { CodexTranscriptRenderOptions } from './codex-thread-types';
 import { renderCodexSessionFile, writeCodexSessionFileExport } from './codex-transcript-renderer';
 import { applyPathTransforms, type PathDisplaySettings } from './path-transforms';
 import type { ExportFormat } from './shared';
-import {
-    buildBatchExportBaseName,
-    buildConversationExportBaseName,
-    getExportMimeType,
-    zipExportDirectory,
-    zipExportFile,
-} from './ui-export-archive';
+import { buildBatchExportBaseName, buildConversationExportBaseName, getExportMimeType } from './ui-export-archive';
 import { buildUiExportDownloadUrl, ensureUiExportDir } from './ui-export-files';
+import { zipExportDirectory, zipExportFile } from './ui-export-zip';
 
 type RenderCodexThreadDownloadInput = {
     dbPath: string;

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

@@ -14,6 +14,17 @@ export type DynamicToolRow = DynamicToolDefinition & {
     threadId: string;
 };
 
+export type ThreadGoal = {
+    createdAtMs: number;
+    goalId: string;
+    objective: string;
+    status: string;
+    timeUsedSeconds: number;
+    tokenBudget: number | null;
+    tokensUsed: number;
+    updatedAtMs: number;
+};
+
 export type SessionMetaExtended = SessionMeta & {
     baseInstructions: JsonValue | null;
     dynamicTools: DynamicToolDefinition[];
@@ -165,14 +176,20 @@ export type ThreadListEntry = {
 
 export type ThreadBrowseData = {
     dynamicTools: DynamicToolRow[];
+    goals: ThreadGoal[];
     project: string;
     relations: ThreadRelations;
     thread: ThreadRow;
 };
 
+export type DashboardThreadSummary = Pick<
+    ThreadRow,
+    'cwd' | 'id' | 'model' | 'preview' | 'title' | 'tokens_used' | 'updated_at' | 'updated_at_ms'
+>;
+
 export type DashboardRecentThread = {
     project: string;
-    thread: ThreadRow;
+    thread: DashboardThreadSummary;
 };
 
 export type DashboardSummary = {
@@ -232,6 +249,7 @@ export type CodexAnalyticsSummary = {
     archivedThreads: number;
     averageTokensPerThread: number;
     distinctToolNames: number;
+    medianTokensPerThread: number;
     threadsWithWebSearch: number;
     totalProjects: number;
     totalThreads: number;
@@ -240,6 +258,8 @@ export type CodexAnalyticsSummary = {
 
 export type CodexAnalytics = {
     modelsByTokens: ModelTokenSummary[];
+    reasoningEfforts: DistributionItem[];
+    sources: DistributionItem[];
     summary: CodexAnalyticsSummary;
     toolUsage: ToolUsageSummary[];
 };

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

@@ -1,30 +1,80 @@
 import { stat } from 'node:fs/promises';
 import path from 'node:path';
-import type { ParsedCodexTranscript } from './codex-browser-types';
+import type { ParsedCodexTranscript, ThreadTranscriptStats } from './codex-browser-types';
 import { parseCodexTranscriptFile } from './codex-thread-parser';
 import type { CodexTranscriptEventFilters } from './codex-transcript-filter';
 import { shouldShowCodexTranscriptEvent } from './codex-transcript-filter';
 import { runWithTranscriptLoadLimit } from './transcript-load-limiter';
-import { getFileFingerprint, hashCacheKeyParts, withCachedJson } from './ui-cache';
+import { getFileFingerprint, hashCacheKeyPartsIterable, withCachedJson } from './ui-cache';
 
 // Keep initial thread payloads below sizes that make TanStack Start SSR responses unreliable.
 export const LARGE_THREAD_SIZE_BYTES = 8 * 1024 * 1024;
 export const LARGE_THREAD_PREVIEW_EVENT_LIMIT = 200;
-const CODEX_TRANSCRIPT_CACHE_VERSION = 'v2';
+const CODEX_TRANSCRIPT_CACHE_VERSION = 'v3';
+const CODEX_TRANSCRIPT_STATS_CACHE_VERSION = 'v1';
+const FILE_STABILITY_ATTEMPTS = 3;
+
+type CodexTranscriptStatsLoader = (sessionFile: string) => Promise<ThreadTranscriptStats>;
 
 const isMissingFileError = (error: unknown) => {
     return error instanceof Error && 'code' in error && error.code === 'ENOENT';
 };
 
+const withStableFileCache = async <T>(
+    sessionFile: string,
+    keyForFingerprint: (fingerprint: string) => string,
+    loader: () => Promise<T>,
+): Promise<T> => {
+    for (let attempt = 0; attempt < FILE_STABILITY_ATTEMPTS; attempt += 1) {
+        const fingerprint = await getFileFingerprint(sessionFile);
+        const value = await withCachedJson(keyForFingerprint(fingerprint), loader);
+        if ((await getFileFingerprint(sessionFile)) === fingerprint) {
+            return value;
+        }
+    }
+
+    throw new Error(`Codex rollout changed repeatedly while loading: ${sessionFile}`);
+};
+
 export const getCachedParsedCodexTranscript = async (sessionFile: string): Promise<ParsedCodexTranscript> => {
-    const fingerprint = await getFileFingerprint(sessionFile);
-    const key = `thread-${hashCacheKeyParts(CODEX_TRANSCRIPT_CACHE_VERSION, path.basename(sessionFile), fingerprint)}`;
+    return withStableFileCache(
+        sessionFile,
+        (fingerprint) =>
+            `thread-${hashCacheKeyPartsIterable([CODEX_TRANSCRIPT_CACHE_VERSION, path.basename(sessionFile), fingerprint])}`,
+        async () =>
+            runWithTranscriptLoadLimit(() => parseCodexTranscriptFile(sessionFile), {
+                path: sessionFile,
+                source: 'codex-full',
+            }),
+    );
+};
+
+const loadCodexTranscriptStats: CodexTranscriptStatsLoader = async (sessionFile) => {
+    const transcript = await parseCodexTranscriptFile(sessionFile, {
+        includeRaw: false,
+        maxTurnContexts: 0,
+    });
+
+    return transcript.stats;
+};
 
-    return withCachedJson(key, async () =>
-        runWithTranscriptLoadLimit(() => parseCodexTranscriptFile(sessionFile), {
-            path: sessionFile,
-            source: 'codex-full',
-        }),
+export const getCachedCodexTranscriptStats = async (
+    sessionFile: string,
+    loadStats: CodexTranscriptStatsLoader = loadCodexTranscriptStats,
+): Promise<ThreadTranscriptStats> => {
+    return withStableFileCache(
+        sessionFile,
+        (fingerprint) =>
+            `thread-list-stats-${hashCacheKeyPartsIterable([
+                CODEX_TRANSCRIPT_STATS_CACHE_VERSION,
+                path.basename(sessionFile),
+                fingerprint,
+            ])}`,
+        () =>
+            runWithTranscriptLoadLimit(() => loadStats(sessionFile), {
+                path: sessionFile,
+                source: 'codex-list-stats',
+            }),
     );
 };
 
@@ -65,38 +115,43 @@ export const getCachedThreadTranscriptPreview = async (
     const threshold = options.largeTranscriptThresholdBytes ?? LARGE_THREAD_SIZE_BYTES;
     const previewEventLimit = options.previewEventLimit ?? LARGE_THREAD_PREVIEW_EVENT_LIMIT;
     const filters = options.filters;
-    const fingerprint = await getFileFingerprint(sessionFile);
-    const { fileSizeBytes, shouldDeferTranscriptLoad } = await getThreadRolloutLoadState(sessionFile, threshold);
     const filterKey = filters ? JSON.stringify(filters) : 'all';
-    const key = `thread-preview-${hashCacheKeyParts(CODEX_TRANSCRIPT_CACHE_VERSION, path.basename(sessionFile), fingerprint, String(threshold), String(previewEventLimit), filterKey)}`;
+    return withStableFileCache(
+        sessionFile,
+        (fingerprint) =>
+            `thread-preview-${hashCacheKeyPartsIterable([CODEX_TRANSCRIPT_CACHE_VERSION, path.basename(sessionFile), fingerprint, String(threshold), String(previewEventLimit), filterKey])}`,
+        async () => {
+            const { fileSizeBytes, shouldDeferTranscriptLoad } = await getThreadRolloutLoadState(
+                sessionFile,
+                threshold,
+            );
+            if (!shouldDeferTranscriptLoad) {
+                return runWithTranscriptLoadLimit(
+                    () =>
+                        parseCodexTranscriptFile(sessionFile, {
+                            sourceFileSizeBytes: fileSizeBytes,
+                        }),
+                    {
+                        path: sessionFile,
+                        source: 'codex-preview-full',
+                    },
+                );
+            }
 
-    return withCachedJson(key, async () => {
-        if (!shouldDeferTranscriptLoad) {
             return runWithTranscriptLoadLimit(
                 () =>
                     parseCodexTranscriptFile(sessionFile, {
+                        eventFilter: filters ? (event) => shouldShowCodexTranscriptEvent(event, filters) : undefined,
+                        includeRaw: false,
+                        maxTurnContexts: 0,
                         sourceFileSizeBytes: fileSizeBytes,
+                        tailEventLimit: previewEventLimit,
                     }),
                 {
                     path: sessionFile,
-                    source: 'codex-preview-full',
+                    source: 'codex-preview',
                 },
             );
-        }
-
-        return runWithTranscriptLoadLimit(
-            () =>
-                parseCodexTranscriptFile(sessionFile, {
-                    eventFilter: filters ? (event) => shouldShowCodexTranscriptEvent(event, filters) : undefined,
-                    includeRaw: false,
-                    maxTurnContexts: 0,
-                    sourceFileSizeBytes: fileSizeBytes,
-                    tailEventLimit: previewEventLimit,
-                }),
-            {
-                path: sessionFile,
-                source: 'codex-preview',
-            },
-        );
-    });
+        },
+    );
 };

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

@@ -33,7 +33,9 @@ type ParseCodexTranscriptState = {
     maxTurnContexts: number;
     sequence: number;
     shouldStop: boolean;
+    tailEventCursor: number;
     tailEventLimit: number;
+    tailEventsWrapped: boolean;
     turnContexts: TurnContextRecord[];
 };
 
@@ -88,7 +90,9 @@ export const parseCodexTranscriptFile = async (
         maxTurnContexts,
         sequence: 0,
         shouldStop: false,
+        tailEventCursor: 0,
         tailEventLimit,
+        tailEventsWrapped: false,
         turnContexts,
     };
 
@@ -100,6 +104,15 @@ export const parseCodexTranscriptFile = async (
         }
     }
 
+    if (state.tailEventsWrapped && events.length > 0) {
+        events.splice(
+            0,
+            events.length,
+            ...events.slice(state.tailEventCursor),
+            ...events.slice(0, state.tailEventCursor),
+        );
+    }
+
     for (const event of events) {
         updateTranscriptStats(stats, event);
     }
@@ -129,7 +142,7 @@ const captureTranscriptRecord = (parsed: Record<string, JsonValue>, state: Parse
         return;
     }
 
-    const event = toThreadEvent(parsed, state.sequence, state.includeRaw);
+    const event = parseCodexTranscriptRecord(parsed, state.sequence, state.includeRaw);
     if (!event) {
         return;
     }
@@ -139,9 +152,12 @@ const captureTranscriptRecord = (parsed: Record<string, JsonValue>, state: Parse
         return;
     }
 
-    state.events.push(event);
-    if (state.events.length > state.tailEventLimit) {
-        state.events.shift();
+    if (!Number.isFinite(state.tailEventLimit) || state.events.length < state.tailEventLimit) {
+        state.events.push(event);
+    } else if (state.tailEventLimit > 0) {
+        state.events[state.tailEventCursor] = event;
+        state.tailEventCursor = (state.tailEventCursor + 1) % state.tailEventLimit;
+        state.tailEventsWrapped = true;
     }
     state.shouldStop = state.events.length >= state.maxEvents;
 };
@@ -204,10 +220,10 @@ const captureTurnContext = (parsed: Record<string, JsonValue>, turnContexts: Tur
     });
 };
 
-const toThreadEvent = (
+export const parseCodexTranscriptRecord = (
     parsed: Record<string, JsonValue>,
-    sequence: number,
-    includeRaw: boolean,
+    sequence = 0,
+    includeRaw = false,
 ): ThreadEvent | null => {
     const payload = asObject(parsed.payload);
     if (!payload) {
@@ -235,15 +251,7 @@ const buildEventMessage = (
     sequence: number,
     timestamp: string | null,
 ) => {
-    if (payloadType === 'task_started') {
-        return createTaskStartedEvent(payload, raw, sequence, timestamp);
-    }
-
-    if (payloadType === 'task_complete') {
-        return createTaskCompleteEvent(payload, raw, sequence, timestamp);
-    }
-
-    return null;
+    return buildSupplementalEvent(payload, payloadType, raw, sequence, timestamp);
 };
 
 const buildResponseItemEvent = (
@@ -265,11 +273,11 @@ const buildResponseItemEvent = (
         return createAgentMessageEvent(payload, raw, sequence, timestamp);
     }
 
-    if (payloadType === 'function_call') {
-        return createToolCallEvent(payload, raw, sequence, timestamp);
+    if (payloadType === 'function_call' || payloadType === 'custom_tool_call') {
+        return createToolCallEvent(payload, raw, sequence, timestamp, payloadType === 'custom_tool_call');
     }
 
-    if (payloadType === 'function_call_output') {
+    if (payloadType === 'function_call_output' || payloadType === 'custom_tool_call_output') {
         return createToolOutputEvent(payload, raw, sequence, timestamp);
     }
 
@@ -277,6 +285,16 @@ const buildResponseItemEvent = (
         return createReasoningEvent(payload, raw, sequence, timestamp);
     }
 
+    return buildSupplementalEvent(payload, payloadType, raw, sequence, timestamp);
+};
+
+const buildSupplementalEvent = (
+    payload: Record<string, JsonValue>,
+    payloadType: string | null,
+    raw: Record<string, JsonValue>,
+    sequence: number,
+    timestamp: string | null,
+) => {
     if (payloadType === 'token_count') {
         return createTokenCountEvent(payload, raw, sequence, timestamp);
     }
@@ -305,12 +323,12 @@ const createMessageEvent = (
     const role = asString(payload.role);
     const content = payload.content;
     const text = extractText(content);
-    if (!role || content === undefined) {
+    if (!role || content === undefined || !text.trim()) {
         return null;
     }
 
     return {
-        isHiddenByDefault: shouldHideTranscriptText(role, text),
+        isHiddenByDefault: shouldHideCodexTranscriptText(role, text),
         kind: 'message',
         memoryCitation: null,
         model: asString(payload.model),
@@ -330,9 +348,9 @@ const createUserMessageEvent = (
     sequence: number,
     timestamp: string | null,
 ): MessageEvent => {
-    const text = stripMemoryCitationBlocks(asString(payload.message) ?? '');
+    const text = stripCodexMemoryCitationBlocks(asString(payload.message) ?? '');
     return {
-        isHiddenByDefault: shouldHideTranscriptText('user', text),
+        isHiddenByDefault: shouldHideCodexTranscriptText('user', text),
         kind: 'message',
         memoryCitation: null,
         model: null,
@@ -352,9 +370,9 @@ const createAgentMessageEvent = (
     sequence: number,
     timestamp: string | null,
 ): MessageEvent => {
-    const text = stripMemoryCitationBlocks(asString(payload.message) ?? '');
+    const text = stripCodexMemoryCitationBlocks(asString(payload.message) ?? '');
     return {
-        isHiddenByDefault: shouldHideTranscriptText('assistant', text),
+        isHiddenByDefault: shouldHideCodexTranscriptText('assistant', text),
         kind: 'message',
         memoryCitation: payload.memory_citation ?? null,
         model: asString(payload.model),
@@ -373,10 +391,13 @@ const createToolCallEvent = (
     raw: Record<string, JsonValue>,
     sequence: number,
     timestamp: string | null,
+    isCustomToolCall: boolean,
 ): ToolCallEvent => {
     const name = asString(payload.name) ?? 'unknown';
-    const argumentsText = asString(payload.arguments);
-    const parsedArguments = parseExecCommandArguments(argumentsText);
+    const argumentsText = asString(isCustomToolCall ? payload.input : payload.arguments);
+    const parsedArguments = isCustomToolCall
+        ? { argumentsParseFailed: false, cmd: argumentsText, workdir: null }
+        : parseExecCommandArguments(argumentsText);
 
     return {
         argumentsParseFailed: parsedArguments.argumentsParseFailed,
@@ -398,7 +419,7 @@ const createToolOutputEvent = (
     sequence: number,
     timestamp: string | null,
 ): ToolOutputEvent => {
-    const outputText = asString(payload.output) ?? '';
+    const outputText = extractToolOutputText(payload.output);
 
     return {
         callId: asString(payload.call_id),
@@ -524,7 +545,7 @@ const updateTranscriptStats = (stats: ThreadTranscriptStats, event: ThreadEvent)
 
     if (event.kind === 'tool_call') {
         stats.toolCallCount += 1;
-        if (event.name === 'exec_command') {
+        if (event.name === 'exec' || event.name === 'exec_command') {
             stats.execCommandCount += 1;
         }
         return;
@@ -592,13 +613,31 @@ const parseExecCommandArguments = (argumentsText: string | null) => {
     }
 };
 
+const extractToolOutputText = (output: JsonValue | undefined): string => {
+    if (typeof output === 'string') {
+        return output;
+    }
+
+    if (!Array.isArray(output)) {
+        return '';
+    }
+
+    return output
+        .map((entry) => {
+            const contentBlock = asObject(entry);
+            return contentBlock ? asString(contentBlock.text) : null;
+        })
+        .filter((entry): entry is string => entry !== null)
+        .join('\n');
+};
+
 const extractText = (content: JsonValue): string => {
     if (typeof content === 'string') {
-        return stripMemoryCitationBlocks(content);
+        return stripCodexMemoryCitationBlocks(content);
     }
 
     if (Array.isArray(content)) {
-        return stripMemoryCitationBlocks(
+        return stripCodexMemoryCitationBlocks(
             content
                 .map((entry) => extractTextPart(entry))
                 .filter(Boolean)
@@ -607,14 +646,17 @@ const extractText = (content: JsonValue): string => {
     }
 
     if (content && typeof content === 'object') {
-        return stripMemoryCitationBlocks(asString((content as Record<string, JsonValue>).text) ?? '');
+        return stripCodexMemoryCitationBlocks(asString((content as Record<string, JsonValue>).text) ?? '');
     }
 
     return '';
 };
 
-const stripMemoryCitationBlocks = (text: string): string => {
-    return stripCodexAppDirectiveLines(text.replace(/<oai-mem-citation>[\s\S]*?<\/oai-mem-citation>/gu, ''));
+export const stripCodexMemoryCitationBlocks = (text: string): string => {
+    const withoutMemoryCitations = text.includes('<oai-mem-citation>')
+        ? text.replace(/<oai-mem-citation>[\s\S]*?<\/oai-mem-citation>/gu, '')
+        : text;
+    return stripCodexAppDirectiveLines(withoutMemoryCitations);
 };
 
 const extractTextPart = (entry: JsonValue): string => {
@@ -633,7 +675,7 @@ const extractTextPart = (entry: JsonValue): string => {
     return text ?? '';
 };
 
-const shouldHideTranscriptText = (role: string, text: string) => {
+export const shouldHideCodexTranscriptText = (role: string, text: string) => {
     if (!text) {
         return true;
     }
@@ -644,6 +686,7 @@ const shouldHideTranscriptText = (role: string, text: string) => {
 
     return (
         text.startsWith('# AGENTS.md instructions for ') ||
+        text.startsWith('AGENTS.md instructions for ') ||
         text.startsWith('<permissions instructions>') ||
         text.startsWith('<app-context>') ||
         text.startsWith('<environment_context>') ||

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

@@ -1,8 +1,8 @@
 import { Database } from 'bun:sqlite';
-import { copyFile, utimes } from 'node:fs/promises';
+import { copyFile, readdir, rm, utimes } from 'node:fs/promises';
 import path from 'node:path';
 import type { RecoverProjectThreadsResult } from './codex-browser-types';
-import { getPortablePathBasename } from './shared';
+import { getPortablePathBasename } from './portable-path';
 import { runWithSqliteRetry } from './sqlite-retry';
 
 type RecoveryThreadRow = {
@@ -18,6 +18,8 @@ type GlobalState = {
     'project-order'?: string[];
 };
 
+const RECOVERY_BACKUP_RETENTION_COUNT = 5;
+
 const backupFile = async (filePath: string, label: string) => {
     const stamp = new Date()
         .toISOString()
@@ -26,6 +28,14 @@ const backupFile = async (filePath: string, label: string) => {
         .replace('T', '-');
     const backupPath = `${filePath}.bak-${label}-${stamp}`;
     await copyFile(filePath, backupPath);
+    const directory = path.dirname(filePath);
+    const prefix = `${path.basename(filePath)}.bak-${label}-`;
+    const backups = (await readdir(directory))
+        .filter((entry) => entry.startsWith(prefix))
+        .sort((left, right) => right.localeCompare(left));
+    await Promise.all(
+        backups.slice(RECOVERY_BACKUP_RETENTION_COUNT).map((entry) => rm(path.join(directory, entry), { force: true })),
+    );
     return backupPath;
 };
 
@@ -100,9 +110,9 @@ const refreshThreadRows = (db: Database, threadIds: string[]) => {
     return Number(result.changes);
 };
 
-const refreshSessionIndex = async (sessionIndexPath: string, threadIds: string[]) => {
+const prepareSessionIndexRefresh = async (sessionIndexPath: string, threadIds: string[]) => {
     if (threadIds.length === 0) {
-        return 0;
+        return { content: null, updated: 0 };
     }
 
     const now = new Date().toISOString().replace(/\.\d{3}Z$/, 'Z');
@@ -116,7 +126,19 @@ const refreshSessionIndex = async (sessionIndexPath: string, threadIds: string[]
             continue;
         }
 
-        const parsed = JSON.parse(line) as { id?: string; updated_at?: string };
+        let parsed: { id?: string; updated_at?: string };
+        try {
+            const value: unknown = JSON.parse(line);
+            if (!value || typeof value !== 'object' || Array.isArray(value)) {
+                rewrittenLines.push(line);
+                continue;
+            }
+            parsed = value as { id?: string; updated_at?: string };
+        } catch {
+            rewrittenLines.push(line);
+            continue;
+        }
+
         if (parsed.id && threadIdSet.has(parsed.id)) {
             parsed.updated_at = now;
             updated += 1;
@@ -125,8 +147,10 @@ const refreshSessionIndex = async (sessionIndexPath: string, threadIds: string[]
         rewrittenLines.push(JSON.stringify(parsed));
     }
 
-    await Bun.write(sessionIndexPath, `${rewrittenLines.join('\n')}\n`);
-    return updated;
+    return {
+        content: `${rewrittenLines.join('\n')}\n`,
+        updated,
+    };
 };
 
 const touchRolloutFiles = async (codexDir: string, rolloutPaths: string[]) => {
@@ -177,12 +201,15 @@ export const recoverCodexProjectThreads = async (
         const topLevelThreads = getProjectTopLevelThreads(db, projectName);
         const projectCwds = [...new Set(topLevelThreads.map((thread) => thread.cwd))];
         const rootUpdateResult = updateGlobalRoots(globalState, projectCwds);
-        await writeGlobalState(globalStatePath, rootUpdateResult.state);
-
         const threadIds = topLevelThreads.map((thread) => thread.id);
         const rolloutPaths = topLevelThreads.map((thread) => thread.rollout_path);
+        const sessionIndexRefresh = await prepareSessionIndexRefresh(sessionIndexPath, threadIds);
+
+        await writeGlobalState(globalStatePath, rootUpdateResult.state);
         const threadDbRowsUpdated = refreshThreadRows(db, threadIds);
-        const sessionIndexRowsUpdated = await refreshSessionIndex(sessionIndexPath, threadIds);
+        if (sessionIndexRefresh.content !== null) {
+            await Bun.write(sessionIndexPath, sessionIndexRefresh.content);
+        }
         const rolloutFilesTouched = await touchRolloutFiles(codexDir, rolloutPaths);
 
         return {
@@ -192,7 +219,7 @@ export const recoverCodexProjectThreads = async (
             resolvedCwds: projectCwds,
             rolloutFilesTouched,
             savedRootsAdded: rootUpdateResult.savedRootsAdded,
-            sessionIndexRowsUpdated,
+            sessionIndexRowsUpdated: sessionIndexRefresh.updated,
             threadDbRowsUpdated,
             topLevelThreadsFound: threadIds.length,
         };