spiracha 2.1.0 → 2.2.0

package/src/lib/grok-transcript.ts

@@ -5,6 +5,7 @@ import type {
     GrokTranscriptEntry,
     GrokTranscriptPart,
 } from './grok-exporter-types';
+import { getFinalGrokAssistantTextPartIds, getGrokTextPartPhase } from './grok-transcript-phase';
 import {
     cleanExtractedText,
     cleanInlineTitle,
@@ -118,9 +119,20 @@ const renderToolResultPart = (part: GrokTranscriptPart, options: GrokExportOptio
     return renderSection('Tool Output', lines.join('\n'), options.outputFormat);
 };
 
-const renderPart = (entry: GrokTranscriptEntry, part: GrokTranscriptPart, options: GrokExportOptions): string => {
+const renderPart = (
+    entry: GrokTranscriptEntry,
+    part: GrokTranscriptPart,
+    options: GrokExportOptions,
+    finalAssistantTextPartIds: Set<string>,
+): string => {
     switch (part.type) {
         case 'text':
+            if (
+                getGrokTextPartPhase(entry, part, finalAssistantTextPartIds) === 'commentary' &&
+                !options.includeCommentary
+            ) {
+                return '';
+            }
             return renderTextPart(entry, part, options);
         case 'reasoning':
             return renderReasoningPart(part, options);
@@ -134,8 +146,9 @@ const renderPart = (entry: GrokTranscriptEntry, part: GrokTranscriptPart, option
 };
 
 export const renderGrokTranscript = (transcript: GrokSessionTranscript, options: GrokExportOptions): string | null => {
+    const finalAssistantTextPartIds = getFinalGrokAssistantTextPartIds(transcript.entries);
     const sections = transcript.entries.flatMap((entry) =>
-        entry.parts.map((part) => renderPart(entry, part, options)).filter(Boolean),
+        entry.parts.map((part) => renderPart(entry, part, options, finalAssistantTextPartIds)).filter(Boolean),
     );
     if (sections.length === 0) {
         return null;

package/src/lib/kiro-db.ts

@@ -1,7 +1,7 @@
-import { createHash } from 'node:crypto';
-import { readdir, rm, stat } from 'node:fs/promises';
+import { createHash, randomUUID } from 'node:crypto';
+import { readdir, rename, rm, stat } from 'node:fs/promises';
 import path from 'node:path';
-import { mapWithConcurrency } from './concurrency';
+import { createConcurrencyLimiter, mapWithConcurrency } from './concurrency';
 import {
     getDefaultKiroDataDir,
     type KiroSessionSummary,
@@ -11,21 +11,26 @@ import {
     type KiroWorkspaceGroup,
     resolveKiroWorkspaceSessionsDir,
 } from './kiro-exporter-types';
+import { getPortablePathBasename } from './portable-path';
 import {
     asObject,
     asString,
     cleanExtractedText,
     cleanInlineTitle,
-    getPortablePathBasename,
     isWorkspacePathQuery,
     type JsonValue,
+    readDirectoryEntriesIfExists,
     workspacePathMatchesQuery,
 } from './shared';
 
 export { getDefaultKiroDataDir, resolveKiroWorkspaceSessionsDir };
 
 const READ_CONCURRENCY = 8;
+const DELETE_CONCURRENCY = 1;
+const EXECUTION_CACHE_TTL_MS = 1_000;
 const WORKSPACE_KEY_PREFIX = 'workspace:';
+const kiroDeleteLimiter = createConcurrencyLimiter(DELETE_CONCURRENCY);
+const executionFilesCache = new Map<string, { expiresAtMs: number; files: KiroExecutionFile[] }>();
 
 type KiroSessionIndexEntry = {
     createdAtMs: number | null;
@@ -87,19 +92,23 @@ const toIso = (value: number | null): string | null => {
     return value === null ? null : new Date(value).toISOString();
 };
 
+const parseTimestampStringMs = (value: string): number | null => {
+    const numeric = Number(value);
+    if (Number.isFinite(numeric)) {
+        return numeric > 0 && numeric < 10_000_000_000 ? numeric * 1000 : numeric;
+    }
+
+    const parsed = Date.parse(value);
+    return Number.isFinite(parsed) ? parsed : null;
+};
+
 const parseTimestampMs = (value: JsonValue | undefined): number | null => {
     if (typeof value === 'number' && Number.isFinite(value)) {
         return value > 0 && value < 10_000_000_000 ? value * 1000 : value;
     }
 
     if (typeof value === 'string') {
-        const numeric = Number(value);
-        if (Number.isFinite(numeric)) {
-            return numeric > 0 && numeric < 10_000_000_000 ? numeric * 1000 : numeric;
-        }
-
-        const parsed = Date.parse(value);
-        return Number.isFinite(parsed) ? parsed : null;
+        return value.trim() ? parseTimestampStringMs(value) : null;
     }
 
     return null;
@@ -288,7 +297,9 @@ const parseHistoryEntry = (raw: Record<string, JsonValue>, index: number): KiroT
         promptLogCount: getPromptLogCount(raw),
         raw,
         role: asString(message.role ?? null) ?? 'message',
-        timestamp: null,
+        timestamp: toIso(
+            parseTimestampMs(raw.timestamp ?? raw.createdAt ?? raw.created_at ?? message.timestamp ?? null),
+        ),
     };
 };
 
@@ -444,7 +455,7 @@ const getKiroWorkspaceHash = (workspacePath: string): string => {
 };
 
 const listFilesRecursively = async (root: string, maxDepth = 3): Promise<string[]> => {
-    const entries = await readdir(root, { withFileTypes: true }).catch(() => []);
+    const entries = await readDirectoryEntriesIfExists(root);
     const files: string[] = [];
 
     for (const entry of entries) {
@@ -472,18 +483,31 @@ const listExecutionFilesForSession = async (
         return [];
     }
 
-    const files = await listFilesRecursively(workspaceExecutionRoot);
-    const executions = await mapWithConcurrency(files, READ_CONCURRENCY, async (filePath) => {
-        const raw = await readJsonObject(filePath);
-        return asString(raw?.chatSessionId ?? null) === sessionId && raw ? { filePath, raw } : null;
-    });
+    const cached = executionFilesCache.get(workspaceExecutionRoot);
+    let executions = cached && cached.expiresAtMs > Date.now() ? cached.files : null;
+    if (!executions) {
+        const files = await listFilesRecursively(workspaceExecutionRoot);
+        executions = (
+            await mapWithConcurrency(files, READ_CONCURRENCY, async (filePath) => {
+                const raw = await readJsonObject(filePath);
+                return raw ? { filePath, raw } : null;
+            })
+        ).flatMap((execution) => (execution ? [execution] : []));
+        executionFilesCache.set(workspaceExecutionRoot, {
+            expiresAtMs: Date.now() + EXECUTION_CACHE_TTL_MS,
+            files: executions,
+        });
+    }
 
-    return executions.flatMap((execution) => (execution ? [execution] : []));
+    return executions.filter((execution) => asString(execution.raw.chatSessionId ?? null) === sessionId);
 };
 
 const getActionTimestamp = (action: Record<string, JsonValue>, execution: Record<string, JsonValue>): string | null => {
     return toIso(
-        parseTimestampMs(action.emittedAt) ?? parseTimestampMs(action.endTime) ?? parseTimestampMs(execution.endTime),
+        parseTimestampMs(action.emittedAt) ??
+            parseTimestampMs(action.endTime) ??
+            parseTimestampMs(execution.endTime) ??
+            parseTimestampMs(execution.startTime),
     );
 };
 
@@ -594,6 +618,7 @@ const parseExecutionActionMessageEntry = (
         raw: {
             ...action,
             executionFilePath: execution.filePath,
+            executionStartTime: execution.raw.startTime ?? null,
         },
         role: 'assistant',
         timestamp: getActionTimestamp(action, execution.raw),
@@ -633,6 +658,7 @@ const parseExecutionActionToolEntry = (
         raw: {
             ...action,
             executionFilePath: execution.filePath,
+            executionStartTime: execution.raw.startTime ?? null,
         },
         role: 'tool',
         timestamp: getActionTimestamp(action, execution.raw),
@@ -678,43 +704,87 @@ const readExecutionEntries = async (
     return executions.sort(compareExecutionFiles).flatMap(parseExecutionEntries);
 };
 
-const getVisibleEntries = (
-    historyEntries: KiroTranscriptEntry[],
-    executionEntries: KiroTranscriptEntry[],
-): KiroTranscriptEntry[] => {
-    if (executionEntries.length === 0) {
-        return historyEntries;
-    }
-
-    const executionEntriesById = new Map<string, KiroTranscriptEntry[]>();
+const groupExecutionEntriesById = (executionEntries: KiroTranscriptEntry[]) => {
+    const entriesById = new Map<string, KiroTranscriptEntry[]>();
     for (const entry of executionEntries) {
         if (!entry.executionId) {
             continue;
         }
 
-        const entries = executionEntriesById.get(entry.executionId) ?? [];
+        const entries = entriesById.get(entry.executionId) ?? [];
         entries.push(entry);
-        executionEntriesById.set(entry.executionId, entries);
+        entriesById.set(entry.executionId, entries);
     }
+    return entriesById;
+};
 
+const replaceExecutionPlaceholders = (
+    historyEntries: KiroTranscriptEntry[],
+    executionEntriesById: Map<string, KiroTranscriptEntry[]>,
+) => {
     const usedExecutionIds = new Set<string>();
     const visibleEntries: KiroTranscriptEntry[] = [];
     for (const entry of historyEntries) {
         const matchingExecutionEntries = entry.executionId ? executionEntriesById.get(entry.executionId) : undefined;
-        if (isAssistantPlaceholderEntry(entry)) {
-            if (matchingExecutionEntries) {
-                visibleEntries.push(...matchingExecutionEntries);
-                usedExecutionIds.add(entry.executionId!);
-            }
+        if (!isAssistantPlaceholderEntry(entry) || !matchingExecutionEntries) {
+            visibleEntries.push(entry);
             continue;
         }
 
-        visibleEntries.push(entry);
+        visibleEntries.push(...matchingExecutionEntries);
+        usedExecutionIds.add(entry.executionId!);
     }
+    return { usedExecutionIds, visibleEntries };
+};
 
-    visibleEntries.push(
-        ...executionEntries.filter((entry) => !entry.executionId || !usedExecutionIds.has(entry.executionId)),
-    );
+const groupUnmatchedExecutionEntries = (executionEntries: KiroTranscriptEntry[], usedExecutionIds: Set<string>) => {
+    const groups = new Map<string, KiroTranscriptEntry[]>();
+    for (const entry of executionEntries) {
+        if (entry.executionId && usedExecutionIds.has(entry.executionId)) {
+            continue;
+        }
+
+        const groupKey = entry.executionId ?? asString(entry.raw.executionFilePath ?? null) ?? entry.entryId;
+        const group = groups.get(groupKey) ?? [];
+        group.push(entry);
+        groups.set(groupKey, group);
+    }
+    return groups.values();
+};
+
+const insertExecutionGroupByStartTime = (
+    visibleEntries: KiroTranscriptEntry[],
+    executionGroup: KiroTranscriptEntry[],
+) => {
+    const firstEntry = executionGroup[0]!;
+    const executionTime = parseTimestampMs(firstEntry.raw.executionStartTime) ?? parseTimestampMs(firstEntry.timestamp);
+    const insertionIndex =
+        executionTime === null
+            ? -1
+            : visibleEntries.findIndex((entry) => {
+                  const entryTime = parseTimestampMs(entry.timestamp);
+                  return entryTime !== null && entryTime > executionTime;
+              });
+    if (insertionIndex < 0) {
+        visibleEntries.push(...executionGroup);
+    } else {
+        visibleEntries.splice(insertionIndex, 0, ...executionGroup);
+    }
+};
+
+const getVisibleEntries = (
+    historyEntries: KiroTranscriptEntry[],
+    executionEntries: KiroTranscriptEntry[],
+): KiroTranscriptEntry[] => {
+    if (executionEntries.length === 0) {
+        return historyEntries;
+    }
+
+    const executionEntriesById = groupExecutionEntriesById(executionEntries);
+    const { usedExecutionIds, visibleEntries } = replaceExecutionPlaceholders(historyEntries, executionEntriesById);
+    for (const executionGroup of groupUnmatchedExecutionEntries(executionEntries, usedExecutionIds)) {
+        insertExecutionGroupByStartTime(visibleEntries, executionGroup);
+    }
     return visibleEntries;
 };
 
@@ -787,7 +857,7 @@ const readSessionFile = async (
 const listSessionFilesForWorkspace = async (sessionsDir: string, directoryName: string): Promise<KiroSessionFile[]> => {
     const workspaceDir = path.join(sessionsDir, directoryName);
     const index = await readSessionIndex(workspaceDir);
-    const entries = await readdir(workspaceDir, { withFileTypes: true }).catch(() => []);
+    const entries = await readDirectoryEntriesIfExists(workspaceDir);
 
     return entries
         .filter((entry) => entry.isFile() && entry.name.endsWith('.json') && entry.name !== 'sessions.json')
@@ -820,7 +890,7 @@ const readSessionFiles = async (files: KiroSessionFile[]): Promise<KiroSessionTr
     const transcripts = await mapWithConcurrency(files, READ_CONCURRENCY, (file) =>
         readSessionFile(file, { includeExecutions: false, sessionsDir: path.dirname(path.dirname(file.filePath)) }),
     );
-    return transcripts.flatMap((transcript) => (transcript ? [transcript] : []));
+    return transcripts.flatMap((transcript) => (transcript && transcript.renderablePartCount > 0 ? [transcript] : []));
 };
 
 const compareNullableMsDesc = (left: number | null, right: number | null): number => {
@@ -934,7 +1004,16 @@ export const listKiroSessionsForGroup = async (
 
 const locateSessionFile = async (sessionsDir: string, sessionId: string): Promise<KiroSessionFile | null> => {
     const files = await listSessionFiles(sessionsDir);
-    return files.find((file) => path.basename(file.filePath, '.json') === sessionId) ?? null;
+    const filenameMatch = files.find((file) => path.basename(file.filePath, '.json') === sessionId);
+    if (filenameMatch) {
+        return filenameMatch;
+    }
+
+    const bodyMatches = await mapWithConcurrency(files, READ_CONCURRENCY, async (file) => {
+        const raw = await readJsonObject(file.filePath);
+        return asString(raw?.sessionId ?? null) === sessionId ? file : null;
+    });
+    return bodyMatches.find((file): file is KiroSessionFile => file !== null) ?? null;
 };
 
 const removeKiroSessionIndexEntry = async (workspaceDir: string, sessionId: string): Promise<void> => {
@@ -951,7 +1030,13 @@ const removeKiroSessionIndexEntry = async (workspaceDir: string, sessionId: stri
         return;
     }
 
-    await Bun.write(indexPath, JSON.stringify(next, null, 2));
+    const tempPath = `${indexPath}.${randomUUID()}.tmp`;
+    try {
+        await Bun.write(tempPath, JSON.stringify(next, null, 2));
+        await rename(tempPath, indexPath);
+    } finally {
+        await rm(tempPath, { force: true });
+    }
 };
 
 export const readKiroSessionTranscript = async (
@@ -970,31 +1055,39 @@ export const readKiroSessionTranscript = async (
     return readSessionFile(file, { includeExecutions: true, sessionsDir });
 };
 
-export const deleteKiroSession = async (sessionsDir: string, sessionId: string): Promise<DeleteKiroSessionResult> => {
-    if (!(await pathExists(sessionsDir))) {
-        return { deletedFiles: [], deletedSessionIds: [] };
-    }
-
-    const file = await locateSessionFile(sessionsDir, sessionId);
-    if (!file) {
-        return { deletedFiles: [], deletedSessionIds: [] };
-    }
+export const deleteKiroSession = (sessionsDir: string, sessionId: string): Promise<DeleteKiroSessionResult> => {
+    return kiroDeleteLimiter(async () => {
+        if (!(await pathExists(sessionsDir))) {
+            return { deletedFiles: [], deletedSessionIds: [] };
+        }
 
-    const transcript = await readSessionFile(file, { includeExecutions: false, sessionsDir });
-    const executionFiles = transcript
-        ? await listExecutionFilesForSession(
-              getKiroDataDirFromSessionsDir(sessionsDir),
-              sessionId,
-              transcript.session.worktree,
-          )
-        : [];
-    const deletedFiles = [file.filePath, ...executionFiles.map((execution) => execution.filePath)];
+        const file = await locateSessionFile(sessionsDir, sessionId);
+        if (!file) {
+            return { deletedFiles: [], deletedSessionIds: [] };
+        }
 
-    await Promise.all(deletedFiles.map((filePath) => rm(filePath, { force: true })));
-    await removeKiroSessionIndexEntry(path.dirname(file.filePath), sessionId);
+        const transcript = await readSessionFile(file, { includeExecutions: false, sessionsDir });
+        const executionFiles = transcript
+            ? await listExecutionFilesForSession(
+                  getKiroDataDirFromSessionsDir(sessionsDir),
+                  sessionId,
+                  transcript.session.worktree,
+              )
+            : [];
+        const deletedFiles = [file.filePath, ...executionFiles.map((execution) => execution.filePath)];
+
+        await Promise.all(deletedFiles.map((filePath) => rm(filePath, { force: true })));
+        executionFilesCache.delete(
+            path.join(
+                getKiroDataDirFromSessionsDir(sessionsDir),
+                getKiroWorkspaceHash(transcript?.session.worktree ?? ''),
+            ),
+        );
+        await removeKiroSessionIndexEntry(path.dirname(file.filePath), sessionId);
 
-    return {
-        deletedFiles,
-        deletedSessionIds: [sessionId],
-    };
+        return {
+            deletedFiles,
+            deletedSessionIds: [sessionId],
+        };
+    });
 };

package/src/lib/kiro-transcript.ts

@@ -61,10 +61,6 @@ const renderTextPart = (part: KiroTranscriptPart, title: string, options: KiroEx
 };
 
 const renderImagePart = (part: KiroTranscriptPart, options: KiroExportOptions): string => {
-    if (!options.includeCommentary) {
-        return '';
-    }
-
     const text = cleanExtractedText(part.text ?? 'Image attachment').trim();
     return renderSection('Attachment', text, options.outputFormat);
 };

package/src/lib/opencode-db.ts

@@ -24,6 +24,7 @@ import {
     asString,
     isWorkspacePathQuery,
     type JsonValue,
+    pathExists,
     workspacePathMatchesQuery,
 } from './shared';
 import { runWithSqliteRetry } from './sqlite-retry';
@@ -120,7 +121,7 @@ const openCodeDbLimiter = createConcurrencyLimiter(resolveOpenCodeDbConcurrency(
 const openCodeDesktopStateLimiter = createConcurrencyLimiter(1);
 
 const logOpenCodeDb = (event: string, details: Record<string, unknown>) => {
-    if (process.env.SPIRACHA_OPENCODE_DB_LOGS !== '0') {
+    if (process.env.SPIRACHA_OPENCODE_DB_LOGS === '1') {
         console.info(`[spiracha:opencode-db] ${event}`, details);
     }
 };
@@ -185,12 +186,6 @@ const getDefaultOpenCodeDesktopStateDir = (
         : null;
 };
 
-const pathExists = async (target: string): Promise<boolean> => {
-    return await stat(target)
-        .then(() => true)
-        .catch(() => false);
-};
-
 export const getOpenCodeReadDbUri = (dbPath: string, mode: 'ro' | 'rw' = 'rw'): string => {
     const url = pathToFileURL(dbPath);
     url.searchParams.set('mode', mode);
@@ -1014,12 +1009,13 @@ const parseTextOpenCodePart = (base: BaseOpenCodePart): OpenCodeTranscriptPart =
 
 const parseToolOpenCodePart = (base: BaseOpenCodePart): OpenCodeTranscriptPart => {
     const state = asObject(base.raw.state ?? null);
+    const metadata = asObject(state?.metadata ?? null);
     return {
         ...base,
         argumentsText: formatJsonLike(state?.input),
         callId: asString(base.raw.callID ?? null) ?? asString(base.raw.callId ?? null),
         endTimeMs: parseToolTimeMs(base.raw, 'end'),
-        outputText: formatJsonLike(state?.output),
+        outputText: formatJsonLike(state?.output ?? metadata?.output ?? state?.error),
         startTimeMs: parseToolTimeMs(base.raw, 'start'),
         status: asString(state?.status ?? null),
         title: asString(state?.title ?? null),

package/src/lib/opencode-think-tags.ts

@@ -27,9 +27,23 @@ const findClosingBackticks = (text: string, start: number, runLength: number): n
 };
 
 const findThinkCloseIndex = (text: string, start: number): number => {
-    THINK_CLOSE_PATTERN.lastIndex = start;
-    const match = THINK_CLOSE_PATTERN.exec(text);
-    return match ? match.index : -1;
+    let cursor = start;
+    while (cursor < text.length) {
+        THINK_CLOSE_PATTERN.lastIndex = cursor;
+        const match = THINK_CLOSE_PATTERN.exec(text);
+        if (!match) {
+            return -1;
+        }
+
+        const backtickIndex = text.indexOf('`', cursor);
+        if (backtickIndex === -1 || backtickIndex >= match.index) {
+            return match.index;
+        }
+
+        cursor = findClosingBackticks(text, backtickIndex, getBacktickRunLength(text, backtickIndex));
+    }
+
+    return -1;
 };
 
 const getLastVisibleChar = (parts: string[]): string => {

package/src/lib/portable-path.ts

@@ -0,0 +1,9 @@
+export const getPortablePathBasename = (value: string): string => {
+    const trimmed = value.replace(/[\\/]+$/u, '');
+    if (!trimmed) {
+        return '';
+    }
+
+    const separatorIndex = Math.max(trimmed.lastIndexOf('/'), trimmed.lastIndexOf('\\'));
+    return separatorIndex === -1 ? trimmed : trimmed.slice(separatorIndex + 1);
+};

package/src/lib/qoder-acp-client.ts

@@ -9,6 +9,7 @@ const INITIALIZE_REQUEST_ID = 1;
 const LOAD_REQUEST_ID = 2;
 
 type JsonRpcMessage = {
+    error?: JsonValue;
     id?: number;
     jsonrpc?: '2.0';
     method?: string;
@@ -16,6 +17,14 @@ type JsonRpcMessage = {
     result?: JsonValue;
 };
 
+export const isQoderAcpResponse = (message: JsonRpcMessage, requestId: number) => {
+    return (
+        message.id === requestId &&
+        message.method === undefined &&
+        (Object.hasOwn(message, 'result') || Object.hasOwn(message, 'error'))
+    );
+};
+
 export type QoderAcpSessionUpdate = {
     requestId: string | null;
     sessionId: string;
@@ -207,7 +216,7 @@ export const loadQoderAcpSession = async (
         };
 
         const markLoadCompleted = (message: JsonRpcMessage) => {
-            if (message.id !== LOAD_REQUEST_ID || loadCompleted) {
+            if (!isQoderAcpResponse(message, LOAD_REQUEST_ID) || loadCompleted) {
                 return false;
             }
 
@@ -221,7 +230,7 @@ export const loadQoderAcpSession = async (
         };
 
         const handleMessage = (message: JsonRpcMessage) => {
-            if (message.id === INITIALIZE_REQUEST_ID) {
+            if (isQoderAcpResponse(message, INITIALIZE_REQUEST_ID)) {
                 sendLoadRequest();
                 return;
             }

package/src/lib/qoder-db.ts

@@ -2,6 +2,7 @@ import { Database } from 'bun:sqlite';
 import { readdir, stat } from 'node:fs/promises';
 import path from 'node:path';
 import { mapWithConcurrency } from './concurrency';
+import { getPortablePathBasename } from './portable-path';
 import { loadQoderAcpSession, type QoderAcpSessionUpdate, resolveQoderAcpSocketPath } from './qoder-acp-client';
 import {
     getDefaultQoderUserDir,
@@ -14,16 +15,18 @@ import {
     resolveQoderGlobalStateDb,
     resolveQoderWorkspaceStorageDir,
 } from './qoder-exporter-types';
+import { coalesceQoderMessageChunks } from './qoder-transcript-phase';
 import {
     asObject,
     asString,
     cleanExtractedText,
     cleanInlineTitle,
-    getPortablePathBasename,
     isWorkspacePathQuery,
     type JsonValue,
+    toFileUri,
     workspacePathMatchesQuery,
 } from './shared';
+import { runWithSqliteRetry } from './sqlite-retry';
 
 export {
     getDefaultQoderUserDir,
@@ -202,7 +205,7 @@ const getWorkspaceLabel = (worktree: string): string => {
 };
 
 const getWorkspaceUri = (worktree: string): string => {
-    return worktree.startsWith(path.sep) ? `file://${worktree}` : worktree;
+    return worktree.startsWith(path.sep) ? toFileUri(worktree) : worktree;
 };
 
 const parseJsonValue = (value: string): JsonValue | null => {
@@ -213,23 +216,50 @@ const parseJsonValue = (value: string): JsonValue | null => {
     }
 };
 
+export const isUnavailableQoderGlobalStateError = (error: unknown): boolean => {
+    if (!(error instanceof Error)) {
+        return false;
+    }
+
+    const code = 'code' in error && typeof error.code === 'string' ? error.code : '';
+    return (
+        code === 'SQLITE_CANTOPEN' ||
+        code === 'SQLITE_IOERR_READ' ||
+        /^(?:SQLite operation failed after \d+ attempts?:\s*)?(?:SQLITE_CANTOPEN:.*|unable to open database file)$/iu.test(
+            error.message,
+        )
+    );
+};
+
 const readGlobalRows = async (globalStateDb = resolveQoderGlobalStateDb()): Promise<ItemTableRow[]> => {
-    if (!(await pathExists(globalStateDb))) {
+    const isDatabaseFile = await stat(globalStateDb)
+        .then((metadata) => metadata.isFile())
+        .catch(() => false);
+    if (!isDatabaseFile) {
         return [];
     }
 
-    let db: Database | null = null;
     try {
-        db = new Database(globalStateDb, { readonly: true, strict: true });
-        return db
-            .query(
-                "select key, value from ItemTable where key like 'lingma.chat.localHistory.%.quest' or key = 'aicoding.questTaskListSnapshot' or key in ('aicoding.modelConfigs.cache.assistant', 'aicoding.modelConfigs.cache.quest')",
-            )
-            .all() as ItemTableRow[];
-    } catch {
-        return [];
-    } finally {
-        db?.close();
+        return runWithSqliteRetry({
+            action: () => {
+                const db = new Database(globalStateDb, { readonly: true, strict: true });
+                try {
+                    db.exec('PRAGMA busy_timeout = 1000');
+                    return db
+                        .query(
+                            "select key, value from ItemTable where key like 'lingma.chat.localHistory.%.quest' or key = 'aicoding.questTaskListSnapshot' or key in ('aicoding.modelConfigs.cache.assistant', 'aicoding.modelConfigs.cache.quest')",
+                        )
+                        .all() as ItemTableRow[];
+                } finally {
+                    db.close();
+                }
+            },
+        });
+    } catch (error) {
+        if (isUnavailableQoderGlobalStateError(error)) {
+            return [];
+        }
+        throw error;
     }
 };
 
@@ -800,6 +830,7 @@ const readRecordSummary = async (
     modelFallback: string | null,
 ): Promise<QoderSessionSummary> => {
     const state = await readStateData(workspaceStorageDir, workspaceStorageIds, record);
+    // List stats describe persisted Qoder state only; detail reads may additionally hydrate CLI or live ACP messages.
     const entries = buildLocalTranscriptEntries(record, state);
     const stats = createStatsFromEntries(entries, state.snapshotFileCount);
     return toSessionSummary(record, state, stats, modelFallback);
@@ -1128,6 +1159,7 @@ const cliToolCallPartToTranscriptPart = (part: Record<string, JsonValue>): Qoder
               raw: {
                   ...part,
                   command: text,
+                  toolCallId: asString(data.id ?? data.tool_use_id ?? part.id ?? part.tool_use_id ?? null),
                   toolName: getCliToolName(part, data),
               },
               role: 'tool',
@@ -1494,9 +1526,11 @@ const readAcpTranscriptEntries = async (
     }
 
     return {
-        entries: loaded.events
-            .map((event, index) => acpUpdateToEntry(event, index))
-            .filter((entry): entry is QoderTranscriptEntry => Boolean(entry)),
+        entries: coalesceQoderMessageChunks(
+            loaded.events
+                .map((event, index) => acpUpdateToEntry(event, index))
+                .filter((entry): entry is QoderTranscriptEntry => Boolean(entry)),
+        ),
         model: getAcpModel(loaded.events),
         socketPath: loaded.socketPath,
     };