spiracha 1.4.0 → 1.5.0

package/apps/ui/dist/server/assets/{codex-server-CNXSJuc2.js → codex-server-CGXU4H8-.js}

@@ -1,18 +1,20 @@
 import { t as createServerFn } from "../server.js";
 import { t as createServerRpc } from "./createServerRpc-CF_DEwnm.js";
-import { a as cleanInlineTitle, c as formatInlineLiteral, d as readJsonlObjects, h as renderSection, i as cleanExtractedText, l as formatModelLabel, m as renderMetadataBlock, n as asObject, o as createExportWriteStream, p as renderDocumentTitle, r as asString, s as finalizeExportWriteStream, t as asNumber, u as getPortablePathBasename } from "./shared-CPRNYIql.js";
+import { a as sanitizeExportFileName, n as ensureUiExportDir, o as zipExportDirectory, r as getExportMimeType, s as zipExportFile, t as buildUiExportDownloadUrl } from "./ui-export-files-BHLX9bhN.js";
+import { a as cleanExtractedText, c as finalizeExportWriteStream, d as getPortablePathBasename, f as readJsonlObjects$1, g as renderSection, h as renderMetadataBlock, i as asString, l as formatInlineLiteral, m as renderDocumentTitle, n as asNumber, o as cleanInlineTitle, r as asObject, s as createExportWriteStream, u as formatModelLabel } from "./shared-DyhChtHf.js";
 import { t as mapWithConcurrency } from "./concurrency-VXtYvlGh.js";
 import { t as isRetryableSqliteError } from "./sqlite-error-LZDrnxdd.js";
 import { t as applyPathTransforms } from "./path-transforms-DL2IwtYd.js";
-import { a as sanitizeExportFileName, n as ensureUiExportDir, o as zipExportDirectory, r as getExportMimeType, s as zipExportFile, t as buildUiExportDownloadUrl } from "./ui-export-files-BHLX9bhN.js";
 import { finished } from "node:stream/promises";
 import { z } from "zod";
-import { Database } from "bun:sqlite";
+import { createHash, randomUUID } from "node:crypto";
 import { copyFile, mkdir, mkdtemp, readdir, rename, rm, stat, utimes } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
-import { createReadStream } from "node:fs";
-import { createHash, randomUUID } from "node:crypto";
+import { Database, constants } from "bun:sqlite";
+import { closeSync, createReadStream, openSync, readSync, readdirSync, statSync } from "node:fs";
+import { StringDecoder } from "node:string_decoder";
+import { pathToFileURL } from "node:url";
 //#region ../../src/lib/codex-exporter-types.ts
 var DEFAULT_CODEX_DIR = path.join(os.homedir(), ".codex");
 var DEFAULT_DB_PATH = path.join(DEFAULT_CODEX_DIR, "state_5.sqlite");
