spiracha 1.1.0 → 1.1.1

package/apps/ui/dist/server/assets/{threads._threadId-D3xaWM86.js → threads._threadId-euyNckhj.js}

@@ -1,15 +1,15 @@
-import { t as applyPathTransforms$1 } from "./path-transforms-DD1e7rhY.js";
+import { t as applyPathTransforms$1 } from "./path-transforms-DL2IwtYd.js";
 import { t as cn } from "./utils-C_uf36nf.js";
 import { t as Button } from "./button-CmTDnzOn.js";
 import { n as useSettings } from "./settings-store-DpEJEQ7M.js";
 import { a as threadSnapshotQueryOptions, c as deleteThreadFn, o as threadTranscriptQueryOptions, u as exportThreadFn } from "./codex-queries-CAF6HYiG.js";
-import { t as Route } from "./threads._threadId-D3PYZIwl.js";
+import { t as Route } from "./threads._threadId-Ba7vv6-K.js";
 import { t as Checkbox$1 } from "./checkbox-C0hovF41.js";
 import { t as MetricCard } from "./metric-card-ByEeLu0r.js";
 import { t as PageHeader } from "./page-header-CxdZM86z.js";
-import { a as formatModelLabel, i as formatList, n as formatBytes, r as formatDateTime, s as formatTokens, t as formatBooleanLabel } from "./formatters-B6o5pTY9.js";
+import { a as formatModelLabel, i as formatList, n as formatBytes, r as formatDateTime, s as formatTokens, t as formatBooleanLabel } from "./formatters-FJaGZgJk.js";
 import { t as DeleteConfirmDialog } from "./delete-confirm-dialog-CWqcTXTF.js";
-import { n as downloadUrlFile, r as ExportDialog, t as downloadTextFile } from "./download-CzHmFWGk.js";
+import { n as downloadUrlFile, r as ExportDialog, t as downloadTextFile } from "./download-C5rkk_Bo.js";
 import { useEffect, useRef, useState } from "react";
 import { Link, useNavigate } from "@tanstack/react-router";
 import { Fragment, jsx, jsxs } from "react/jsx-runtime";
@@ -235,6 +235,7 @@ function TranscriptEventCard({ assistantModel, copied, event, isSelected, showRa
 					]
 				}), event.timestamp ? /* @__PURE__ */ jsx("p", {
 					className: "shrink-0 text-[var(--muted-foreground)] text-xs",
+					suppressHydrationWarning: true,
 					children: formatDateTime(event.timestamp)
 				}) : null]
 			}),
@@ -294,6 +295,12 @@ function TranscriptView({ assistantModel, events, projectPath, showCommentary, s
 			timeoutIdsRef.current = [];
 		};
 	}, []);
