spiracha 2.1.0 → 2.2.0

package/src/lib/qoder-transcript-phase.ts

@@ -2,6 +2,59 @@ import type { QoderTranscriptEntry } from './qoder-exporter-types';
 
 export type QoderMessagePhase = 'commentary' | 'final_answer' | null;
 
+const getMessageChunkType = (entry: QoderTranscriptEntry): string | null => {
+    if (entry.entryType !== 'message' || (entry.role !== 'assistant' && entry.role !== 'user')) {
+        return null;
+    }
+
+    const sessionUpdate = entry.parts[0]?.raw.sessionUpdate;
+    return typeof sessionUpdate === 'string' && sessionUpdate.endsWith('_message_chunk') ? sessionUpdate : null;
+};
+
+const mergeMessageChunks = (first: QoderTranscriptEntry, second: QoderTranscriptEntry): QoderTranscriptEntry => {
+    const firstPart = first.parts[0]!;
+    const secondPart = second.parts[0]!;
+    return {
+        ...first,
+        parts: [
+            {
+                ...firstPart,
+                raw: {
+                    ...firstPart.raw,
+                    coalescedChunkCount:
+                        (typeof firstPart.raw.coalescedChunkCount === 'number'
+                            ? firstPart.raw.coalescedChunkCount
+                            : 1) + 1,
+                },
+                text: `${firstPart.text ?? ''}${secondPart.text ?? ''}`,
+            },
+        ],
+        raw: second.raw,
+        timestamp: second.timestamp ?? first.timestamp,
+    };
+};
+
+export const coalesceQoderMessageChunks = (entries: QoderTranscriptEntry[]): QoderTranscriptEntry[] => {
+    const coalesced: QoderTranscriptEntry[] = [];
+    for (const entry of entries) {
+        const previous = coalesced.at(-1);
+        const chunkType = getMessageChunkType(entry);
+        if (
+            previous &&
+            chunkType &&
+            chunkType === getMessageChunkType(previous) &&
+            previous.requestId === entry.requestId &&
+            previous.parts.length === 1 &&
+            entry.parts.length === 1
+        ) {
+            coalesced[coalesced.length - 1] = mergeMessageChunks(previous, entry);
+        } else {
+            coalesced.push(entry);
+        }
+    }
+    return coalesced;
+};
+
 export const getFinalQoderAssistantMessageEntryIds = (entries: QoderTranscriptEntry[]): Set<string> => {
     const finalEntryIds = new Set<string>();
     let latestAssistantMessageEntryId: string | null = null;
@@ -37,5 +90,16 @@ export const getQoderMessagePhase = (entry: QoderTranscriptEntry, finalAssistant
         return null;
     }
 
+    const isExplicitReasoning = entry.parts.some((part) => {
+        return (
+            part.raw.sourceType === 'reasoning' ||
+            part.raw.sourceType === 'thinking' ||
+            part.raw.sessionUpdate === 'agent_thought_chunk'
+        );
+    });
+    if (isExplicitReasoning) {
+        return 'commentary';
+    }
+
     return finalAssistantMessageEntryIds.has(entry.entryId) ? 'final_answer' : 'commentary';
 };

package/src/lib/qoder-transcript.ts

