spiracha 2.0.0 → 2.2.0

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

@@ -1,6 +1,6 @@
 import { createServerFn } from '@tanstack/react-start';
 import { z } from 'zod';
-import { renderSourceSessionDownload } from './source-session-export-server';
+import { renderSourceSessionDownload, renderSourceSessionsDownload } from './source-session-export-server';
 
 const workspaceSchema = z.object({
     workspaceKey: z.string().min(1),
@@ -19,6 +19,15 @@ const exportSessionSchema = z.object({
     zipArchive: z.boolean().default(false),
 });
 
+const exportSessionsSchema = z.object({
+    includeCommentary: z.boolean().default(true),
+    includeMetadata: z.boolean().default(true),
+    includeTools: z.boolean().default(true),
+    outputFormat: z.enum(['md', 'txt']).default('md'),
+    sessionIds: z.array(z.string().min(1)).min(1),
+    zipArchive: z.boolean().default(true),
+});
+
 export const listQoderWorkspacesFn = createServerFn({ method: 'GET' }).handler(async () => {
     const { listQoderWorkspaceGroups } = await import('@spiracha/lib/qoder-db');
     return listQoderWorkspaceGroups();
@@ -32,19 +41,27 @@ export const listQoderSessionsFn = createServerFn({ method: 'GET' })
     });
 
 const loadQoderSessionTranscript = async (sessionId: string) => {
+    const { runWithTranscriptLoadLimit } = await import('@spiracha/lib/transcript-load-limiter');
     const { readQoderSessionTranscript, resolveQoderGlobalStateDb, resolveQoderWorkspaceStorageDir } = await import(
         '@spiracha/lib/qoder-db'
     );
-    const transcript = await readQoderSessionTranscript(
-        resolveQoderGlobalStateDb(),
-        resolveQoderWorkspaceStorageDir(),
-        sessionId,
-    );
-    if (!transcript) {
-        throw new Error(`Qoder session not found: ${sessionId}`);
-    }
+    const globalStateDb = resolveQoderGlobalStateDb();
+    const workspaceStorageDir = resolveQoderWorkspaceStorageDir();
+    return runWithTranscriptLoadLimit(
+        async () => {
+            const transcript = await readQoderSessionTranscript(globalStateDb, workspaceStorageDir, sessionId);
+            if (!transcript) {
+                throw new Error(`Qoder session not found: ${sessionId}`);
+            }
 
-    return transcript;
+            return transcript;
+        },
+        {
+            id: sessionId,
+            path: globalStateDb,
+            source: 'qoder-ui',
+        },
+    );
 };
 
 export const getQoderSessionDetailFn = createServerFn({ method: 'GET' })
@@ -71,8 +88,47 @@ export const exportQoderSessionFn = createServerFn({ method: 'POST' })
 
         return renderSourceSessionDownload({
             content,
+            cwd: transcript.session.workspacePath ?? transcript.session.worktree,
             fallbackBaseName: 'qoder-session',
-            fileBaseName: transcript.session.title || transcript.session.sessionId,
+            outputFormat: data.outputFormat,
+            sessionId: transcript.session.sessionId,
+            updatedAtMs: transcript.session.lastActiveAtMs,
+            zipArchive: data.zipArchive,
+        });
+    });
+
+export const exportQoderSessionsFn = createServerFn({ method: 'POST' })
+    .validator(exportSessionsSchema)
+    .handler(async ({ data }) => {
+        const { renderQoderTranscript } = await import('@spiracha/lib/qoder-transcript');
+        const entries = await Promise.all(
+            data.sessionIds.map(async (sessionId) => {
+                const transcript = await loadQoderSessionTranscript(sessionId);
+                const content = renderQoderTranscript(transcript, {
+                    includeCommentary: data.includeCommentary,
+                    includeMetadata: data.includeMetadata,
+                    includeTools: data.includeTools,
+                    outputFormat: data.outputFormat,
+                });
+
+                if (!content) {
+                    throw new Error(`Qoder session has no exportable content: ${sessionId}`);
+                }
+
+                return {
+                    content,
+                    cwd: transcript.session.workspacePath ?? transcript.session.worktree,
+                    fallbackBaseName: 'qoder-session',
+                    fileBaseName: transcript.session.title || transcript.session.sessionId,
+                    sessionId: transcript.session.sessionId,
+                    updatedAtMs: transcript.session.lastActiveAtMs,
+                };
+            }),
+        );
+
+        return renderSourceSessionsDownload({
+            entries,
+            fallbackBaseName: 'qoder-sessions',
             outputFormat: data.outputFormat,
             zipArchive: data.zipArchive,
         });

package/apps/ui/src/lib/qoder-transcript-events.ts

@@ -57,7 +57,7 @@ const buildToolCallEvent = (
 ): ThreadEvent => ({
     argumentsParseFailed: false,
     argumentsText: command,
-    callId: entry.entryId,
+    callId: getPartString(part, 'toolCallId') ?? entry.entryId,
     command,
     kind: 'tool_call',
     name: getPartString(part, 'toolName') ?? 'qoder_file_operation',

package/apps/ui/src/lib/route-search.ts

@@ -6,6 +6,16 @@ export type AnalyticsSearch = {
     project?: string;
 };
 
+export type ThreadTranscriptSearch = {
+    commentary?: boolean;
+    extra?: boolean;
+    q?: string;
+    raw?: boolean;
+    sort?: 'earliest' | 'latest';
+    tools?: boolean;
+    user?: boolean;
+};
+
 type SearchRecord = Record<string, unknown>;
 
 const asNonBlankString = (value: unknown) => {
@@ -27,6 +37,110 @@ export const parseAnalyticsSearch = (search: SearchRecord): AnalyticsSearch => {
     return project ? { project } : {};
 };
 
+const asBooleanSearch = (value: unknown) => {
+    if (value === true || value === 'true' || value === '1') {
+        return true;
+    }
+
+    if (value === false || value === 'false' || value === '0') {
+        return false;
+    }
+
+    return undefined;
+};
+
+const setBooleanSearchParam = (target: SearchRecord, key: keyof ThreadTranscriptSearch, value: boolean) => {
+    if (value) {
+        target[key] = true;
+        return;
+    }
+
+    delete target[key];
+};
+
+const setTextSearchParam = (target: SearchRecord, key: keyof ThreadTranscriptSearch, value: string | undefined) => {
+    const trimmed = asNonBlankString(value);
+    if (trimmed) {
+        target[key] = trimmed;
+        return;
+    }
+
+    delete target[key];
+};
+
+const setThreadSortSearchParam = (target: SearchRecord, value: ThreadTranscriptSearch['sort']) => {
+    if (value === 'latest') {
+        target.sort = 'latest';
+        return;
+    }
+
+    delete target.sort;
+};
+
+export const parseThreadTranscriptSearch = (search: SearchRecord): ThreadTranscriptSearch => {
+    const q = asNonBlankString(search.q);
+    const sort = search.sort === 'latest' ? 'latest' : undefined;
+    const parsed: ThreadTranscriptSearch = q ? { q } : {};
+    const tools = asBooleanSearch(search.tools);
+    const commentary = asBooleanSearch(search.commentary);
+    const extra = asBooleanSearch(search.extra);
+    const raw = asBooleanSearch(search.raw);
+    const user = asBooleanSearch(search.user);
+
+    if (tools) {
+        parsed.tools = true;
+    }
+    if (commentary) {
+        parsed.commentary = true;
+    }
+    if (extra) {
+        parsed.extra = true;
+    }
+    if (raw) {
+        parsed.raw = true;
+    }
+    if (user) {
+        parsed.user = true;
+    }
+    if (sort) {
+        parsed.sort = sort;
+    }
+
+    return parsed;
+};
+
+export const withThreadTranscriptSearch = (
+    current: SearchRecord,
+    patch: Partial<ThreadTranscriptSearch>,
+): SearchRecord & ThreadTranscriptSearch => {
+    const next = { ...current };
+
+    if ('q' in patch) {
+        setTextSearchParam(next, 'q', patch.q);
+    }
+    if ('sort' in patch) {
+        setThreadSortSearchParam(next, patch.sort);
+    }
+
+    if ('tools' in patch && typeof patch.tools === 'boolean') {
+        setBooleanSearchParam(next, 'tools', patch.tools);
+    }
+    if ('commentary' in patch && typeof patch.commentary === 'boolean') {
+        setBooleanSearchParam(next, 'commentary', patch.commentary);
+    }
+    if ('extra' in patch && typeof patch.extra === 'boolean') {
+        setBooleanSearchParam(next, 'extra', patch.extra);
+    }
+    if ('raw' in patch && typeof patch.raw === 'boolean') {
+        setBooleanSearchParam(next, 'raw', patch.raw);
+    }
+    if ('user' in patch && typeof patch.user === 'boolean') {
+        setBooleanSearchParam(next, 'user', patch.user);
+    }
+
+    return next as SearchRecord & ThreadTranscriptSearch;
+};
+
 export const withTextQuerySearch = (current: SearchRecord, query: string): SearchRecord & TextQuerySearch => {
     const next = { ...current };
     const q = asNonBlankString(query);

package/apps/ui/src/lib/route-state-reset.tsx

@@ -0,0 +1,10 @@
+import { Fragment, type ReactNode } from 'react';
+
+type RouteStateResetBoundaryProps = {
+    children: ReactNode;
+    routeKey: string;
+};
+
+export const RouteStateResetBoundary = ({ children, routeKey }: RouteStateResetBoundaryProps) => {
+    return <Fragment key={routeKey}>{children}</Fragment>;
+};

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

@@ -0,0 +1,33 @@
+import { createServerFn } from '@tanstack/react-start';
+import { getCookie, setCookie } from '@tanstack/react-start/server';
+import { z } from 'zod';
+import { parseSerializedSettings, SETTINGS_COOKIE_NAME, serializeSettings } from '#/lib/settings';
+
+const exportDefaultsSchema = z.object({
+    includeCommentary: z.boolean(),
+    includeMetadata: z.boolean(),
+    includeTools: z.boolean(),
+    outputFormat: z.enum(['md', 'txt']),
+    zipArchive: z.boolean(),
+});
+
+const settingsSchema = z.object({
+    convertToProjectRoot: z.boolean(),
+    exportDefaults: exportDefaultsSchema,
+    redactUsername: z.boolean(),
+});
+
+export const getInitialSettingsFn = createServerFn({ method: 'GET' }).handler(async () =>
+    parseSerializedSettings(getCookie(SETTINGS_COOKIE_NAME)),
+);
+
+export const saveSettingsFn = createServerFn({ method: 'POST' })
+    .validator(settingsSchema)
+    .handler(async ({ data }) => {
+        setCookie(SETTINGS_COOKIE_NAME, serializeSettings(data), {
+            httpOnly: true,
+            maxAge: 60 * 60 * 24 * 365,
+            path: '/',
+            sameSite: 'lax',
+        });
+    });

package/apps/ui/src/lib/settings-store.tsx

@@ -1,59 +1,103 @@
-import type { ReactNode } from 'react';
-import { createContext, useContext, useEffect, useState } from 'react';
-
-export type Settings = {
-    convertToProjectRoot: boolean;
-    redactUsername: boolean;
-};
+import { createContext, type ReactNode, useCallback, useContext, useEffect, useMemo, useRef, useState } from 'react';
+import { DEFAULT_SETTINGS, normalizeSettings, type Settings } from '#/lib/settings';
+import { getInitialSettingsFn, saveSettingsFn } from '#/lib/settings-server';
 
 type SettingsContextValue = {
     settings: Settings;
     updateSetting: <K extends keyof Settings>(key: K, value: Settings[K]) => void;
 };
 
-const STORAGE_KEY = 'spiracha-settings';
-
-const defaultSettings: Settings = {
-    convertToProjectRoot: false,
-    redactUsername: false,
-};
+const SETTINGS_CHANNEL_NAME = 'spiracha-settings';
 
 const SettingsContext = createContext<SettingsContextValue>({
-    settings: defaultSettings,
+    settings: DEFAULT_SETTINGS,
     updateSetting: () => {},
 });
 
-const loadSettings = (): Settings => {
-    if (typeof window === 'undefined') {
-        return defaultSettings;
-    }
-    try {
-        const stored = window.localStorage.getItem(STORAGE_KEY);
-        return stored ? { ...defaultSettings, ...(JSON.parse(stored) as Partial<Settings>) } : defaultSettings;
-    } catch {
-        return defaultSettings;
-    }
-};
-
-export function SettingsProvider({ children }: { children: ReactNode }) {
-    const [settings, setSettings] = useState<Settings>(defaultSettings);
+export function SettingsProvider({
+    children,
+    initialSettings = DEFAULT_SETTINGS,
+}: {
+    children: ReactNode;
+    initialSettings?: Settings;
+}) {
+    const [settings, setSettings] = useState(initialSettings);
+    const channelRef = useRef<BroadcastChannel | null>(null);
+    const pendingSaveCountRef = useRef(0);
+    const settingsRef = useRef(initialSettings);
+    const settingsRevisionRef = useRef(0);
+    const synchronizationRequestRef = useRef(0);
+    const persistenceQueueRef = useRef(Promise.resolve());
 
-    // Load from localStorage on mount (client only — avoids SSR hydration mismatch)
     useEffect(() => {
-        setSettings(loadSettings());
+        const synchronizeFromCookie = () => {
+            const hadPendingSave = pendingSaveCountRef.current > 0;
+            const requestId = synchronizationRequestRef.current + 1;
+            const revision = settingsRevisionRef.current;
+            synchronizationRequestRef.current = requestId;
+            void getInitialSettingsFn()
+                .then((savedSettings) => {
+                    if (
+                        hadPendingSave ||
+                        pendingSaveCountRef.current > 0 ||
+                        requestId !== synchronizationRequestRef.current ||
+                        revision !== settingsRevisionRef.current
+                    ) {
+                        return;
+                    }
+                    settingsRef.current = savedSettings;
+                    setSettings(savedSettings);
+                })
+                .catch((error: unknown) => {
+                    console.error('[spiracha:settings] synchronization failed', {
+                        error: error instanceof Error ? error.message : String(error),
+                    });
+                });
+        };
+        const channel = typeof BroadcastChannel === 'undefined' ? null : new BroadcastChannel(SETTINGS_CHANNEL_NAME);
+        if (channel) {
+            channel.onmessage = (event: MessageEvent<unknown>) => {
+                if (pendingSaveCountRef.current > 0) {
+                    return;
+                }
+                const synchronizedSettings = normalizeSettings(event.data);
+                settingsRevisionRef.current += 1;
+                settingsRef.current = synchronizedSettings;
+                setSettings(synchronizedSettings);
+            };
+            channelRef.current = channel;
+        }
+        window.addEventListener('focus', synchronizeFromCookie);
+
+        return () => {
+            window.removeEventListener('focus', synchronizeFromCookie);
+            channel?.close();
+            channelRef.current = null;
+        };
     }, []);
 
-    const updateSetting = <K extends keyof Settings>(key: K, value: Settings[K]) => {
-        setSettings((prev) => {
-            const next = { ...prev, [key]: value };
+    const updateSetting = useCallback(<K extends keyof Settings>(key: K, value: Settings[K]) => {
+        const nextSettings = { ...settingsRef.current, [key]: value };
+        pendingSaveCountRef.current += 1;
+        settingsRevisionRef.current += 1;
+        settingsRef.current = nextSettings;
+        setSettings(nextSettings);
+        persistenceQueueRef.current = persistenceQueueRef.current.then(async () => {
             try {
-                localStorage.setItem(STORAGE_KEY, JSON.stringify(next));
-            } catch {}
-            return next;
+                await saveSettingsFn({ data: nextSettings });
+                channelRef.current?.postMessage(nextSettings);
+            } catch (error) {
+                console.error('[spiracha:settings] persistence failed', {
+                    error: error instanceof Error ? error.message : String(error),
+                });
+            } finally {
+                pendingSaveCountRef.current -= 1;
+            }
         });
-    };
+    }, []);
+    const contextValue = useMemo(() => ({ settings, updateSetting }), [settings, updateSetting]);
 
-    return <SettingsContext.Provider value={{ settings, updateSetting }}>{children}</SettingsContext.Provider>;
+    return <SettingsContext.Provider value={contextValue}>{children}</SettingsContext.Provider>;
 }
 
 export const useSettings = () => useContext(SettingsContext);

package/apps/ui/src/lib/settings.ts

@@ -0,0 +1,65 @@
+import { DEFAULT_EXPORT_DIALOG_OPTIONS, type ExportDialogOptions } from '#/lib/export-options';
+
+export type Settings = {
+    convertToProjectRoot: boolean;
+    exportDefaults: ExportDialogOptions;
+    redactUsername: boolean;
+};
+
+export const SETTINGS_COOKIE_NAME = 'spiracha-settings';
+
+export const DEFAULT_SETTINGS: Settings = {
+    convertToProjectRoot: false,
+    exportDefaults: DEFAULT_EXPORT_DIALOG_OPTIONS,
+    redactUsername: false,
+};
+
+const asRecord = (value: unknown): Record<string, unknown> | null =>
+    value !== null && typeof value === 'object' && !Array.isArray(value) ? (value as Record<string, unknown>) : null;
+
+const booleanOrDefault = (value: unknown, fallback: boolean) => (typeof value === 'boolean' ? value : fallback);
+
+const parseExportDefaults = (value: unknown): ExportDialogOptions => {
+    const record = asRecord(value);
+    if (!record) {
+        return DEFAULT_EXPORT_DIALOG_OPTIONS;
+    }
+
+    return {
+        includeCommentary: booleanOrDefault(record.includeCommentary, DEFAULT_EXPORT_DIALOG_OPTIONS.includeCommentary),
+        includeMetadata: booleanOrDefault(record.includeMetadata, DEFAULT_EXPORT_DIALOG_OPTIONS.includeMetadata),
+        includeTools: booleanOrDefault(record.includeTools, DEFAULT_EXPORT_DIALOG_OPTIONS.includeTools),
+        outputFormat:
+            record.outputFormat === 'txt' || record.outputFormat === 'md'
+                ? record.outputFormat
+                : DEFAULT_EXPORT_DIALOG_OPTIONS.outputFormat,
+        zipArchive: booleanOrDefault(record.zipArchive, DEFAULT_EXPORT_DIALOG_OPTIONS.zipArchive),
+    };
+};
+
+export const normalizeSettings = (value: unknown): Settings => {
+    const record = asRecord(value);
+    if (!record) {
+        return DEFAULT_SETTINGS;
+    }
+
+    return {
+        convertToProjectRoot: booleanOrDefault(record.convertToProjectRoot, DEFAULT_SETTINGS.convertToProjectRoot),
+        exportDefaults: parseExportDefaults(record.exportDefaults),
+        redactUsername: booleanOrDefault(record.redactUsername, DEFAULT_SETTINGS.redactUsername),
+    };
+};
+
+export const parseSerializedSettings = (serialized: string | null | undefined): Settings => {
+    if (!serialized) {
+        return DEFAULT_SETTINGS;
+    }
+
+    try {
+        return normalizeSettings(JSON.parse(decodeURIComponent(serialized)));
+    } catch {
+        return DEFAULT_SETTINGS;
+    }
+};
+
+export const serializeSettings = (settings: Settings) => JSON.stringify(settings);

package/apps/ui/src/lib/source-session-export-server.ts

@@ -2,15 +2,40 @@ import { randomUUID } from 'node:crypto';
 import { mkdtemp, rm } from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
-import { getExportMimeType, sanitizeExportFileName, zipExportDirectory } from '@spiracha/lib/ui-export-archive';
+import {
+    buildBatchExportBaseName,
+    buildConversationExportBaseName,
+    getExportMimeType,
+    resolveUniqueExportFileBaseName,
+    sanitizeExportFileName,
+} from '@spiracha/lib/ui-export-archive';
 import { buildUiExportDownloadUrl, ensureUiExportDir } from '@spiracha/lib/ui-export-files';
+import { zipExportDirectory } from '@spiracha/lib/ui-export-zip';
 
 type ExportFormat = 'md' | 'txt';
 
 type RenderSourceSessionDownloadOptions = {
     content: string;
+    cwd: string | null;
+    fallbackBaseName: string;
+    outputFormat: ExportFormat;
+    sessionId: string;
+    updatedAtMs: number | null;
+    zipArchive: boolean;
+};
+
+type RenderedSourceSession = {
+    content: string;
+    cwd: string | null;
     fallbackBaseName: string;
     fileBaseName: string;
+    sessionId: string;
+    updatedAtMs: number | null;
+};
+
+type RenderSourceSessionsDownloadOptions = {
+    entries: RenderedSourceSession[];
+    fallbackBaseName: string;
     outputFormat: ExportFormat;
     zipArchive: boolean;
 };
@@ -21,12 +46,21 @@ export const toSafeSourceExportName = (value: string, fallback: string) => {
 
 export const renderSourceSessionDownload = async ({
     content,
+    cwd,
     fallbackBaseName,
-    fileBaseName,
     outputFormat,
+    sessionId,
+    updatedAtMs,
     zipArchive,
 }: RenderSourceSessionDownloadOptions) => {
-    const safeBaseName = toSafeSourceExportName(fileBaseName, fallbackBaseName);
+    const safeBaseName = buildConversationExportBaseName(
+        {
+            cwd,
+            id: sessionId,
+            updatedAtMs,
+        },
+        fallbackBaseName,
+    );
     if (!zipArchive) {
         return {
             content,
@@ -54,3 +88,52 @@ export const renderSourceSessionDownload = async ({
         mode: 'download_url' as const,
     };
 };
+
+export const renderSourceSessionsDownload = async ({
+    entries,
+    fallbackBaseName,
+    outputFormat,
+    zipArchive,
+}: RenderSourceSessionsDownloadOptions) => {
+    if (entries.length === 0) {
+        throw new Error('No transcripts selected for export');
+    }
+
+    if (entries.length === 1) {
+        const entry = entries[0]!;
+        return renderSourceSessionDownload({
+            content: entry.content,
+            cwd: entry.cwd,
+            fallbackBaseName: entry.fallbackBaseName,
+            outputFormat,
+            sessionId: entry.sessionId,
+            updatedAtMs: entry.updatedAtMs,
+            zipArchive,
+        });
+    }
+
+    const safeBaseName = buildBatchExportBaseName(entries, fallbackBaseName);
+    const exportDir = await ensureUiExportDir();
+    const workspaceDir = await mkdtemp(path.join(os.tmpdir(), `${safeBaseName}-`));
+    const zipPath = path.join(exportDir, `${safeBaseName}-${randomUUID()}.zip`);
+    const usedBaseNames = new Map<string, number>();
+
+    try {
+        for (const entry of entries) {
+            const baseName = toSafeSourceExportName(entry.fileBaseName, entry.fallbackBaseName);
+            const fileBaseName = resolveUniqueExportFileBaseName(baseName, usedBaseNames);
+            await Bun.write(path.join(workspaceDir, `${fileBaseName}.${outputFormat}`), entry.content);
+        }
+
+        await zipExportDirectory(workspaceDir, zipPath);
+    } finally {
+        await rm(workspaceDir, { force: true, recursive: true });
+    }
+
+    return {
+        downloadUrl: buildUiExportDownloadUrl(zipPath),
+        fileName: `${safeBaseName}.zip`,
+        mimeType: 'application/zip',
+        mode: 'download_url' as const,
+    };
+};

package/apps/ui/src/lib/thread-metadata.ts

@@ -0,0 +1,22 @@
+const humanizePolicy = (value: string) => value.replaceAll(/[-_]+/gu, ' ');
+
+export const formatSandboxPolicy = (serializedPolicy: string) => {
+    const trimmed = serializedPolicy.trim();
+    if (!trimmed) {
+        return 'n/a';
+    }
+
+    try {
+        const parsed = JSON.parse(trimmed) as unknown;
+        if (typeof parsed === 'string') {
+            return humanizePolicy(parsed);
+        }
+        if (parsed && typeof parsed === 'object' && 'type' in parsed && typeof parsed.type === 'string') {
+            return humanizePolicy(parsed.type);
+        }
+    } catch {
+        return humanizePolicy(trimmed);
+    }
+
+    return humanizePolicy(trimmed);
+};

package/apps/ui/src/lib/thread-transcript-load.ts

@@ -0,0 +1,15 @@
+type TranscriptLoadState = {
+    isPartial: boolean;
+} | null;
+
+export const shouldLoadFullThreadTranscript = ({
+    shouldLoadTranscript,
+    snapshotTranscript,
+    transcriptMissing,
+}: {
+    shouldLoadTranscript: boolean;
+    snapshotTranscript: TranscriptLoadState;
+    transcriptMissing: boolean;
+}) => {
+    return shouldLoadTranscript && !transcriptMissing && (snapshotTranscript === null || snapshotTranscript.isPartial);
+};

package/apps/ui/src/lib/thread-transcript-stats.ts

@@ -1,6 +1,15 @@
 import type { ThreadEvent, ThreadTranscriptStats } from '@spiracha/lib/codex-browser-types';
 
-const EXEC_TOOL_NAMES = new Set(['bash', 'exec', 'execute', 'execute_command', 'run_command', 'shell', 'terminal']);
+const EXEC_TOOL_NAMES = new Set([
+    'bash',
+    'exec',
+    'exec_command',
+    'execute',
+    'execute_command',
+    'run_command',
+    'shell',
+    'terminal',
+]);
 
 const isExecToolName = (name: string | null | undefined): boolean => {
     return EXEC_TOOL_NAMES.has((name ?? '').trim().toLowerCase());