+	useEffect(() => {
+		setSelectedEventKeys((current) => {
+			const next = current.filter((key) => visibleEventKeySet.has(key));
+			return next.length === current.length ? current : next;
+		});
+	}, [visibleEventKeySet]);
 	const scheduleTimeout = (callback, delayMs) => {
 		const timeoutId = window.setTimeout(() => {
 			timeoutIdsRef.current = timeoutIdsRef.current.filter((entry) => entry !== timeoutId);
@@ -497,15 +504,24 @@ var buildThreadItems = (snapshot) => {
 		},
 		{
 			label: "Created",
-			value: formatDateTime(snapshot.thread.created_at_ms ?? snapshot.thread.created_at * 1e3)
+			value: /* @__PURE__ */ jsx("span", {
+				suppressHydrationWarning: true,
+				children: formatDateTime(snapshot.thread.created_at_ms ?? snapshot.thread.created_at * 1e3)
+			})
 		},
 		{
 			label: "Updated",
-			value: formatDateTime(snapshot.thread.updated_at_ms ?? snapshot.thread.updated_at * 1e3)
+			value: /* @__PURE__ */ jsx("span", {
+				suppressHydrationWarning: true,
+				children: formatDateTime(snapshot.thread.updated_at_ms ?? snapshot.thread.updated_at * 1e3)
+			})
 		},
 		{
 			label: "Session started",
-			value: formatDateTime(snapshot.transcript?.sessionMeta.timestamp ?? null)
+			value: /* @__PURE__ */ jsx("span", {
+				suppressHydrationWarning: true,
+				children: formatDateTime(snapshot.transcript?.sessionMeta.timestamp ?? null)
+			})
 		},
 		{
 			label: "Rollout size",
@@ -517,7 +533,10 @@ var buildThreadItems = (snapshot) => {
 		},
 		{
 			label: "Archived at",
-			value: formatDateTime(snapshot.thread.archived_at ? snapshot.thread.archived_at * 1e3 : null)
+			value: /* @__PURE__ */ jsx("span", {
+				suppressHydrationWarning: true,
+				children: formatDateTime(snapshot.thread.archived_at ? snapshot.thread.archived_at * 1e3 : null)
+			})
 		}
 	];
 };
@@ -934,7 +953,10 @@ function ThreadDetailPage() {
 					}),
 					/* @__PURE__ */ jsx(MetricCard, {
 						label: "Updated",
-						value: formatDateTime(snapshot.thread.updated_at_ms ?? snapshot.thread.updated_at * 1e3)
+						value: /* @__PURE__ */ jsx("span", {
+							suppressHydrationWarning: true,
+							children: formatDateTime(snapshot.thread.updated_at_ms ?? snapshot.thread.updated_at * 1e3)
+						})
 					}),
 					/* @__PURE__ */ jsx(MetricCard, {
 						label: "Thread source",

package/apps/ui/dist/server/server.js

@@ -3471,7 +3471,7 @@ var defaultSerovalPlugins = [
 * the dev styles URL for route-scoped CSS collection.
 */
 async function getStartManifest(matchedRoutes) {
-	const { tsrStartManifest } = await import("./assets/_tanstack-start-manifest_v-BjsXNYgm.js");
+	const { tsrStartManifest } = await import("./assets/_tanstack-start-manifest_v-C0V305Nt.js");
 	const startManifest = tsrStartManifest();
 	let routes = startManifest.routes;
 	routes[rootRouteId];
@@ -3498,47 +3498,47 @@ async function getStartManifest(matchedRoutes) {
 var manifest = {
 	"0814663c3bdc58135f97d210d145ef0be5ca54ef9a5f1e3030be9b1bfc901e30": {
 		functionName: "exportThreadFn_createServerFn_handler",
-		importer: () => import("./assets/codex-server-Cqh0hb93.js")
+		importer: () => import("./assets/codex-server-BFZq2Y2O.js")
 	},
 	"164ee82cdd565ed96591a64312f0f7bd961040baf066a89d9f5636330d11360b": {
 		functionName: "deleteProjectFn_createServerFn_handler",
-		importer: () => import("./assets/codex-server-Cqh0hb93.js")
+		importer: () => import("./assets/codex-server-BFZq2Y2O.js")
 	},
 	"29727b7ad5b8fe42e83817376653e064d9fe8888799f056b2e59296b3396568b": {
 		functionName: "deleteThreadFn_createServerFn_handler",
-		importer: () => import("./assets/codex-server-Cqh0hb93.js")
+		importer: () => import("./assets/codex-server-BFZq2Y2O.js")
 	},
 	"4712520da0f07bbd1f0907e5a162fe518516ff4caca3fd23876cc65539d87d7a": {
 		functionName: "getAnalyticsFn_createServerFn_handler",
-		importer: () => import("./assets/codex-server-Cqh0hb93.js")
+		importer: () => import("./assets/codex-server-BFZq2Y2O.js")
 	},
 	"59fb2cb4d60c8e7d47e0afcc914ee6f9d9f4bf076c8e66eab1693066753655b3": {
 		functionName: "listProjectThreadsFn_createServerFn_handler",
-		importer: () => import("./assets/codex-server-Cqh0hb93.js")
+		importer: () => import("./assets/codex-server-BFZq2Y2O.js")
 	},
 	"5da27045f7e28ded6353bc16aace284af7ef1b4010ef04d0186a6feadb466497": {
 		functionName: "getThreadTranscriptFn_createServerFn_handler",
-		importer: () => import("./assets/codex-server-Cqh0hb93.js")
+		importer: () => import("./assets/codex-server-BFZq2Y2O.js")
 	},
 	"72991e2b6e0adbf8d63bb8b139dad88a00b77b7030ec28ceac36c3cce7846b4c": {
 		functionName: "getThreadSnapshotFn_createServerFn_handler",
-		importer: () => import("./assets/codex-server-Cqh0hb93.js")
+		importer: () => import("./assets/codex-server-BFZq2Y2O.js")
 	},
 	"792690638a3b10035a5b7368c3d98bdc70cbfe1e36a4aa5f45b1c49b8b1025b0": {
 		functionName: "getDashboardSummaryFn_createServerFn_handler",
-		importer: () => import("./assets/codex-server-Cqh0hb93.js")
+		importer: () => import("./assets/codex-server-BFZq2Y2O.js")
 	},
 	"96aa60bf7dd9b5bde415bcf3ad6f6955a975eecd9aa0516cf401cc39bebebe6c": {
 		functionName: "deleteThreadsFn_createServerFn_handler",
-		importer: () => import("./assets/codex-server-Cqh0hb93.js")
+		importer: () => import("./assets/codex-server-BFZq2Y2O.js")
 	},
 	"b4e15c006e9a277470958bb008f89b5b0acc7256109581de44cf17d587d174a5": {
 		functionName: "exportThreadsFn_createServerFn_handler",
-		importer: () => import("./assets/codex-server-Cqh0hb93.js")
+		importer: () => import("./assets/codex-server-BFZq2Y2O.js")
 	},
 	"ccefccb816ba13508f23db4e31067b3403e750225257592d3ae11071ffc3fd6f": {
 		functionName: "listProjectsFn_createServerFn_handler",
-		importer: () => import("./assets/codex-server-Cqh0hb93.js")
+		importer: () => import("./assets/codex-server-BFZq2Y2O.js")
 	}
 };
 async function getServerFnById(id, access) {
@@ -5328,8 +5328,8 @@ var getBaseManifest = getProdBaseManifest;
 var createEarlyHintsForRequest = createEarlyHintsCollector;
 async function loadEntries() {
 	const [routerEntry, startEntry, pluginAdapters] = await Promise.all([
-		import("./assets/router-ve2Hrl2Y.js"),
-		import("./assets/start-BAvbjjfs.js"),
+		import("./assets/router-C_w-haH6.js"),
+		import("./assets/start-HeKLHD9b.js"),
 		import("./assets/__23tanstack-start-plugin-adapters-BzCA6dXo.js")
 	]);
 	return {
@@ -5666,7 +5666,7 @@ async function handleServerRoutes({ getRouter, request, url, executeRouter, cont
 	return ctx.response;
 }
 //#endregion
-//#region ../../node_modules/.bun/@tanstack+react-start@1.168.11+1cc525de2aa52ed1/node_modules/@tanstack/react-start/dist/plugin/default-entry/server.ts
+//#region ../../node_modules/.bun/@tanstack+react-start@1.168.11+5cefe02f681c7619/node_modules/@tanstack/react-start/dist/plugin/default-entry/server.ts
 var fetch$1 = createStartHandler(defaultStreamHandler);
 function createServerEntry(entry) {
 	return { async fetch(...args) {

package/package.json

@@ -21,6 +21,7 @@
         "@tanstack/react-virtual": "3.13.25",
         "class-variance-authority": "0.7.1",
         "clsx": "2.1.1",
+        "iconv-lite": "^0.7.2",
         "lucide-react": "1.16.0",
         "radix-ui": "1.4.3",
         "react": "19.2.6",
@@ -61,6 +62,7 @@
         "src/lib/ui-export-files.ts",
         "src/lib/ui-cache.ts",
         "src/lib/interactive-cli.ts",
+        "src/lib/model-label.ts",
         "src/lib/native-open.ts",
         "src/lib/shared.ts",
         "apps/ui/dist/client/assets/**/*",
@@ -91,10 +93,14 @@
     },
     "scripts": {
         "build": "bun run typecheck && bun run --cwd apps/ui build",
+        "coverage": "bun run coverage:root && bun run coverage:ui",
+        "coverage:root": "bun test --coverage --coverage-reporter=lcov --coverage-dir coverage && bun run ./src/coverage-check.ts root",
+        "coverage:ui": "bun run --cwd apps/ui coverage && bun run ./src/coverage-check.ts ui",
         "export:claude": "bun run ./src/export-claude.ts",
         "format": "biome check . --write && biome lint . --write",
         "lint": "biome check .",
         "mcp": "bun run ./src/mcp-server.ts",
+        "smoke:package-ui": "bun run ./src/package-ui-smoke.ts",
         "start": "bun run ./src/export-chats.ts",
         "typecheck": "bun run typecheck:root && bun run typecheck:ui",
         "typecheck:root": "bunx tsc --noEmit",
@@ -103,7 +109,7 @@
         "ui:preview": "bun run --cwd apps/ui preview"
     },
     "type": "module",
-    "version": "1.1.0",
+    "version": "1.1.1",
     "workspaces": [
         "apps/*"
     ]

package/src/export-chats.ts

@@ -5,7 +5,7 @@ import path from 'node:path';
 import { stdin as input, stdout as output } from 'node:process';
 import { createInterface } from 'node:readline/promises';
 import { getCodexHelpText, parseCodexCliArgs, runCodexExport } from './lib/codex-exporter';
-import { runInteractiveExport } from './lib/interactive-cli';
+import type { InteractiveExportResult } from './lib/interactive-cli';
 import { openPathNatively } from './lib/native-open';
 import { CliUsageError } from './lib/shared';
 
@@ -44,6 +44,7 @@ const shouldRunInteractive = (argv: string[]): boolean => {
 };
 
 const runInteractiveCliFlow = async (): Promise<void> => {
+    const { runInteractiveExport } = await import('./lib/interactive-cli');
     const result = await runInteractiveExport();
     const targetFolder = await printInteractiveExportResult(result);
     await maybeOpenExportFolder(targetFolder);
@@ -55,9 +56,7 @@ const runCodexCliFlow = async (argv: string[]): Promise<void> => {
     printCodexExportResult(result);
 };
 
-const printInteractiveExportResult = async (
-    result: Awaited<ReturnType<typeof runInteractiveExport>>,
-): Promise<string> => {
+const printInteractiveExportResult = async (result: InteractiveExportResult): Promise<string> => {
     if (result.mode === 'claude') {
         console.log(`Exported ${result.sourcePath} -> ${result.outputPath}`);
         return resolveExportFolder(result.outputPath);

package/src/lib/claude-exporter.ts

@@ -848,7 +848,7 @@ const fileExists = async (targetPath: string): Promise<boolean> => {
 };
 
 const requireValue = (value: string | undefined, flag: string): string => {
-    if (!value || value.startsWith('--')) {
+    if (!value || (value.startsWith('-') && value !== '-')) {
         throw new CliUsageError(`Missing value for ${flag}`);
     }
 

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

@@ -26,6 +26,75 @@ type DeleteProjectOptions = {
     deleteSessionFiles?: boolean;
 };
 
+const SQLITE_DELETE_BATCH_SIZE = 400;
+const SESSION_FILE_DELETE_CONCURRENCY = 16;
+const THREAD_LIST_IO_CONCURRENCY = 8;
+
+const chunkValues = <T>(values: T[], chunkSize: number) => {
+    const chunks: T[][] = [];
+
+    for (let index = 0; index < values.length; index += chunkSize) {
+        chunks.push(values.slice(index, index + chunkSize));
+    }
+
+    return chunks;
+};
+
+const isPromiseLike = (value: unknown): value is PromiseLike<unknown> => {
+    if ((typeof value !== 'object' && typeof value !== 'function') || value === null) {
+        return false;
+    }
+
+    return 'then' in value && typeof value.then === 'function';
+};
+
+const mapWithConcurrency = async <T, TResult>(
+    values: T[],
+    limit: number,
+    mapper: (value: T, index: number) => Promise<TResult>,
+) => {
+    const results = new Array<TResult>(values.length);
+    let nextIndex = 0;
+
+    const worker = async () => {
+        while (true) {
+            const currentIndex = nextIndex;
+            nextIndex += 1;
+
+            if (currentIndex >= values.length) {
+                return;
+            }
+
+            results[currentIndex] = await mapper(values[currentIndex]!, currentIndex);
+        }
+    };
+
+    await Promise.all(Array.from({ length: Math.min(limit, values.length) }, () => worker()));
+    return results;
+};
+
+const openReadonlyDb = (dbPath: string, busyTimeoutMs: number) => {
+    const db = new Database(dbPath, { readonly: true });
+    try {
+        db.exec(`PRAGMA busy_timeout = ${busyTimeoutMs}`);
+        return db;
+    } catch (error) {
+        db.close();
+        throw error;
+    }
+};
+
+const openWritableDb = (dbPath: string, busyTimeoutMs: number) => {
+    const db = new Database(dbPath);
+    try {
+        db.exec(`PRAGMA busy_timeout = ${busyTimeoutMs}`);
+        return db;
+    } catch (error) {
+        db.close();
+        throw error;
+    }
+};
+
 const toTimestampMs = (thread: ThreadRow) => {
     return thread.updated_at_ms ?? thread.updated_at * 1000;
 };
@@ -54,13 +123,17 @@ const parseJsonSafely = (value: string | null) => {
     }
 };
 
-const withReadonlyDb = <T>(dbPath: string, callback: (db: Database) => T): T => {
+export const withReadonlyDb = <T>(dbPath: string, callback: (db: Database) => T): T => {
     return runWithSqliteRetry({
         action: () => {
-            const db = new Database(dbPath, { readonly: true });
-            db.exec('PRAGMA busy_timeout = 5000');
+            const db = openReadonlyDb(dbPath, 5000);
             try {
-                return callback(db);
+                const result = callback(db);
+                if (isPromiseLike(result)) {
+                    throw new Error('Database callbacks must be synchronous');
+                }
+
+                return result;
             } finally {
                 db.close();
             }
@@ -71,13 +144,16 @@ const withReadonlyDb = <T>(dbPath: string, callback: (db: Database) => T): T =>
 const withWritableDb = <T>(dbPath: string, callback: (db: Database) => T): T => {
     const db = runWithSqliteRetry({
         action: () => {
-            const connection = new Database(dbPath);
-            connection.exec('PRAGMA busy_timeout = 5000');
-            return connection;
+            return openWritableDb(dbPath, 5000);
         },
     });
     try {
-        return callback(db);
+        const result = callback(db);
+        if (isPromiseLike(result)) {
+            throw new Error('Database callbacks must be synchronous');
+        }
+
+        return result;
     } finally {
         db.close();
     }
@@ -99,9 +175,7 @@ export const resolveCodexThreadDbPath = () => {
         try {
             const db = runWithSqliteRetry({
                 action: () => {
-                    const connection = new Database(candidate, { readonly: true });
-                    connection.exec('PRAGMA busy_timeout = 1500');
-                    return connection;
+                    return openReadonlyDb(candidate, 1500);
                 },
             });
             db.close();
@@ -236,11 +310,21 @@ const getThreadDeleteTargets = (db: Database, threadIds: string[]) => {
         return [];
     }
 
-    const placeholders = threadIds.map(() => '?').join(', ');
-    return db.query(`SELECT id, rollout_path FROM threads WHERE id IN (${placeholders})`).all(...threadIds) as Array<{
-        id: string;
-        rollout_path: string;
-    }>;
+    const targets: Array<{ id: string; rollout_path: string }> = [];
+
+    for (const threadIdChunk of chunkValues(threadIds, SQLITE_DELETE_BATCH_SIZE)) {
+        const placeholders = threadIdChunk.map(() => '?').join(', ');
+        targets.push(
+            ...(db
+                .query(`SELECT id, rollout_path FROM threads WHERE id IN (${placeholders})`)
+                .all(...threadIdChunk) as Array<{
+                id: string;
+                rollout_path: string;
+            }>),
+        );
+    }
+
+    return targets;
 };
 
 const deleteThreadIds = (db: Database, threadIds: string[]): DeleteThreadsResult => {
@@ -263,28 +347,30 @@ const deleteThreadIds = (db: Database, threadIds: string[]): DeleteThreadsResult
     }
 
     const deleteMany = db.transaction((ids: string[]) => {
-        const placeholders = ids.map(() => '?').join(', ');
+        for (const threadIdChunk of chunkValues(ids, SQLITE_DELETE_BATCH_SIZE)) {
+            const placeholders = threadIdChunk.map(() => '?').join(', ');
 
-        // Codex schema differs across versions, so only touch dependent tables that actually exist.
-        if (existingTableNames.has('thread_dynamic_tools')) {
-            db.query(`DELETE FROM thread_dynamic_tools WHERE thread_id IN (${placeholders})`).run(...ids);
-        }
+            // Codex schema differs across versions, so only touch dependent tables that actually exist.
+            if (existingTableNames.has('thread_dynamic_tools')) {
+                db.query(`DELETE FROM thread_dynamic_tools WHERE thread_id IN (${placeholders})`).run(...threadIdChunk);
+            }
 
-        if (existingTableNames.has('thread_goals')) {
-            db.query(`DELETE FROM thread_goals WHERE thread_id IN (${placeholders})`).run(...ids);
-        }
+            if (existingTableNames.has('thread_goals')) {
+                db.query(`DELETE FROM thread_goals WHERE thread_id IN (${placeholders})`).run(...threadIdChunk);
+            }
 
-        if (existingTableNames.has('stage1_outputs')) {
-            db.query(`DELETE FROM stage1_outputs WHERE thread_id IN (${placeholders})`).run(...ids);
-        }
+            if (existingTableNames.has('stage1_outputs')) {
+                db.query(`DELETE FROM stage1_outputs WHERE thread_id IN (${placeholders})`).run(...threadIdChunk);
+            }
 
-        if (existingTableNames.has('thread_spawn_edges')) {
-            db.query(
-                `DELETE FROM thread_spawn_edges WHERE parent_thread_id IN (${placeholders}) OR child_thread_id IN (${placeholders})`,
-            ).run(...ids, ...ids);
-        }
+            if (existingTableNames.has('thread_spawn_edges')) {
+                db.query(
+                    `DELETE FROM thread_spawn_edges WHERE parent_thread_id IN (${placeholders}) OR child_thread_id IN (${placeholders})`,
+                ).run(...threadIdChunk, ...threadIdChunk);
+            }
 
-        db.query(`DELETE FROM threads WHERE id IN (${placeholders})`).run(...ids);
+            db.query(`DELETE FROM threads WHERE id IN (${placeholders})`).run(...threadIdChunk);
+        }
     });
 
     deleteMany(existingIds);
@@ -297,7 +383,10 @@ const deleteThreadIds = (db: Database, threadIds: string[]): DeleteThreadsResult
 
 const deleteThreadSessionFiles = async (sessionFiles: string[]) => {
     const uniqueSessionFiles = [...new Set(sessionFiles)];
-    await Promise.all(uniqueSessionFiles.map((sessionFile) => rm(sessionFile, { force: true })));
+    await mapWithConcurrency(uniqueSessionFiles, SESSION_FILE_DELETE_CONCURRENCY, async (sessionFile) => {
+        await rm(sessionFile, { force: true });
+        return sessionFile;
+    });
     return uniqueSessionFiles;
 };
 
@@ -323,39 +412,37 @@ export const listProjectThreads = async (
     options: ListProjectThreadsOptions = {},
 ): Promise<ThreadListEntry[]> => {
     const threads = filterThreadsByProject(readAllThreads(dbPath), projectName);
-    const entries = await Promise.all(
-        threads.map(async (thread): Promise<ThreadListEntry> => {
-            const rollout = await getThreadRolloutLoadState(thread.rollout_path, options.largeTranscriptThresholdBytes);
-
-            if (rollout.shouldDeferTranscriptLoad) {
-                return {
-                    project: projectName,
-                    rolloutSizeBytes: rollout.fileSizeBytes,
-                    stats: {
-                        deferred: true,
-                        execCommandCount: 0,
-                        toolCallCount: 0,
-                        webSearchEventCount: 0,
-                    },
-                    thread: compactThreadListRow(thread),
-                };
-            }
-
-            const transcript = await getCachedParsedCodexTranscript(thread.rollout_path);
+    const entries = await mapWithConcurrency(threads, THREAD_LIST_IO_CONCURRENCY, async (thread) => {
+        const rollout = await getThreadRolloutLoadState(thread.rollout_path, options.largeTranscriptThresholdBytes);
 
+        if (rollout.shouldDeferTranscriptLoad) {
             return {
                 project: projectName,
                 rolloutSizeBytes: rollout.fileSizeBytes,
                 stats: {
-                    deferred: false,
-                    execCommandCount: transcript.stats.execCommandCount,
-                    toolCallCount: transcript.stats.toolCallCount,
-                    webSearchEventCount: transcript.stats.webSearchEventCount,
+                    deferred: true,
+                    execCommandCount: 0,
+                    toolCallCount: 0,
+                    webSearchEventCount: 0,
                 },
                 thread: compactThreadListRow(thread),
             };
-        }),
-    );
+        }
+
+        const transcript = await getCachedParsedCodexTranscript(thread.rollout_path);
+
+        return {
+            project: projectName,
+            rolloutSizeBytes: rollout.fileSizeBytes,
+            stats: {
+                deferred: false,
+                execCommandCount: transcript.stats.execCommandCount,
+                toolCallCount: transcript.stats.toolCallCount,
+                webSearchEventCount: transcript.stats.webSearchEventCount,
+            },
+            thread: compactThreadListRow(thread),
+        };
+    });
 
     return entries.sort((left, right) => toTimestampMs(right.thread) - toTimestampMs(left.thread));
 };

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

@@ -153,6 +153,17 @@ const logRolloutChangeIfDetected = (
     });
 };
 
+const cleanupExportWorkspace = async (workspacePath: string) => {
+    try {
+        await rm(workspacePath, { force: true, recursive: true });
+    } catch (error) {
+        logExportEvent('warn', 'workspace_cleanup_failed', {
+            error: error instanceof Error ? error.message : String(error),
+            workspacePath,
+        });
+    }
+};
+
 const zipExportFile = async (sourcePath: string, zipPath: string) => {
     const proc = Bun.spawn(['zip', '-9', '-j', zipPath, sourcePath], {
         stderr: 'pipe',
@@ -240,7 +251,7 @@ export const renderCodexThreadDownload = async (
 
                 await zipExportFile(savedPath, zipPath);
             } finally {
-                await rm(workspaceDir, { force: true, recursive: true });
+                await cleanupExportWorkspace(workspaceDir);
             }
 
             const rolloutSnapshotAfter = await getRolloutSnapshot(browseData.thread.rollout_path);
@@ -395,7 +406,7 @@ export const renderCodexThreadsDownload = async (
         });
         throw error;
     } finally {
-        await rm(bundleDirectory, { force: true, recursive: true });
+        await cleanupExportWorkspace(bundleDirectory);
     }
 
     const zipStat = await Bun.file(zipPath).stat();

package/src/lib/codex-exporter-cli.ts

@@ -261,7 +261,7 @@ export const resolveDefaultOutputDir = (cwdFilter: string | null): string => {
 };
 
 const requireValue = (value: string | undefined, flag: string): string => {
-    if (!value || value.startsWith('--')) {
+    if (!value || (value.startsWith('-') && value !== '-')) {
         throw new CliUsageError(`Missing value for ${flag}`);
     }
 

package/src/lib/codex-exporter-db.ts

@@ -1,6 +1,6 @@
-import { Database } from 'bun:sqlite';
 import { readdir } from 'node:fs/promises';
 import path from 'node:path';
+import { withReadonlyDb } from './codex-browser-db';
 import {
     type CodexCliOptions,
     DEFAULT_CODEX_DIR,
@@ -17,33 +17,29 @@ export const loadThreadData = (dbPath: string, options: CodexCliOptions): Thread
     const parentByChildId = new Map<string, SpawnEdgeRow>();
     const childEdgesByParentId = new Map<string, SpawnEdgeRow[]>();
 
-    let db: Database | null = null;
-
     try {
-        db = new Database(dbPath, { readonly: true });
-
-        const threadQuery = buildThreadQuery(options);
-        const threadRows = db.query(threadQuery.sql).all(...threadQuery.params) as ThreadRow[];
+        withReadonlyDb(dbPath, (db) => {
+            const threadQuery = buildThreadQuery(options);
+            const threadRows = db.query(threadQuery.sql).all(...threadQuery.params) as ThreadRow[];
 
-        for (const row of threadRows) {
-            threadsById.set(row.id, row);
-        }
+            for (const row of threadRows) {
+                threadsById.set(row.id, row);
+            }
 
-        const edgeQuery = buildSpawnEdgeQuery([...threadsById.keys()], options);
-        const edgeRows = db.query(edgeQuery.sql).all(...edgeQuery.params) as SpawnEdgeRow[];
+            const edgeQuery = buildSpawnEdgeQuery([...threadsById.keys()], options);
+            const edgeRows = db.query(edgeQuery.sql).all(...edgeQuery.params) as SpawnEdgeRow[];
 
-        for (const row of edgeRows) {
-            parentByChildId.set(row.child_thread_id, row);
+            for (const row of edgeRows) {
+                parentByChildId.set(row.child_thread_id, row);
 
-            const existing = childEdgesByParentId.get(row.parent_thread_id) ?? [];
-            existing.push(row);
-            childEdgesByParentId.set(row.parent_thread_id, existing);
-        }
+                const existing = childEdgesByParentId.get(row.parent_thread_id) ?? [];
+                existing.push(row);
+                childEdgesByParentId.set(row.parent_thread_id, existing);
+            }
+        });
     } catch (error) {
         const message = error instanceof Error ? error.message : String(error);
         throw new Error(`Failed to read thread database at ${dbPath}: ${message}`);
-    } finally {
-        db?.close();
     }
 
     return {
@@ -210,14 +206,17 @@ export const toOutputRelativePath = (
         return flatName;
     }
 
+    // Prefer preserving the input sessions tree when the rollout lives under the configured input root.
     if (normalized.startsWith(`${inputRoot}${path.sep}`)) {
         return path.relative(inputRoot, normalized).replace(/\.jsonl$/i, extension);
     }
 
+    // Fall back to a stable Codex-relative path when the file is under ~/.codex.
     if (normalized.startsWith(`${codexRoot}${path.sep}`)) {
         return path.relative(codexRoot, normalized).replace(/\.jsonl$/i, extension);
     }
 
+    // Otherwise collapse to the basename so ad hoc session files cannot escape the output directory.
     return path.basename(normalized).replace(/\.jsonl$/i, extension);
 };