@@ -9,6 +9,7 @@ import { getFinalQoderAssistantMessageEntryIds, getQoderMessagePhase } from './q
 import {
     cleanExtractedText,
     cleanInlineTitle,
+    formatInlineLiteral,
     type MetadataEntry,
     renderDocumentTitle,
     renderMetadataBlock,
@@ -61,6 +62,33 @@ const renderTextPart = (part: QoderTranscriptPart, title: string, options: Qoder
     return text ? renderSection(title, text, options.outputFormat) : '';
 };
 
+const getPartString = (part: QoderTranscriptPart, key: string): string | null => {
+    const value = part.raw[key];
+    return typeof value === 'string' && value.trim() ? value : null;
+};
+
+const renderToolPart = (part: QoderTranscriptPart, title: string, options: QoderExportOptions): string => {
+    const text = cleanExtractedText(part.text ?? '').trim();
+    if (!text) {
+        return '';
+    }
+
+    const lines: string[] = [];
+    const toolName = getPartString(part, 'toolName');
+    const toolCallId = getPartString(part, 'toolCallId');
+    if (toolName) {
+        lines.push(`Tool: ${formatInlineLiteral(toolName, options.outputFormat)}`);
+    }
+    if (toolCallId) {
+        lines.push(`Call ID: ${toolCallId}`);
+    }
+    if (lines.length > 0) {
+        lines.push('');
+    }
+    lines.push(text);
+    return renderSection(title, lines.join('\n'), options.outputFormat);
+};
+
 const renderPart = (
     entry: QoderTranscriptEntry,
     part: QoderTranscriptPart,
@@ -68,11 +96,11 @@ const renderPart = (
     finalAssistantMessageEntryIds: Set<string>,
 ): string => {
     if (entry.entryType === 'tool_call') {
-        return options.includeTools && part.type === 'text' ? renderTextPart(part, 'Tool call', options) : '';
+        return options.includeTools && part.type === 'text' ? renderToolPart(part, 'Tool call', options) : '';
     }
 
     if (entry.entryType === 'tool_output') {
-        return options.includeTools && part.type === 'text' ? renderTextPart(part, 'Tool output', options) : '';
+        return options.includeTools && part.type === 'text' ? renderToolPart(part, 'Tool output', options) : '';
     }
 
     if (getQoderMessagePhase(entry, finalAssistantMessageEntryIds) === 'commentary' && !options.includeCommentary) {

package/src/lib/shared.ts

@@ -1,9 +1,10 @@
 import { createReadStream, createWriteStream } from 'node:fs';
-import { mkdir } from 'node:fs/promises';
+import { mkdir, readdir, stat } from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
 import { createInterface } from 'node:readline';
 import { finished } from 'node:stream/promises';
+import { pathToFileURL } from 'node:url';
 import { formatModelLabel as formatSharedModelLabel } from './model-label';
 
 export type JsonValue = string | number | boolean | null | JsonValue[] | { [key: string]: JsonValue };
@@ -17,6 +18,19 @@ export type MetadataEntry = {
 
 export class CliUsageError extends Error {}
 
+export const readDirectoryEntriesIfExists = async (directoryPath: string) => {
+    try {
+        return await readdir(directoryPath, { withFileTypes: true });
+    } catch (error) {
+        if ((error as { code?: unknown }).code === 'ENOENT') {
+            return [];
+        }
+        throw error;
+    }
+};
+
+export const toFileUri = (filePath: string): string => pathToFileURL(filePath).href;
+
 export const expandHome = (value: string): string => {
     if (!value) {
         return value;
@@ -26,20 +40,26 @@ export const expandHome = (value: string): string => {
         return os.homedir();
     }
 
-    if (value.startsWith('~/')) {
-        return path.join(os.homedir(), value.slice(2));
+    if (value.startsWith('~/') || value.startsWith('~\\')) {
+        return path.join(
+            os.homedir(),
+            ...value
+                .slice(2)
+                .split(/[\\/]+/u)
+                .filter(Boolean),
+        );
     }
 
     return value;
 };
 
-export const getPortablePathBasename = (value: string): string => {
-    const trimmed = value.replace(/[\\/]+$/u, '');
-    if (!trimmed) {
-        return '';
+export const pathExists = async (target: string): Promise<boolean> => {
+    try {
+        await stat(target);
+        return true;
+    } catch {
+        return false;
     }
-
-    return path.win32.basename(path.posix.basename(trimmed));
 };
 
 export const isWorkspacePathQuery = (value: string): boolean => {
@@ -128,6 +148,7 @@ export const readJsonlObjects = (filePath: string): AsyncIterableIterator<Record
     });
     const lineIterator = lines[Symbol.asyncIterator]();
     let closed = false;
+    let lineNumber = 0;
 
     const close = () => {
         if (closed) {
@@ -147,17 +168,27 @@ export const readJsonlObjects = (filePath: string): AsyncIterableIterator<Record
                 return { done: true, value: undefined as never };
             }
 
+            lineNumber += 1;
             const trimmed = nextLine.value.trim();
             if (!trimmed) {
                 continue;
             }
 
             try {
+                const parsed = JSON.parse(trimmed) as JsonValue;
+                const object = asObject(parsed);
+                if (!object) {
+                    console.warn('[spiracha:jsonl] invalid_json_line', { filePath, lineNumber });
+                    continue;
+                }
+
                 return {
                     done: false,
-                    value: JSON.parse(trimmed) as Record<string, JsonValue>,
+                    value: object,
                 };
-            } catch {}
+            } catch {
+                console.warn('[spiracha:jsonl] invalid_json_line', { filePath, lineNumber });
+            }
         }
     };
 
@@ -225,7 +256,8 @@ export const renderSection = (title: string, body: string, format: ExportFormat)
 
 export const renderCodeBlock = (text: string, format: ExportFormat): string => {
     if (format === 'md') {
-        return `\`\`\`text\n${text}\n\`\`\``;
+        const fence = getBacktickFence(text, 3);
+        return `${fence}text\n${text}\n${fence}`;
     }
 
     return text;
@@ -235,10 +267,14 @@ export const formatInlineLiteral = (value: string, format: ExportFormat): string
     return format === 'md' ? inlineCode(value) : value;
 };
 
-export const inlineCode = (value: string): string => {
-    const backtickRuns = value.match(/`+/g) ?? [];
+const getBacktickFence = (value: string, minimumLength: number): string => {
+    const backtickRuns = value.match(/`+/gu) ?? [];
     const maxRunLength = backtickRuns.reduce((max, run) => Math.max(max, run.length), 0);
-    const fence = '`'.repeat(maxRunLength + 1);
+    return '`'.repeat(Math.max(minimumLength, maxRunLength + 1));
+};
+
+export const inlineCode = (value: string): string => {
+    const fence = getBacktickFence(value, 1);
     const padded = value.startsWith('`') || value.endsWith('`') ? ` ${value} ` : value;
     return `${fence}${padded}${fence}`;
 };

package/src/lib/sqlite-error.ts

@@ -1,14 +1,40 @@
+const SQLITE_RETRYABLE_CODES = new Set(['SQLITE_BUSY', 'SQLITE_BUSY_SNAPSHOT', 'SQLITE_CANTOPEN', 'SQLITE_LOCKED']);
+const SQLITE_OPERATION_PREFIX = String.raw`(?:SQLite operation failed after \d+ attempts?:\s*)?`;
 const SQLITE_RETRYABLE_PATTERNS = [
-    /unable to open database file/iu,
-    /database is locked/iu,
-    /SQLITE_BUSY/iu,
-    /SQLITE_CANTOPEN/iu,
+    new RegExp(`^${SQLITE_OPERATION_PREFIX}unable to open database(?: file)?(?:$|:)`, 'iu'),
+    new RegExp(`^${SQLITE_OPERATION_PREFIX}database(?: table)? is locked(?:$|:)`, 'iu'),
+    /^SQLITE_(?:BUSY|CANTOPEN|LOCKED)(?:_[A-Z_]+)?(?:$|:)/u,
 ];
+const SQLITE_DATABASE_PATTERNS = [
+    ...SQLITE_RETRYABLE_PATTERNS,
+    /^SQLITE_[A-Z_]+(?:$|:)/u,
+    new RegExp(
+        `^${SQLITE_OPERATION_PREFIX}(?:attempt to write a readonly database|database disk image is malformed|disk I/O error)(?:$|:)`,
+        'iu',
+    ),
+];
+
+const getSqliteCode = (error: Error): string | null => {
+    const code = 'code' in error ? error.code : null;
+    return typeof code === 'string' && code.startsWith('SQLITE_') ? code.toUpperCase() : null;
+};
 
 export const isRetryableSqliteError = (error: unknown) => {
     if (!(error instanceof Error)) {
         return false;
     }
 
-    return SQLITE_RETRYABLE_PATTERNS.some((pattern) => pattern.test(error.message));
+    const code = getSqliteCode(error);
+    return (
+        Boolean(code && SQLITE_RETRYABLE_CODES.has(code)) ||
+        SQLITE_RETRYABLE_PATTERNS.some((pattern) => pattern.test(error.message))
+    );
+};
+
+export const isSqliteDatabaseError = (error: unknown): boolean => {
+    if (!(error instanceof Error)) {
+        return false;
+    }
+
+    return getSqliteCode(error) !== null || SQLITE_DATABASE_PATTERNS.some((pattern) => pattern.test(error.message));
 };

package/src/lib/transcript-load-limiter.ts

@@ -19,9 +19,14 @@ export const resolveTranscriptLoadConcurrency = (value = process.env.SPIRACHA_TR
         : DEFAULT_TRANSCRIPT_LOAD_CONCURRENCY;
 };
 
-const transcriptLoadLimiter = createConcurrencyLimiter(resolveTranscriptLoadConcurrency());
+let transcriptLoadLimiter: ReturnType<typeof createConcurrencyLimiter> | null = null;
 
-const shouldLogTranscriptLoads = () => process.env.SPIRACHA_TRANSCRIPT_LOAD_LOGS !== '0';
+const getTranscriptLoadLimiter = () => {
+    transcriptLoadLimiter ??= createConcurrencyLimiter(resolveTranscriptLoadConcurrency());
+    return transcriptLoadLimiter;
+};
+
+const shouldLogTranscriptLoads = () => process.env.SPIRACHA_TRANSCRIPT_LOAD_LOGS === '1';
 
 const logTranscriptLoad = (event: string, details: Record<string, unknown>) => {
     if (shouldLogTranscriptLoads()) {
@@ -38,7 +43,7 @@ export const runWithTranscriptLoadLimit = async <T>(
     queuedTranscriptLoads += 1;
     const queuedAt = Date.now();
 
-    return transcriptLoadLimiter(async () => {
+    return getTranscriptLoadLimiter()(async () => {
         queuedTranscriptLoads -= 1;
         activeTranscriptLoads += 1;
         const startedAt = Date.now();

package/src/lib/ui-cache.ts

@@ -1,10 +1,14 @@
 import { createHash, randomUUID } from 'node:crypto';
-import { chmod, mkdir, readdir, rename, rm, stat } from 'node:fs/promises';
+import { chmod, lstat, mkdir, readdir, rename, rm, stat, utimes } from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
 
 const CACHE_DIR = path.join(os.tmpdir(), 'spiracha-ui-cache');
 const CACHE_ENVELOPE_VERSION = 1;
+const DEFAULT_CACHE_MAX_AGE_MS = 24 * 60 * 60 * 1000;
+const DEFAULT_CACHE_MAX_BYTES = 256 * 1024 * 1024;
+const CACHE_PURGE_INTERVAL_MS = 60 * 1000;
+const CACHE_KEY_PREFIX_MAX_LENGTH = 80;
 
 type CacheEnvelope<T> = {
     value: T;
@@ -14,19 +18,135 @@ type CacheEnvelope<T> = {
 type CacheReadResult<T> = { hit: true; value: T } | { hit: false };
 
 const inFlightCacheLoads = new Map<string, Promise<unknown>>();
+const activeCachePathCounts = new Map<string, number>();
+const pendingCachePathRemovals = new Set<string>();
+let cacheDirectoryInitialized = false;
+let cacheInvalidationGeneration = 0;
+let lastCachePurgeAtMs = 0;
 
-const ensureCacheDir = async () => {
-    await mkdir(CACHE_DIR, { mode: 0o700, recursive: true });
-    await chmod(CACHE_DIR, 0o700);
+const removeInactiveCachePath = async (filePath: string): Promise<void> => {
+    if (activeCachePathCounts.has(filePath)) {
+        pendingCachePathRemovals.add(filePath);
+        return;
+    }
+    await rm(filePath, { force: true });
 };
 
-const toCachePath = (key: string) => {
-    const safeKey = key.replace(/[^a-zA-Z0-9._-]/gu, '_');
-    return path.join(CACHE_DIR, `${safeKey}-${hashCacheKeyParts(key)}.json`);
+const beginActiveCachePath = (filePath: string): void => {
+    activeCachePathCounts.set(filePath, (activeCachePathCounts.get(filePath) ?? 0) + 1);
+};
+
+const finishActiveCachePath = async (filePath: string): Promise<void> => {
+    const remainingCount = (activeCachePathCounts.get(filePath) ?? 1) - 1;
+    if (remainingCount > 0) {
+        activeCachePathCounts.set(filePath, remainingCount);
+        return;
+    }
+    activeCachePathCounts.delete(filePath);
+    if (pendingCachePathRemovals.delete(filePath)) {
+        await rm(filePath, { force: true });
+    }
+};
+
+export const pruneUiCacheEntries = async (
+    cacheDir: string = CACHE_DIR,
+    maxAgeMs: number = DEFAULT_CACHE_MAX_AGE_MS,
+    maxBytes: number = DEFAULT_CACHE_MAX_BYTES,
+) => {
+    const cutoff = Date.now() - maxAgeMs;
+    const entries = await readdir(cacheDir, { withFileTypes: true }).catch((error: unknown) => {
+        if ((error as { code?: unknown }).code === 'ENOENT') {
+            return [];
+        }
+        throw error;
+    });
+    const cacheFiles = (
+        await Promise.all(
+            entries
+                .filter((entry) => entry.isFile())
+                .map(async (entry) => {
+                    const filePath = path.join(cacheDir, entry.name);
+                    try {
+                        const metadata = await stat(filePath);
+                        return { filePath, mtimeMs: metadata.mtimeMs, name: entry.name, size: metadata.size };
+                    } catch (error) {
+                        if ((error as { code?: unknown }).code === 'ENOENT') {
+                            return null;
+                        }
+                        throw error;
+                    }
+                }),
+        )
+    ).filter((entry): entry is NonNullable<typeof entry> => entry !== null);
+    const staleFiles = cacheFiles.filter((entry) => entry.name.endsWith('.json') && entry.mtimeMs < cutoff);
+    await Promise.all(staleFiles.map((entry) => removeInactiveCachePath(entry.filePath)));
+
+    const retainedCacheFiles = cacheFiles.filter((entry) => entry.mtimeMs >= cutoff && entry.name.endsWith('.json'));
+    let retainedBytes = retainedCacheFiles.reduce((total, entry) => total + entry.size, 0);
+    if (retainedBytes <= maxBytes) {
+        return;
+    }
+
+    const retainedOldestFirst = retainedCacheFiles.sort(
+        (left, right) => left.mtimeMs - right.mtimeMs || left.name.localeCompare(right.name),
+    );
+    const oversizedFiles = [];
+    for (const entry of retainedOldestFirst) {
+        if (retainedBytes <= maxBytes) {
+            break;
+        }
+        oversizedFiles.push(entry.filePath);
+        retainedBytes -= entry.size;
+    }
+    await Promise.all(oversizedFiles.map(removeInactiveCachePath));
+};
+
+const assertSafeCacheDirectory = async () => {
+    const metadata = await lstat(CACHE_DIR);
+    if (!metadata.isDirectory() || metadata.isSymbolicLink()) {
+        throw new Error(`Unsafe Spiracha cache directory: ${CACHE_DIR}`);
+    }
+    return metadata;
+};
+
+const refreshCacheDirectoryState = async () => {
+    try {
+        await assertSafeCacheDirectory();
+    } catch (error) {
+        if ((error as { code?: unknown }).code !== 'ENOENT') {
+            throw error;
+        }
+        cacheDirectoryInitialized = false;
+    }
+};
+
+const ensureCacheDir = async () => {
+    if (cacheDirectoryInitialized) {
+        await refreshCacheDirectoryState();
+    }
+
+    if (!cacheDirectoryInitialized) {
+        await mkdir(CACHE_DIR, { mode: 0o700, recursive: true });
+        const metadata = await assertSafeCacheDirectory();
+        if ((metadata.mode & 0o777) !== 0o700) {
+            await chmod(CACHE_DIR, 0o700);
+        }
+        cacheDirectoryInitialized = true;
+    }
+    const now = Date.now();
+    if (now - lastCachePurgeAtMs >= CACHE_PURGE_INTERVAL_MS) {
+        lastCachePurgeAtMs = now;
+        void pruneUiCacheEntries(CACHE_DIR).catch((error) => {
+            console.warn('[spiracha:ui-cache] cache pruning failed', {
+                error: error instanceof Error ? error.message : String(error),
+            });
+        });
+    }
 };
 
-export const hashCacheKeyParts = (...parts: string[]) => {
-    return createHash('sha1').update(parts.join('|')).digest('hex');
+const toCachePath = (key: string) => {
+    const safeKey = key.replace(/[^a-zA-Z0-9._-]/gu, '_').slice(0, CACHE_KEY_PREFIX_MAX_LENGTH);
+    return path.join(CACHE_DIR, `${safeKey}-${hashCacheKeyPartsIterable([key])}.json`);
 };
 
 export const hashCacheKeyPartsIterable = (parts: Iterable<string>) => {
@@ -55,11 +175,14 @@ const readCachedJson = async <T>(key: string): Promise<CacheReadResult<T>> => {
     }
 
     let parsed: CacheEnvelope<T> | T;
+    beginActiveCachePath(filePath);
     try {
         parsed = (await file.json()) as CacheEnvelope<T> | T;
     } catch {
         await rm(filePath, { force: true });
         return { hit: false };
+    } finally {
+        await finishActiveCachePath(filePath);
     }
 
     if (
@@ -69,6 +192,8 @@ const readCachedJson = async <T>(key: string): Promise<CacheReadResult<T>> => {
         (parsed as CacheEnvelope<T>).version === CACHE_ENVELOPE_VERSION &&
         'value' in parsed
     ) {
+        const now = new Date();
+        await utimes(filePath, now, now).catch(() => undefined);
         return { hit: true, value: (parsed as CacheEnvelope<T>).value };
     }
 
@@ -90,28 +215,35 @@ export const setCachedJson = async <T>(key: string, value: T) => {
         version: CACHE_ENVELOPE_VERSION,
     };
 
+    beginActiveCachePath(filePath);
+    beginActiveCachePath(tempPath);
     try {
         await Bun.write(tempPath, JSON.stringify(envelope));
         await rename(tempPath, filePath);
     } finally {
         await rm(tempPath, { force: true });
+        await finishActiveCachePath(tempPath);
+        await finishActiveCachePath(filePath);
     }
 };
 
 export const withCachedJson = async <T>(key: string, loader: () => Promise<T>): Promise<T> => {
-    const cached = await readCachedJson<T>(key);
-    if (cached.hit) {
-        return cached.value;
-    }
-
     const inFlight = inFlightCacheLoads.get(key);
     if (inFlight) {
         return (await inFlight) as T;
     }
 
     const load = (async () => {
+        const generation = cacheInvalidationGeneration;
+        const cached = await readCachedJson<T>(key);
+        if (cached.hit) {
+            return cached.value;
+        }
+
         const value = await loader();
-        await setCachedJson(key, value);
+        if (generation === cacheInvalidationGeneration) {
+            await setCachedJson(key, value);
+        }
         return value;
     })();
     inFlightCacheLoads.set(key, load);
@@ -119,17 +251,20 @@ export const withCachedJson = async <T>(key: string, loader: () => Promise<T>):
     try {
         return await load;
     } finally {
-        inFlightCacheLoads.delete(key);
+        if (inFlightCacheLoads.get(key) === load) {
+            inFlightCacheLoads.delete(key);
+        }
     }
 };
 
 export const invalidateCacheByPrefix = async (...prefixes: string[]) => {
+    cacheInvalidationGeneration += 1;
     await ensureCacheDir();
     const entries = await readdir(CACHE_DIR);
 
     await Promise.all(
         entries
             .filter((entry) => prefixes.some((prefix) => entry.startsWith(prefix)))
-            .map((entry) => rm(path.join(CACHE_DIR, entry), { force: true })),
+            .map((entry) => removeInactiveCachePath(path.join(CACHE_DIR, entry))),
     );
 };

package/src/lib/ui-export-archive.ts

@@ -1,3 +1,4 @@
+import { getPortablePathBasename } from './portable-path';
 import type { ExportFormat } from './shared';
 
 type BatchExportNameEntry = {
@@ -9,16 +10,6 @@ type ConversationExportNameEntry = BatchExportNameEntry & {
     id: string;
 };
 
-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);
-};
-
 export const sanitizeExportFileName = (value: string) => {
     return value
         .replace(/[<>:"/\\|?*\u0000-\u001f]/gu, ' ')
@@ -32,9 +23,19 @@ export const getExportMimeType = (outputFormat: ExportFormat) => {
 };
 
 export const resolveUniqueExportFileBaseName = (baseName: string, usedCounts: Map<string, number>) => {
-    const count = (usedCounts.get(baseName) ?? 0) + 1;
-    usedCounts.set(baseName, count);
-    return count === 1 ? baseName : `${baseName}-${count}`;
+    const normalizeKey = (value: string) => value.normalize('NFC').toLowerCase();
+    const baseKey = normalizeKey(baseName);
+    let count = (usedCounts.get(baseKey) ?? 0) + 1;
+    let candidate = count === 1 ? baseName : `${baseName}-${count}`;
+
+    while (usedCounts.has(normalizeKey(candidate))) {
+        count += 1;
+        candidate = `${baseName}-${count}`;
+    }
+
+    usedCounts.set(baseKey, count);
+    usedCounts.set(normalizeKey(candidate), Math.max(usedCounts.get(normalizeKey(candidate)) ?? 0, 1));
+    return candidate;
 };
 
 const formatBatchExportDate = (value: number) => {
@@ -77,45 +78,3 @@ export const buildBatchExportBaseName = (entries: BatchExportNameEntry[], fallba
         ? `${projectName}-${formatBatchExportDate(latestUpdatedAtMs)}-threads-${entries.length}`
         : `${projectName}-threads-${entries.length}`;
 };
-
-const readPipeText = async (pipe: ReadableStream<Uint8Array> | number | undefined) => {
-    return pipe && typeof pipe !== 'number' ? new Response(pipe).text() : '';
-};
-
-const runZip = async (args: string[], options: { cwd?: string } = {}) => {
-    let proc: ReturnType<typeof Bun.spawn>;
-    try {
-        proc = Bun.spawn(['zip', '-9', ...args], {
-            cwd: options.cwd,
-            stderr: 'pipe',
-            stdout: 'pipe',
-        });
-    } catch (error) {
-        throw new Error(
-            `zip command failed to start. Install the "zip" executable or choose a non-zip export. ${error instanceof Error ? error.message : String(error)}`,
-        );
-    }
-
-    const [stdoutText, stderrText, exitCode] = await Promise.all([
-        readPipeText(proc.stdout),
-        readPipeText(proc.stderr),
-        proc.exited,
-    ]);
-
-    if (exitCode !== 0) {
-        const output = (stderrText || stdoutText).trim();
-        throw new Error(
-            output
-                ? `zip command failed (${exitCode}): ${output}`
-                : `zip command failed (${exitCode}). Install the "zip" executable or choose a non-zip export.`,
-        );
-    }
-};
-
-export const zipExportFile = async (sourcePath: string, zipPath: string) => {
-    await runZip(['-j', zipPath, sourcePath]);
-};
-
-export const zipExportDirectory = async (sourceDirectory: string, zipPath: string) => {
-    await runZip(['-r', zipPath, '.'], { cwd: sourceDirectory });
-};