@@ -57,7 +59,7 @@ var parseCodexTranscriptFile = async (sessionFile, options = {}) => {
 	const maxEvents = options.maxEvents ?? Number.POSITIVE_INFINITY;
 	const maxTurnContexts = options.maxTurnContexts ?? Number.POSITIVE_INFINITY;
 	let sequence = 0;
-	for await (const parsed of readJsonlObjects(sessionFile)) {
+	for await (const parsed of readJsonlObjects$1(sessionFile)) {
 		captureSessionMeta$1(parsed, sessionMeta);
 		if (asString(parsed.type) === "turn_context") {
 			if (turnContexts.length < maxTurnContexts) captureTurnContext(parsed, turnContexts);
@@ -433,12 +435,24 @@ var invalidateCacheByPrefix = async (...prefixes) => {
 //#endregion
 //#region ../../src/lib/codex-thread-cache.ts
 var LARGE_THREAD_SIZE_BYTES = 100 * 1024 * 1024;
+var isMissingFileError$2 = (error) => {
+	return error instanceof Error && "code" in error && error.code === "ENOENT";
+};
 var getCachedParsedCodexTranscript = async (sessionFile) => {
 	const fingerprint = await getFileFingerprint(sessionFile);
 	return withCachedJson(`thread-${hashCacheKeyParts(path.basename(sessionFile), fingerprint)}`, async () => parseCodexTranscriptFile(sessionFile));
 };
 var getThreadRolloutLoadState = async (sessionFile, largeTranscriptThresholdBytes = LARGE_THREAD_SIZE_BYTES) => {
-	const metadata = await stat(sessionFile);
+	let metadata;
+	try {
+		metadata = await stat(sessionFile);
+	} catch (error) {
+		if (isMissingFileError$2(error)) return {
+			fileSizeBytes: null,
+			shouldDeferTranscriptLoad: false
+		};
+		throw error;
+	}
 	return {
 		fileSizeBytes: metadata.size,
 		shouldDeferTranscriptLoad: metadata.size > largeTranscriptThresholdBytes
@@ -496,6 +510,13 @@ var runWithSqliteRetry = ({ action, delaysMs = DEFAULT_RETRY_DELAYS_MS, sleep =
 var SQLITE_DELETE_BATCH_SIZE = 400;
 var SESSION_FILE_DELETE_CONCURRENCY = 16;
 var THREAD_LIST_IO_CONCURRENCY = 8;
+var CODEX_READONLY_DB_OPEN_FLAGS = constants.SQLITE_OPEN_READONLY | constants.SQLITE_OPEN_URI;
+var JSONL_READ_CHUNK_BYTES = 64 * 1024;
+var SESSION_META_READ_LIMIT_BYTES = 4 * 1024 * 1024;
+var THREAD_ID_PATTERN = /([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\.jsonl$/iu;
+var isSqliteCantOpenError = (error) => {
+	return error.code === "SQLITE_CANTOPEN";
+};
 var chunkValues = (values, chunkSize) => {
 	const chunks = [];
 	for (let index = 0; index < values.length; index += chunkSize) chunks.push(values.slice(index, index + chunkSize));
@@ -505,15 +526,16 @@ var isPromiseLike = (value) => {
 	if (typeof value !== "object" && typeof value !== "function" || value === null) return false;
 	return "then" in value && typeof value.then === "function";
 };
-var openReadonlyDb = (dbPath, busyTimeoutMs) => {
+var openReadonlyDb = (dbPath) => {
 	const db = new Database(dbPath, { readonly: true });
 	try {
-		db.exec(`PRAGMA busy_timeout = ${busyTimeoutMs}`);
+		db.query("SELECT name FROM sqlite_master LIMIT 1").get();
 		return db;
 	} catch (error) {
 		db.close();
-		throw error;
+		if (!isSqliteCantOpenError(error)) throw error;
 	}
+	return new Database(`${pathToFileURL(dbPath).href}?immutable=1`, CODEX_READONLY_DB_OPEN_FLAGS);
 };
 var openWritableDb = (dbPath, busyTimeoutMs) => {
 	const db = new Database(dbPath);
@@ -549,7 +571,7 @@ var parseJsonSafely$1 = (value) => {
 };
 var withReadonlyDb = (dbPath, callback) => {
 	return runWithSqliteRetry({ action: () => {
-		const db = openReadonlyDb(dbPath, 5e3);
+		const db = openReadonlyDb(dbPath);
 		try {
 			const result = callback(db);
 			if (isPromiseLike(result)) throw new Error("Database callbacks must be synchronous");
@@ -580,9 +602,7 @@ var resolveCodexThreadDbPath = () => {
 		path.join(os.homedir(), ".codex", "state_5.sqlite")
 	];
 	for (const candidate of candidates) try {
-		runWithSqliteRetry({ action: () => {
-			return openReadonlyDb(candidate, 1500);
-		} }).close();
+		if (!statSync(candidate).isFile()) continue;
 		return candidate;
 	} catch {}
 	throw new Error(`Unable to open Codex thread database. Tried: ${candidates.join(", ")}`);
@@ -592,6 +612,256 @@ var readAllThreads = (dbPath) => {
 		return db.query("SELECT * FROM threads ORDER BY COALESCE(updated_at_ms, updated_at * 1000) DESC, id DESC").all();
 	});
 };
+var resolveCodexDirFromDbPath$1 = (dbPath) => {
+	const dbDir = path.dirname(dbPath);
+	return path.basename(dbDir) === "sqlite" ? path.dirname(dbDir) : dbDir;
+};
+var parseJsonlObject = (line) => {
+	try {
+		return JSON.parse(line);
+	} catch {
+		return null;
+	}
+};
+var emitJsonlLine = (line, onRecord) => {
+	const trimmed = line.trim();
+	const parsed = trimmed ? parseJsonlObject(trimmed) : null;
+	if (parsed) onRecord(parsed);
+};
+var emitCompleteJsonlLines = (text, onRecord) => {
+	const lines = text.split(/\r?\n/u);
+	const pending = lines.pop() ?? "";
+	for (const line of lines) emitJsonlLine(line, onRecord);
+	return pending;
+};
+var readJsonlObjects = (filePath, onRecord) => {
+	let descriptor = null;
+	try {
+		if (!statSync(filePath).isFile()) return;
+		descriptor = openSync(filePath, "r");
+		const buffer = Buffer.alloc(JSONL_READ_CHUNK_BYTES);
+		const decoder = new StringDecoder("utf8");
+		let position = 0;
+		let pending = "";
+		while (true) {
+			const bytesRead = readSync(descriptor, buffer, 0, buffer.length, position);
+			if (bytesRead === 0) break;
+			position += bytesRead;
+			pending += decoder.write(buffer.subarray(0, bytesRead));
+			pending = emitCompleteJsonlLines(pending, onRecord);
+		}
+		emitJsonlLine(pending + decoder.end(), onRecord);
+	} catch {
+		return;
+	} finally {
+		if (descriptor !== null) closeSync(descriptor);
+	}
+};
+var collectJsonlObjects = (filePath) => {
+	const records = [];
+	readJsonlObjects(filePath, (record) => {
+		records.push(record);
+	});
+	return records;
+};
+var readSessionIndexEntries = (codexDir) => {
+	return collectJsonlObjects(path.join(codexDir, "session_index.jsonl")).filter((entry) => typeof entry.id === "string" && entry.id.length > 0);
+};
+var collectSessionFilesByThreadId = (sessionsDir) => {
+	const sessionFiles = /* @__PURE__ */ new Map();
+	const visit = (directory) => {
+		const entries = (() => {
+			try {
+				return readdirSync(directory, { withFileTypes: true });
+			} catch {
+				return null;
+			}
+		})();
+		if (!entries) return;
+		for (const entry of entries) {
+			const entryPath = path.join(directory, entry.name);
+			if (entry.isDirectory()) {
+				visit(entryPath);
+				continue;
+			}
+			if (!entry.isFile()) continue;
+			const threadId = THREAD_ID_PATTERN.exec(entry.name)?.[1];
+			if (threadId && !sessionFiles.has(threadId)) sessionFiles.set(threadId, entryPath);
+		}
+	};
+	visit(sessionsDir);
+	return sessionFiles;
+};
+var readSessionMetaLine = (sessionFile) => {
+	let descriptor = null;
+	try {
+		descriptor = openSync(sessionFile, "r");
+		const chunks = [];
+		let totalBytes = 0;
+		while (totalBytes < SESSION_META_READ_LIMIT_BYTES) {
+			const buffer = Buffer.alloc(Math.min(64 * 1024, SESSION_META_READ_LIMIT_BYTES - totalBytes));
+			const bytesRead = readSync(descriptor, buffer, 0, buffer.length, totalBytes);
+			if (bytesRead === 0) break;
+			chunks.push(buffer.subarray(0, bytesRead));
+			totalBytes += bytesRead;
+			if (buffer.subarray(0, bytesRead).includes(10)) break;
+		}
+		return Buffer.concat(chunks).toString("utf8").split(/\r?\n/u)[0]?.trim() || null;
+	} catch {
+		return null;
+	} finally {
+		if (descriptor !== null) closeSync(descriptor);
+	}
+};
+var readFallbackSessionMeta = (sessionFile) => {
+	const line = readSessionMetaLine(sessionFile);
+	if (!line) return null;
+	try {
+		const record = JSON.parse(line);
+		return record.type === "session_meta" && record.payload ? record.payload : null;
+	} catch {
+		return null;
+	}
+};
+var parseIsoMs = (value, fallback) => {
+	if (!value) return fallback;
+	const parsed = Date.parse(value);
+	return Number.isFinite(parsed) ? parsed : fallback;
+};
+var stringOrNull = (value) => typeof value === "string" && value.length > 0 ? value : null;
+var numberOrNull = (value) => typeof value === "number" && Number.isFinite(value) ? value : null;
+var objectOrNull = (value) => {
+	return typeof value === "object" && value !== null && !Array.isArray(value) ? value : null;
+};
+var isFallbackSubagent = (sessionMeta) => {
+	return Boolean(sessionMeta.thread_source === "subagent" || stringOrNull(sessionMeta.parent_thread_id) || stringOrNull(sessionMeta.forked_from_id));
+};
+var readFallbackRolloutStats = (sessionFile) => {
+	let model = null;
+	let tokensUsed = 0;
+	readJsonlObjects(sessionFile, (record) => {
+		const payload = objectOrNull(record.payload);
+		if (!payload) return;
+		if (record.type === "turn_context") {
+			model = stringOrNull(payload.model) ?? model;
+			return;
+		}
+		const payloadType = stringOrNull(payload.type);
+		if (payloadType === "message" || payloadType === "agent_message") {
+			model = stringOrNull(payload.model) ?? model;
+			return;
+		}
+		if (payloadType !== "token_count") return;
+		tokensUsed = numberOrNull(objectOrNull(objectOrNull(payload.info)?.total_token_usage)?.total_tokens) ?? tokensUsed;
+	});
+	return {
+		model,
+		tokensUsed
+	};
+};
+var buildFallbackThreadRow = (entry, sessionFile, sessionMeta, rolloutStats) => {
+	const cwd = stringOrNull(sessionMeta.cwd);
+	if (!cwd) return null;
+	let mtimeMs = Date.now();
+	try {
+		mtimeMs = statSync(sessionFile).mtimeMs;
+	} catch {}
+	const updatedAtMs = parseIsoMs(entry.updated_at, mtimeMs);
+	const createdAtMs = parseIsoMs(sessionMeta.timestamp, updatedAtMs);
+	const title = entry.thread_name?.trim() || path.basename(sessionFile, ".jsonl");
+	const source = stringOrNull(sessionMeta.source) ?? "session_file";
+	return {
+		agent_nickname: sessionMeta.agent_nickname ?? null,
+		agent_path: sessionMeta.agent_path ?? null,
+		agent_role: sessionMeta.agent_role ?? null,
+		approval_mode: "unknown",
+		archived: 0,
+		archived_at: null,
+		cli_version: sessionMeta.cli_version ?? "",
+		created_at: Math.floor(createdAtMs / 1e3),
+		created_at_ms: Math.floor(createdAtMs),
+		cwd,
+		first_user_message: title,
+		git_branch: null,
+		git_origin_url: null,
+		git_sha: null,
+		has_user_event: sessionMeta.thread_source === "user" ? 1 : 0,
+		id: entry.id,
+		memory_mode: "enabled",
+		model: rolloutStats.model,
+		model_provider: sessionMeta.model_provider ?? "unknown",
+		preview: title,
+		reasoning_effort: null,
+		rollout_path: sessionFile,
+		sandbox_policy: "{}",
+		source,
+		thread_source: sessionMeta.thread_source ?? null,
+		title,
+		tokens_used: rolloutStats.tokensUsed,
+		updated_at: Math.floor(updatedAtMs / 1e3),
+		updated_at_ms: Math.floor(updatedAtMs)
+	};
+};
+var readFallbackThreadRows = (dbPath, existingThreadIds, projectName = null, options = {}) => {
+	const codexDir = resolveCodexDirFromDbPath$1(dbPath);
+	const sessionFilesByThreadId = collectSessionFilesByThreadId(path.join(codexDir, "sessions"));
+	const fallbackThreads = [];
+	for (const entry of readSessionIndexEntries(codexDir)) {
+		if (existingThreadIds.has(entry.id)) continue;
+		const sessionFile = sessionFilesByThreadId.get(entry.id);
+		if (!sessionFile) continue;
+		const sessionMeta = readFallbackSessionMeta(sessionFile);
+		if (!sessionMeta) continue;
+		if (!options.includeSubagents && isFallbackSubagent(sessionMeta)) continue;
+		const fallbackThread = buildFallbackThreadRow(entry, sessionFile, sessionMeta, readFallbackRolloutStats(sessionFile));
+		if (!fallbackThread || projectName && getPortablePathBasename(fallbackThread.cwd) !== projectName) continue;
+		fallbackThreads.push(fallbackThread);
+	}
+	return fallbackThreads;
+};
+var mergeFallbackThreadRows = (dbPath, threads, projectName = null) => {
+	const threadIds = new Set(threads.map((thread) => thread.id));
+	return [...threads, ...readFallbackThreadRows(dbPath, threadIds, projectName)].sort((left, right) => {
+		const updatedDifference = toTimestampMs(right) - toTimestampMs(left);
+		if (updatedDifference !== 0) return updatedDifference;
+		return right.id.localeCompare(left.id);
+	});
+};
+var applyRolloutActivityTimestamps = (threads) => {
+	return threads.map((thread) => {
+		let rolloutUpdatedAtMs = toTimestampMs(thread);
+		try {
+			rolloutUpdatedAtMs = Math.max(rolloutUpdatedAtMs, statSync(thread.rollout_path).mtimeMs);
+		} catch {}
+		if (rolloutUpdatedAtMs <= toTimestampMs(thread)) return thread;
+		return {
+			...thread,
+			updated_at: Math.floor(rolloutUpdatedAtMs / 1e3),
+			updated_at_ms: Math.floor(rolloutUpdatedAtMs)
+		};
+	}).sort((left, right) => {
+		const updatedDifference = toTimestampMs(right) - toTimestampMs(left);
+		if (updatedDifference !== 0) return updatedDifference;
+		return right.id.localeCompare(left.id);
+	});
+};
+var buildDashboardRecentThreads = (threads) => {
+	const bestThreadByProject = /* @__PURE__ */ new Map();
+	for (const thread of threads) {
+		const project = getPortablePathBasename(thread.cwd);
+		if (!project) continue;
+		const current = bestThreadByProject.get(project);
+		if (!current || toTimestampMs(thread) > toTimestampMs(current)) bestThreadByProject.set(project, thread);
+	}
+	return [...bestThreadByProject.values()].sort((left, right) => {
+		const updatedDifference = toTimestampMs(right) - toTimestampMs(left);
+		if (updatedDifference !== 0) return updatedDifference;
+		return right.id.localeCompare(left.id);
+	}).slice(0, 5).map((thread) => ({
+		project: getPortablePathBasename(thread.cwd),
+		thread: compactThreadListRow(thread)
+	}));
+};
 var filterThreadsByProject = (threads, projectName) => {
 	if (!projectName) return threads;
 	return threads.filter((thread) => getPortablePathBasename(thread.cwd) === projectName);
@@ -696,7 +966,7 @@ var deleteThreadSessionFiles = async (sessionFiles) => {
 	return uniqueSessionFiles;
 };
 var listCodexProjects = (dbPath) => {
-	return mapProjectSummaries(buildProjectSummaryMap(readAllThreads(dbPath)));
+	return mapProjectSummaries(buildProjectSummaryMap(applyRolloutActivityTimestamps(mergeFallbackThreadRows(dbPath, readAllThreads(dbPath)))));
 };
 var compactThreadListRow = (thread) => {
 	return {
@@ -706,8 +976,19 @@ var compactThreadListRow = (thread) => {
 	};
 };
 var listProjectThreads = async (dbPath, projectName, options = {}) => {
-	return (await mapWithConcurrency(filterThreadsByProject(readAllThreads(dbPath), projectName), THREAD_LIST_IO_CONCURRENCY, async (thread) => {
+	return (await mapWithConcurrency(applyRolloutActivityTimestamps(mergeFallbackThreadRows(dbPath, filterThreadsByProject(readAllThreads(dbPath), projectName), projectName)), THREAD_LIST_IO_CONCURRENCY, async (thread) => {
 		const rollout = await getThreadRolloutLoadState(thread.rollout_path, options.largeTranscriptThresholdBytes);
+		if (rollout.fileSizeBytes === null) return {
+			project: projectName,
+			rolloutSizeBytes: null,
+			stats: {
+				deferred: false,
+				execCommandCount: 0,
+				toolCallCount: 0,
+				webSearchEventCount: 0
+			},
+			thread: compactThreadListRow(thread)
+		};
 		if (rollout.shouldDeferTranscriptLoad) return {
 			project: projectName,
 			rolloutSizeBytes: rollout.fileSizeBytes,
@@ -736,10 +1017,11 @@ var listProjectThreads = async (dbPath, projectName, options = {}) => {
 var getThreadBrowseData = (dbPath, threadId) => {
 	return withReadonlyDb(dbPath, (db) => {
 		const existingTableNames = getExistingTableNames(db);
-		const thread = db.query("SELECT * FROM threads WHERE id = ? LIMIT 1").get(threadId);
+		const dbThread = db.query("SELECT * FROM threads WHERE id = ? LIMIT 1").get(threadId);
+		const thread = dbThread ?? readFallbackThreadRows(dbPath, /* @__PURE__ */ new Set(), null, { includeSubagents: true }).find((fallbackThread) => fallbackThread.id === threadId) ?? null;
 		if (!thread) throw new Error(`Thread not found: ${threadId}`);
 		return {
-			dynamicTools: (existingTableNames.has("thread_dynamic_tools") ? db.query("SELECT thread_id, position, name, description, input_schema, defer_loading, namespace FROM thread_dynamic_tools WHERE thread_id = ? ORDER BY position ASC").all(threadId) : []).map((row) => parseDynamicToolRow(row)),
+			dynamicTools: (dbThread && existingTableNames.has("thread_dynamic_tools") ? db.query("SELECT thread_id, position, name, description, input_schema, defer_loading, namespace FROM thread_dynamic_tools WHERE thread_id = ? ORDER BY position ASC").all(threadId) : []).map((row) => parseDynamicToolRow(row)),
 			project: getPortablePathBasename(thread.cwd),
 			relations: getRelationsForThread(db, threadId, existingTableNames),
 			thread
@@ -747,7 +1029,7 @@ var getThreadBrowseData = (dbPath, threadId) => {
 	});
 };
 var getCodexDashboardSummary = (dbPath) => {
-	const threads = readAllThreads(dbPath);
+	const threads = applyRolloutActivityTimestamps(mergeFallbackThreadRows(dbPath, readAllThreads(dbPath)));
 	const projects = mapProjectSummaries(buildProjectSummaryMap(threads));
 	const threadsWithRelations = withReadonlyDb(dbPath, (db) => {
 		if (!getExistingTableNames(db).has("thread_spawn_edges")) return 0;
@@ -757,10 +1039,7 @@ var getCodexDashboardSummary = (dbPath) => {
 	return {
 		activeThreads: threads.filter((thread) => !thread.archived).length,
 		archivedThreads: threads.filter((thread) => Boolean(thread.archived)).length,
-		recentThreads: threads.slice(0, 5).filter((thread) => Boolean(getPortablePathBasename(thread.cwd))).map((thread) => ({
-			project: getPortablePathBasename(thread.cwd),
-			thread: compactThreadListRow(thread)
-		})),
+		recentThreads: buildDashboardRecentThreads(threads),
 		threadsWithRelations,
 		topProjectsByThreadCount: [...projects].sort((left, right) => {
 			if (left.threadCount !== right.threadCount) return right.threadCount - left.threadCount;
@@ -827,7 +1106,7 @@ var deleteCodexProject = async (dbPath, projectName, options = {}) => {
 	}
 };
 var listScopedThreads = (dbPath, projectName) => {
-	return filterThreadsByProject(readAllThreads(dbPath), projectName);
+	return mergeFallbackThreadRows(dbPath, filterThreadsByProject(readAllThreads(dbPath), projectName), projectName);
 };
 var invalidateCodexUiCaches = async () => {
 	await invalidateCacheByPrefix("analytics-", "thread-");
@@ -905,7 +1184,7 @@ var buildThreadAnalyticsCacheKey = (thread) => {
 var parseThreadAnalyticsFile = async (sessionFile) => {
 	const toolNames = [];
 	let hasWebSearch = false;
-	for await (const parsed of readJsonlObjects(sessionFile)) {
+	for await (const parsed of readJsonlObjects$1(sessionFile)) {
 		if (parsed.type !== "response_item") continue;
 		const payload = asObject(parsed.payload);
 		if (!payload) continue;
@@ -1006,7 +1285,7 @@ var writeSessionFileExport = async (target, options, outputPath, transform = (te
 	let wroteSection = false;
 	try {
 		transcriptStream = await createExportWriteStream(transcriptOutputPath);
-		for await (const parsed of readJsonlObjects(target.sessionFile)) {
+		for await (const parsed of readJsonlObjects$1(target.sessionFile)) {
 			captureSessionMeta(parsed, state.sessionMeta);
 			const block = renderCodexTranscriptRecord(parsed, options, state);
 			if (!block) continue;
@@ -1043,7 +1322,7 @@ var collectCodexTranscript = async (sessionFile, options, assistantModel = null)
 		sections: [],
 		sessionMeta: {}
 	};
-	for await (const parsed of readJsonlObjects(sessionFile)) processCodexTranscriptRecord(parsed, options, state);
+	for await (const parsed of readJsonlObjects$1(sessionFile)) processCodexTranscriptRecord(parsed, options, state);
 	return state;
 };
 var getSectionSeparator = () => "\n";
@@ -1500,6 +1779,17 @@ var getRolloutSnapshot = async (rolloutPath) => {
 		sizeBytes: metadata.size
 	};
 };
+var isMissingFileError$1 = (error) => {
+	return error instanceof Error && "code" in error && error.code === "ENOENT";
+};
+var getExistingRolloutSnapshot = async (threadId, rolloutPath) => {
+	try {
+		return await getRolloutSnapshot(rolloutPath);
+	} catch (error) {
+		if (isMissingFileError$1(error)) throw new Error(`Thread ${threadId} rollout file is missing: ${rolloutPath}`, { cause: error });
+		throw error;
+	}
+};
 var logExportEvent = (level, event, details) => {
 	console[level](`[spiracha:export] ${event}`, details);
 };
@@ -1537,7 +1827,7 @@ var renderCodexThreadDownload = async (input) => {
 		...input.pathDisplaySettings,
 		projectPath: browseData.thread.cwd
 	}) : text;
-	const rolloutSnapshotBefore = await getRolloutSnapshot(browseData.thread.rollout_path);
+	const rolloutSnapshotBefore = await getExistingRolloutSnapshot(input.threadId, browseData.thread.rollout_path);
 	logExportEvent("info", "single_start", {
 		fileName,
 		sizeBytes: rolloutSnapshotBefore.sizeBytes,
@@ -1630,7 +1920,7 @@ var renderCodexThreadsDownload = async (input) => {
 	});
 	try {
 		for (const entry of browseEntries) {
-			const rolloutSnapshotBefore = await getRolloutSnapshot(entry.thread.rollout_path);
+			const rolloutSnapshotBefore = await getExistingRolloutSnapshot(entry.thread.id, entry.thread.rollout_path);
 			const singleBaseName = buildExportBaseName(entry.thread);
 			const uniqueBaseName = buildUniqueBatchEntryBaseName(singleBaseName, entry.thread.id, usedBatchEntryBaseNames);
 			const relativeFileName = `${uniqueBaseName}.${input.outputFormat === "md" ? "md" : "txt"}`;

package/apps/ui/dist/server/assets/{cursor-db-cYZEU3WQ.js → cursor-db-CZnYy7aT.js}

@@ -1,9 +1,9 @@
-import { n as asObject, r as asString, t as asNumber } from "./shared-CPRNYIql.js";
+import { i as asString, n as asNumber, r as asObject } from "./shared-DyhChtHf.js";
 import { getCursorGlobalDbPath, getCursorProjectsDir, getCursorWorkspaceStorageDir, resolveCursorUserDir } from "./cursor-exporter-types-CI3goo-c.js";
-import { Database, constants } from "bun:sqlite";
+import { createHash } from "node:crypto";
 import { readdir, stat } from "node:fs/promises";
 import path from "node:path";
-import { createHash } from "node:crypto";
+import { Database, constants } from "bun:sqlite";
 //#region ../../src/lib/cursor-db.ts
 var CURSOR_READONLY_DB_OPEN_FLAGS = constants.SQLITE_OPEN_READONLY | constants.SQLITE_OPEN_URI;
 var getCursorReadonlyDbUri = (dbPath) => {

package/apps/ui/dist/server/assets/{cursor-recovery-nq-kR62j.js → cursor-recovery-CXpO8KcD.js}

@@ -1,7 +1,7 @@
 import { COMPOSER_DATA_KEY, COMPOSER_HEADERS_KEY, getCursorGlobalDbPath, resolveCursorUserDir } from "./cursor-exporter-types-CI3goo-c.js";
-import { findCursorTranscriptDirs, invalidateCursorDiscoveryCache, listCursorWorkspaceGroups, loadGlobalComposerHeaders, openCursorReadonlyDb } from "./cursor-db-cYZEU3WQ.js";
-import { Database } from "bun:sqlite";
+import { findCursorTranscriptDirs, invalidateCursorDiscoveryCache, listCursorWorkspaceGroups, loadGlobalComposerHeaders, openCursorReadonlyDb } from "./cursor-db-CZnYy7aT.js";
 import { rm } from "node:fs/promises";
+import { Database } from "bun:sqlite";
 //#region ../../src/lib/cursor-recovery.ts
 var isCursorRunning = async () => {
 	return await Bun.spawn([

package/apps/ui/dist/server/assets/{cursor-server-C3q7hrp-.js → cursor-server-DNu52A3K.js}

@@ -2,10 +2,10 @@ import { t as createServerFn } from "../server.js";
 import { t as createServerRpc } from "./createServerRpc-CF_DEwnm.js";
 import { a as sanitizeExportFileName, i as resolveUniqueExportFileBaseName, n as ensureUiExportDir, o as zipExportDirectory, r as getExportMimeType, t as buildUiExportDownloadUrl } from "./ui-export-files-BHLX9bhN.js";
 import { z } from "zod";
+import { randomUUID } from "node:crypto";
 import { mkdtemp, rm } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
-import { randomUUID } from "node:crypto";
 //#region src/lib/cursor-server.ts?tss-serverfn-split
 var workspaceSchema = z.object({ workspaceKey: z.string().min(1) });
 var threadSchema = z.object({ composerId: z.string().min(1) });
@@ -31,11 +31,11 @@ var exportThreadsSchema = z.object({
 });
 var deleteThreadsSchema = z.object({ composerIds: z.array(z.string().min(1)).min(1) });
 var ensureCursorClosedForWrite = async () => {
-	const { isCursorRunning } = await import("./cursor-recovery-nq-kR62j.js");
+	const { isCursorRunning } = await import("./cursor-recovery-CXpO8KcD.js");
 	if (await isCursorRunning()) throw new Error("Quit Cursor before deleting. It rewrites chat history on exit, which can resurrect deleted threads.");
 };
 var findGroupByKey = async (workspaceKey) => {
-	const { listCursorWorkspaceGroups } = await import("./cursor-db-cYZEU3WQ.js");
+	const { listCursorWorkspaceGroups } = await import("./cursor-db-CZnYy7aT.js");
 	const group = (await listCursorWorkspaceGroups()).find((candidate) => candidate.key === workspaceKey);
 	if (!group) throw new Error(`Cursor workspace not found: ${workspaceKey}`);
 	return group;
@@ -69,7 +69,7 @@ var renderCursorZipDownload = async (rendered, outputFormat) => {
 	};
 };
 var findCursorThreadByComposerId = async (composerId) => {
-	const { listCursorThreadsForGroup, listCursorWorkspaceGroups } = await import("./cursor-db-cYZEU3WQ.js");
+	const { listCursorThreadsForGroup, listCursorWorkspaceGroups } = await import("./cursor-db-CZnYy7aT.js");
 	for (const group of await listCursorWorkspaceGroups()) {
 		const thread = (await listCursorThreadsForGroup(group, void 0, { includeTranscriptDirs: false })).find((candidate) => candidate.composerId === composerId);
 		if (thread) return thread;
@@ -77,9 +77,9 @@ var findCursorThreadByComposerId = async (composerId) => {
 	return null;
 };
 var renderCursorDownload = async (input) => {
-	const { readCursorThreadTranscriptWithAgentFiles } = await import("./cursor-db-cYZEU3WQ.js");
+	const { readCursorThreadTranscriptWithAgentFiles } = await import("./cursor-db-CZnYy7aT.js");
 	const { getCursorGlobalDbPath } = await import("./cursor-exporter-types-CI3goo-c.js");
-	const { renderCursorTranscript } = await import("./cursor-transcript-2iL3KFSK.js");
+	const { renderCursorTranscript } = await import("./cursor-transcript-B7tGnqtn.js");
 	const globalDbPath = getCursorGlobalDbPath();
 	const rendered = await Promise.all(input.composerIds.map(async (composerId) => {
 		const transcript = await readCursorThreadTranscriptWithAgentFiles(globalDbPath, composerId);
@@ -111,7 +111,7 @@ var listCursorWorkspacesFn_createServerFn_handler = createServerRpc({
 	filename: "src/lib/cursor-server.ts"
 }, (opts) => listCursorWorkspacesFn.__executeServer(opts));
 var listCursorWorkspacesFn = createServerFn({ method: "GET" }).handler(listCursorWorkspacesFn_createServerFn_handler, async () => {
-	const { listCursorWorkspaceGroups } = await import("./cursor-db-cYZEU3WQ.js");
+	const { listCursorWorkspaceGroups } = await import("./cursor-db-CZnYy7aT.js");
 	return listCursorWorkspaceGroups();
 });
 var listCursorThreadsFn_createServerFn_handler = createServerRpc({
@@ -120,7 +120,7 @@ var listCursorThreadsFn_createServerFn_handler = createServerRpc({
 	filename: "src/lib/cursor-server.ts"
 }, (opts) => listCursorThreadsFn.__executeServer(opts));
 var listCursorThreadsFn = createServerFn({ method: "GET" }).validator(workspaceSchema).handler(listCursorThreadsFn_createServerFn_handler, async ({ data }) => {
-	const { listCursorThreadsForGroup } = await import("./cursor-db-cYZEU3WQ.js");
+	const { listCursorThreadsForGroup } = await import("./cursor-db-CZnYy7aT.js");
 	return listCursorThreadsForGroup(await findGroupByKey(data.workspaceKey), void 0, { includeTranscriptDirs: false });
 });
 var getCursorThreadDetailFn_createServerFn_handler = createServerRpc({
@@ -129,7 +129,7 @@ var getCursorThreadDetailFn_createServerFn_handler = createServerRpc({
 	filename: "src/lib/cursor-server.ts"
 }, (opts) => getCursorThreadDetailFn.__executeServer(opts));
 var getCursorThreadDetailFn = createServerFn({ method: "GET" }).validator(threadSchema).handler(getCursorThreadDetailFn_createServerFn_handler, async ({ data }) => {
-	const { readCursorThreadTranscriptWithAgentFiles } = await import("./cursor-db-cYZEU3WQ.js");
+	const { readCursorThreadTranscriptWithAgentFiles } = await import("./cursor-db-CZnYy7aT.js");
 	const { getCursorGlobalDbPath } = await import("./cursor-exporter-types-CI3goo-c.js");
 	const thread = await findCursorThreadByComposerId(data.composerId);
 	if (!thread) throw new Error(`Cursor thread not found: ${data.composerId}`);
@@ -174,7 +174,7 @@ var recoverCursorWorkspaceFn_createServerFn_handler = createServerRpc({
 	filename: "src/lib/cursor-server.ts"
 }, (opts) => recoverCursorWorkspaceFn.__executeServer(opts));
 var recoverCursorWorkspaceFn = createServerFn({ method: "POST" }).validator(recoverSchema).handler(recoverCursorWorkspaceFn_createServerFn_handler, async ({ data }) => {
-	const { isCursorRunning, recoverCursorWorkspaceGroup } = await import("./cursor-recovery-nq-kR62j.js");
+	const { isCursorRunning, recoverCursorWorkspaceGroup } = await import("./cursor-recovery-CXpO8KcD.js");
 	const group = await findGroupByKey(data.workspaceKey);
 	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);
@@ -185,7 +185,7 @@ var deleteCursorThreadsFn_createServerFn_handler = createServerRpc({
 	filename: "src/lib/cursor-server.ts"
 }, (opts) => deleteCursorThreadsFn.__executeServer(opts));
 var deleteCursorThreadsFn = createServerFn({ method: "POST" }).validator(deleteThreadsSchema).handler(deleteCursorThreadsFn_createServerFn_handler, async ({ data }) => {
-	const { collectCursorThreadsForDeletion, pruneCursorThreads } = await import("./cursor-recovery-nq-kR62j.js");
+	const { collectCursorThreadsForDeletion, pruneCursorThreads } = await import("./cursor-recovery-CXpO8KcD.js");
 	await ensureCursorClosedForWrite();
 	return pruneCursorThreads(await collectCursorThreadsForDeletion(data.composerIds), true);
 });
@@ -195,8 +195,8 @@ var deleteCursorWorkspaceFn_createServerFn_handler = createServerRpc({
 	filename: "src/lib/cursor-server.ts"
 }, (opts) => deleteCursorWorkspaceFn.__executeServer(opts));
 var deleteCursorWorkspaceFn = createServerFn({ method: "POST" }).validator(workspaceSchema).handler(deleteCursorWorkspaceFn_createServerFn_handler, async ({ data }) => {
-	const { listCursorThreadsForGroup } = await import("./cursor-db-cYZEU3WQ.js");
-	const { collectCursorThreadsForDeletion, pruneCursorThreads } = await import("./cursor-recovery-nq-kR62j.js");
+	const { listCursorThreadsForGroup } = await import("./cursor-db-CZnYy7aT.js");
+	const { collectCursorThreadsForDeletion, pruneCursorThreads } = await import("./cursor-recovery-CXpO8KcD.js");
 	await ensureCursorClosedForWrite();
 	const composerIds = (await listCursorThreadsForGroup(await findGroupByKey(data.workspaceKey), void 0, { includeTranscriptDirs: false })).map((thread) => thread.composerId);
 	if (composerIds.length === 0) return {

package/apps/ui/dist/server/assets/{cursor-threads._composerId-BkMMTQ3v.js → cursor-threads._composerId-Ckn6ItHI.js}

@@ -1,14 +1,14 @@
 import { t as Button } from "./button-CmTDnzOn.js";
 import { i as deleteCursorThreadsFn, o as exportCursorThreadFn, t as cursorThreadDetailQueryOptions } from "./cursor-queries-NCIM0Nat.js";
-import { t as Route } from "./cursor-threads._composerId-BPJFWfJj.js";
+import { t as Route } from "./cursor-threads._composerId-p9-ARAzc.js";
 import { t as Checkbox } from "./checkbox-C0hovF41.js";
 import { t as MetricCard } from "./metric-card-ByEeLu0r.js";
 import { t as PageHeader } from "./page-header-VNSaM3xd.js";
 import { i as formatList, n as formatBytes, o as formatNumber, r as formatDateTime } from "./formatters-FJaGZgJk.js";
-import { a as TranscriptView, c as Breadcrumbs, i as TabsTrigger, n as TabsContent, o as MetadataSection, r as TabsList, s as JsonPanel, t as Tabs } from "./tabs-CGA13IZM.js";
+import { a as TranscriptView, c as Breadcrumbs, i as TabsTrigger, n as TabsContent, o as MetadataSection, r as TabsList, s as JsonPanel, t as Tabs } from "./tabs-DkaChNVg.js";
 import { n as downloadUrlFile, t as downloadTextFile } from "./download-DMmiy1xf.js";
+import { t as ExportDialog } from "./export-dialog-D88ze9Gy.js";
 import { t as DeleteConfirmDialog } from "./delete-confirm-dialog-BcBNCxWB.js";
-import { t as ExportDialog } from "./export-dialog-BItjWgkZ.js";
 import { useMemo, useState } from "react";
 import { Link, useNavigate } from "@tanstack/react-router";
 import { jsx, jsxs } from "react/jsx-runtime";

package/apps/ui/dist/server/assets/{cursor-threads._composerId-BPJFWfJj.js → cursor-threads._composerId-p9-ARAzc.js}

@@ -4,7 +4,7 @@ import { createFileRoute, lazyRouteComponent } from "@tanstack/react-router";
 import { jsx } from "react/jsx-runtime";
 //#region src/routes/cursor-threads.$composerId.tsx
 var $$splitErrorComponentImporter = () => import("./cursor-threads._composerId-BB0Y_Mao.js");
-var $$splitComponentImporter = () => import("./cursor-threads._composerId-BkMMTQ3v.js");
+var $$splitComponentImporter = () => import("./cursor-threads._composerId-Ckn6ItHI.js");
 var Route = createFileRoute("/cursor-threads/$composerId")({
 	component: lazyRouteComponent($$splitComponentImporter, "component"),
 	errorComponent: lazyRouteComponent($$splitErrorComponentImporter, "errorComponent"),