spiracha 2.1.0 → 2.2.0

package/src/lib/codex-transcript-renderer.ts

@@ -1,7 +1,13 @@
 import { createReadStream } from 'node:fs';
 import { rm } from 'node:fs/promises';
 import path from 'node:path';
-import { finished } from 'node:stream/promises';
+import type { Readable, Writable } from 'node:stream';
+import { pipeline } from 'node:stream/promises';
+import {
+    parseCodexTranscriptRecord,
+    shouldHideCodexTranscriptText,
+    stripCodexMemoryCitationBlocks,
+} from './codex-thread-parser';
 import {
     type CodexTranscriptExportTarget,
     type CodexTranscriptRenderOptions,
@@ -23,6 +29,7 @@ import {
     type JsonValue,
     type MetadataEntry,
     readJsonlObjects,
+    renderCodeBlock,
     renderDocumentTitle,
     renderMetadataBlock,
     renderSection,
@@ -30,6 +37,10 @@ import {
 } from './shared';
 import { runWithTranscriptLoadLimit } from './transcript-load-limiter';
 
+export const pipeCodexExportStream = async (source: Readable, destination: Writable) => {
+    await pipeline(source, destination, { end: false });
+};
+
 export const renderCodexSessionFile = async (
     target: CodexTranscriptExportTarget,
     options: CodexTranscriptRenderOptions,
@@ -122,8 +133,7 @@ export const writeCodexSessionFileExport = async (
             }
 
             const transcriptReadStream = createReadStream(transcriptOutputPath, { encoding: 'utf8' });
-            transcriptReadStream.pipe(outputStream, { end: false });
-            await finished(transcriptReadStream);
+            await pipeCodexExportStream(transcriptReadStream, outputStream);
             outputStream.write('\n');
             await finalizeExportWriteStream(outputStream);
         } catch (error) {
@@ -512,45 +522,22 @@ const normalizeMessage = (value: Record<string, JsonValue>): MessageRecord | nul
 };
 
 const extractToolRecord = (parsed: Record<string, JsonValue>): ToolRecord | null => {
-    if (parsed.type !== 'response_item') {
-        return null;
-    }
-
-    const payload = asObject(parsed.payload);
-    if (!payload) {
-        return null;
-    }
-
-    if (payload.type === 'function_call') {
-        const name = asString(payload.name);
-        const argumentsText = asString(payload.arguments);
-        const callId = asString(payload.call_id);
-
-        if (name !== 'exec_command') {
-            return null;
-        }
-
+    const event = parseCodexTranscriptRecord(parsed);
+    if (event?.kind === 'tool_call') {
         return {
-            argumentsText: argumentsText ?? undefined,
-            callId,
+            argumentsText: event.argumentsText ?? undefined,
+            callId: event.callId,
             kind: 'call',
-            name,
+            name: event.name,
         };
     }
 
-    if (payload.type === 'function_call_output') {
-        const callId = asString(payload.call_id);
-        const outputText = asString(payload.output);
-
-        if (!outputText?.includes('Command: ')) {
-            return null;
-        }
-
+    if (event?.kind === 'tool_output') {
         return {
-            callId,
+            callId: event.callId,
             kind: 'output',
-            name: 'function_call_output',
-            outputText: outputText ?? undefined,
+            name: 'tool_output',
+            outputText: event.outputText,
         };
     }
 
@@ -572,8 +559,10 @@ const renderMessageBlock = (
     }
 
     const extractedText = extractText(message.content);
-    const text = stripCodexAppDirectiveLines(cleanExtractedText(stripPreviewBlock(extractedText)));
-    if (!text || shouldSkipMessage(message.role, text)) {
+    const text = stripCodexMemoryCitationBlocks(
+        stripCodexAppDirectiveLines(cleanExtractedText(stripPreviewBlock(extractedText))),
+    );
+    if (!text || shouldHideCodexTranscriptText(message.role, text)) {
         return '';
     }
 
@@ -586,12 +575,18 @@ const renderMessageBlock = (
 const renderToolBlock = (tool: ToolRecord, outputFormat: ExportFormat): string => {
     if (tool.kind === 'call') {
         const details = formatToolCallDetails(tool, outputFormat);
-        return details ? renderSection('Tool', details, outputFormat) : '';
+        return renderSection('Tool Call', details, outputFormat);
     }
 
     const outputText = tool.outputText ?? '';
     const summary = formatToolOutputSummary(outputText, outputFormat);
-    return summary ? renderSection('Tool Output', summary, outputFormat) : '';
+    if (!summary && !outputText.trim()) {
+        return '';
+    }
+
+    const lines = tool.callId ? [`Call ID: ${tool.callId}`, ''] : [];
+    lines.push(summary || renderCodeBlock(outputText.trim(), outputFormat));
+    return renderSection('Tool Output', lines.join('\n'), outputFormat);
 };
 
 const stripPreviewBlock = (text: string): string => {
@@ -606,7 +601,7 @@ const stripPreviewBlock = (text: string): string => {
 
     const first = parts[0];
     const second = parts[1];
-    const isTranscriptHeading = (value: string) => /^##\s+.+$/i.test(value);
+    const isTranscriptHeading = (value: string) => /^##\s+(?:assistant|user)$/i.test(value);
     const looksLikePreview =
         !/^([UA]):/i.test(first) &&
         !isTranscriptHeading(first) &&
@@ -620,33 +615,26 @@ const stripPreviewBlock = (text: string): string => {
     return parts.slice(1).join('\n\n');
 };
 
-const shouldSkipMessage = (role: string, text: string): boolean => {
-    if (text.startsWith('<environment_context>')) {
-        return true;
-    }
-
-    if (text.startsWith('AGENTS.md instructions for ')) {
-        return true;
-    }
-
-    if (text.startsWith('# AGENTS.md instructions for ')) {
-        return true;
+const formatToolCallDetails = (tool: ToolRecord, outputFormat: ExportFormat): string => {
+    const lines = [`Tool: ${formatInlineLiteral(tool.name, outputFormat)}`];
+    if (tool.callId) {
+        lines.push(`Call ID: ${tool.callId}`);
     }
 
-    if (role === 'user' && text.includes('<environment_context>')) {
-        return true;
+    if (tool.name === 'exec_command') {
+        const details = parseExecCommandArguments(tool.argumentsText);
+        if (details.cmd) {
+            lines.push(`Command: ${formatInlineLiteral(details.cmd, outputFormat)}`);
+            return lines.join('\n');
+        }
     }
 
-    return false;
-};
-
-const formatToolCallDetails = (tool: ToolRecord, outputFormat: ExportFormat): string => {
-    if (tool.name !== 'exec_command') {
-        return '';
+    const argumentsText = tool.argumentsText?.trim();
+    if (argumentsText) {
+        lines.push('', 'Input:', '', renderCodeBlock(argumentsText, outputFormat));
     }
 
-    const details = parseExecCommandArguments(tool.argumentsText);
-    return details.cmd ? `Command: ${formatInlineLiteral(details.cmd, outputFormat)}` : '';
+    return lines.join('\n');
 };
 
 const extractText = (content: JsonValue): string => {

package/src/lib/concurrency.ts

@@ -11,16 +11,28 @@ export const mapWithConcurrency = async <T, TResult>(
     const workerLimit = Math.max(1, requestedLimit);
     const results = new Array<TResult>(values.length);
     let nextIndex = 0;
+    let failed = false;
 
     const worker = async () => {
-        while (nextIndex < values.length) {
+        while (!failed && nextIndex < values.length) {
             const currentIndex = nextIndex;
             nextIndex += 1;
-            results[currentIndex] = await mapper(values[currentIndex]!, currentIndex);
+            try {
+                results[currentIndex] = await mapper(values[currentIndex]!, currentIndex);
+            } catch (error) {
+                failed = true;
+                throw error;
+            }
         }
     };
 
-    await Promise.all(Array.from({ length: Math.min(workerLimit, values.length) }, () => worker()));
+    const settledWorkers = await Promise.allSettled(
+        Array.from({ length: Math.min(workerLimit, values.length) }, () => worker()),
+    );
+    const failure = settledWorkers.find((result): result is PromiseRejectedResult => result.status === 'rejected');
+    if (failure) {
+        throw failure.reason;
+    }
     return results;
 };
 

package/src/lib/conversation-api.ts

@@ -1,3 +1,4 @@
+import path from 'node:path';
 import { mapWithConcurrency } from './concurrency';
 import {
     type ConversationDetail,
@@ -98,10 +99,14 @@ const parseSources = (value: string | null): ParseResult<ConversationSource[] |
         return { value: 'all' };
     }
 
-    const sources = value
-        .split(',')
-        .map((source) => source.trim())
-        .filter(Boolean);
+    const sources = [
+        ...new Set(
+            value
+                .split(',')
+                .map((source) => source.trim())
+                .filter(Boolean),
+        ),
+    ];
     const invalidSource = sources.find((source) => !isConversationSource(source));
 
     return invalidSource ? { error: invalidSourceResponse(invalidSource) } : { value: sources as ConversationSource[] };
@@ -169,6 +174,9 @@ const validatePathLength = (field: string, value: string): Response | null => {
         : invalidFieldResponse(field, value.length, `\`${field}\` is too long.`);
 };
 
+const validateAbsoluteCwd = (cwd: string): Response | null =>
+    path.isAbsolute(cwd) ? null : invalidFieldResponse('cwd', cwd, '`cwd` must be an absolute path.');
+
 const validateTimestamp = (field: string, value: number | undefined): Response | null => {
     if (value === undefined) {
         return null;
@@ -179,14 +187,10 @@ const validateTimestamp = (field: string, value: number | undefined): Response |
         : invalidFieldResponse(field, value, `\`${field}\` must be a non-negative epoch millisecond timestamp.`);
 };
 
-const validateDeleteId = (id: string): Response | null => {
+const validateConversationId = (id: string): Response | null => {
     return /^[A-Za-z0-9][A-Za-z0-9._:-]{0,255}$/u.test(id) && !id.includes('..')
         ? null
-        : invalidFieldResponse(
-              'id',
-              id,
-              'Conversation id contains characters that are not allowed for destructive requests.',
-          );
+        : invalidFieldResponse('id', id, 'Conversation id contains characters that are not allowed by the stable API.');
 };
 
 const parseListLimitParam = (value: string | null): ParseResult<number | undefined> => {
@@ -232,6 +236,10 @@ const buildListOptions = (url: URL): ParseResult<ListConversationsForPathOptions
     if (cwdLengthError) {
         return { error: cwdLengthError };
     }
+    const cwdAbsoluteError = validateAbsoluteCwd(cwd);
+    if (cwdAbsoluteError) {
+        return { error: cwdAbsoluteError };
+    }
 
     const cursor = url.searchParams.get('cursor');
     const cursorError = validateCursor(cursor);
@@ -279,7 +287,7 @@ const buildListOptions = (url: URL): ParseResult<ListConversationsForPathOptions
 };
 
 const normalizeMeta = (meta: { hasNext: boolean; nextCursor: string | null }) => ({
-    hasNext: meta.hasNext,
+    has_next: meta.hasNext,
     next_cursor: meta.nextCursor,
 });
 
@@ -370,9 +378,9 @@ const buildDeleteConversationOptions = (
     if (!decodedId.trim() || decodedId.length > MAX_ID_LENGTH) {
         return { error: invalidFieldResponse('id', decodedId.length, 'Conversation id is invalid.') };
     }
-    const deleteIdError = validateDeleteId(decodedId);
-    if (deleteIdError) {
-        return { error: deleteIdError };
+    const idError = validateConversationId(decodedId);
+    if (idError) {
+        return { error: idError };
     }
 
     return {
@@ -497,10 +505,7 @@ const parseJsonSourceOption = (body: Record<string, unknown>): ParseResult<Conve
     return isConversationSource(source) ? { value: source } : { error: invalidSourceResponse(source) };
 };
 
-const parseJsonIdsOption = (
-    body: Record<string, unknown>,
-    options: { destructive: boolean },
-): ParseResult<string[]> => {
+const parseJsonIdsOption = (body: Record<string, unknown>): ParseResult<string[]> => {
     const idsValue = getOption(body, 'ids', 'ids');
     if (!Array.isArray(idsValue) || idsValue.length === 0) {
         return {
@@ -534,9 +539,9 @@ const parseJsonIdsOption = (
             };
         }
 
-        const deleteIdError = options.destructive ? validateDeleteId(id) : null;
-        if (deleteIdError) {
-            return { error: deleteIdError };
+        const idError = validateConversationId(id);
+        if (idError) {
+            return { error: idError };
         }
 
         if (!seenIds.has(id)) {
@@ -570,16 +575,13 @@ const parseJsonExportMessageSelector = (body: Record<string, unknown>): ParseRes
     return parseMessageSelector(messageSelectorValue.value ?? null, 'all');
 };
 
-const parseConversationIdSetRecord = (
-    body: Record<string, unknown>,
-    options: { destructive: boolean },
-): ParseResult<DeleteConversationsOptions> => {
+const parseConversationIdSetRecord = (body: Record<string, unknown>): ParseResult<DeleteConversationsOptions> => {
     const source = parseJsonSourceOption(body);
     if ('error' in source) {
         return source;
     }
 
-    const ids = parseJsonIdsOption(body, options);
+    const ids = parseJsonIdsOption(body);
     if ('error' in ids) {
         return ids;
     }
@@ -598,7 +600,7 @@ const parseExportConversationsBody = async (request: Request): Promise<ParseResu
         return body;
     }
 
-    const idSet = parseConversationIdSetRecord(body.value, { destructive: false });
+    const idSet = parseConversationIdSetRecord(body.value);
     if ('error' in idSet) {
         return idSet;
     }
@@ -629,7 +631,7 @@ const handleDeleteConversations = async (request: Request, dependencies: ReturnT
         return body.error;
     }
 
-    const result = parseConversationIdSetRecord(body.value, { destructive: true });
+    const result = parseConversationIdSetRecord(body.value);
     if ('error' in result) {
         return result.error;
     }
@@ -845,8 +847,8 @@ const parseJsonCwd = (body: Record<string, unknown>): ParseResult<string> => {
         return { error: errorResponse('validation_error', '`cwd` is required.', 400, { field: 'cwd' }) };
     }
 
-    const cwdLengthError = validatePathLength('cwd', cwd);
-    return cwdLengthError ? { error: cwdLengthError } : { value: cwd };
+    const cwdError = validatePathLength('cwd', cwd) ?? validateAbsoluteCwd(cwd);
+    return cwdError ? { error: cwdError } : { value: cwd };
 };
 
 const parseJsonCursor = (body: Record<string, unknown>): ParseResult<string | null> => {
@@ -954,6 +956,7 @@ const validateListQueryOptions = (options: ListConversationsForPathOptions): Res
 
     return (
         validatePathLength('cwd', options.cwd) ??
+        validateAbsoluteCwd(options.cwd) ??
         validateCursor(options.cursor) ??
         validateLimit(options.limit) ??
         validateTimestamp('updated_after_ms', options.updatedAfterMs) ??
@@ -1017,7 +1020,7 @@ const API_ROUTES: ApiRoute[] = [
     },
     {
         handle: ({ dependencies, url }) => handleListConversations(url, dependencies),
-        matches: ({ source }) => !source,
+        matches: ({ action, source }) => !source && !action,
         method: 'GET',
         resource: 'conversations',
     },

package/src/lib/conversation-data/adapter-helpers.ts

@@ -4,8 +4,23 @@ import type {
     ConversationMessagePhase,
     ConversationMessageRole,
     ConversationSource,
+    ListConversationsForPathOptions,
 } from './types';
 
+export const isWithinUpdatedWindow = (
+    updatedAtMs: number | null | undefined,
+    options: Pick<ListConversationsForPathOptions, 'updatedAfterMs' | 'updatedBeforeMs'>,
+) => {
+    const comparableUpdatedAtMs = updatedAtMs ?? 0;
+    if (options.updatedAfterMs !== undefined && comparableUpdatedAtMs < options.updatedAfterMs) {
+        return false;
+    }
+    if (options.updatedBeforeMs !== undefined && comparableUpdatedAtMs > options.updatedBeforeMs) {
+        return false;
+    }
+    return true;
+};
+
 export const toDateMs = (value: string | number | null | undefined): number | null => {
     if (typeof value === 'number') {
         return Number.isFinite(value) ? value : null;
@@ -36,8 +51,12 @@ export const decodeFileUri = (value: string | null | undefined): string | null =
         }
         return pathname.replace(/^\/([A-Za-z]:)/u, '$1');
     } catch {
-        const pathValue = decodeURIComponent(value.slice('file://'.length));
-        return pathValue.replace(/^\/([A-Za-z]:)/u, '$1');
+        const rawPathValue = value.slice('file://'.length);
+        try {
+            return decodeURIComponent(rawPathValue).replace(/^\/([A-Za-z]:)/u, '$1');
+        } catch {
+            return rawPathValue.replace(/^\/([A-Za-z]:)/u, '$1');
+        }
     }
 };
 
@@ -48,10 +67,13 @@ export const createDeepLinks = (
     native: string | null = null,
 ): ConversationDeepLinks => ({
     native,
-    spiracha: `spiracha://conversation/${source}/${id}`,
+    spiracha: `spiracha://conversation/${source}/${encodeURIComponent(id)}`,
     ui: uiPath,
 });
 
+export const createConversationUiPath = (routeSegment: string, id: string) =>
+    `/${routeSegment}/${encodeURIComponent(id)}`;
+
 export const normalizeRole = (role: string | null | undefined): ConversationMessageRole => {
     if (role === 'assistant' || role === 'system' || role === 'tool' || role === 'user') {
         return role;

package/src/lib/conversation-data/antigravity-adapter.ts

@@ -5,9 +5,17 @@ import {
 } from '../antigravity-db';
 import type { AntigravityConversation } from '../antigravity-exporter-types';
 import { resolveAntigravityRoots } from '../antigravity-exporter-types';
+import { mapWithConcurrency } from '../concurrency';
 import { cleanInlineTitle } from '../shared';
 import { runWithTranscriptLoadLimit } from '../transcript-load-limiter';
-import { createDeepLinks, decodeFileUri, finalizeMessages } from './adapter-helpers';
+import { getFileFingerprint, hashCacheKeyPartsIterable, withCachedJson } from '../ui-cache';
+import {
+    createConversationUiPath,
+    createDeepLinks,
+    decodeFileUri,
+    finalizeMessages,
+    isWithinUpdatedWindow,
+} from './adapter-helpers';
 import { selectConversationMessages } from './message-selector';
 import { getConversationPathMatch, getFirstConversationPathMatch } from './path-match';
 import type {
@@ -27,22 +35,33 @@ const getWorkspacePath = (conversation: AntigravityConversation) =>
     conversation.workspaceFolder ?? decodeFileUri(conversation.workspaceUri);
 
 const stripTrailingPathPunctuation = (value: string) => value.replace(/[),.;:\]`]+$/u, '');
+const PATH_REFERENCE_FALLBACK_LIMIT = 100;
+const PATH_REFERENCE_CONCURRENCY = 4;
 
 const extractAbsolutePathReferences = (text: string): string[] => {
     return [...new Set((text.match(/\/[^\s"'`)\]]+/gu) ?? []).map(stripTrailingPathPunctuation))];
 };
 
 const readMessages = async (conversation: AntigravityConversation) => {
-    const messages = await runWithTranscriptLoadLimit(() => readAntigravityConversationMessages(conversation), {
-        id: conversation.conversationId,
-        path: conversation.transcriptPath ?? conversation.conversationPath ?? undefined,
-        source: 'antigravity-api',
-    });
+    const load = () =>
+        runWithTranscriptLoadLimit(() => readAntigravityConversationMessages(conversation), {
+            id: conversation.conversationId,
+            path: conversation.transcriptPath ?? conversation.conversationPath ?? undefined,
+            source: 'antigravity-api',
+        });
+    const transcriptPath = conversation.transcriptPath;
+    const messages = transcriptPath
+        ? await getFileFingerprint(transcriptPath)
+              .then((fingerprint) =>
+                  withCachedJson(`antigravity-api-messages-${hashCacheKeyPartsIterable([fingerprint])}`, load),
+              )
+              .catch(load)
+        : await load();
     return finalizeMessages(
         messages.map(
-            (message): ConversationMessage => ({
+            (message, entryIndex): ConversationMessage => ({
                 ...message,
-                id: `${conversation.conversationId}:${message.order}:${message.role}:${message.phase}`,
+                id: `${conversation.conversationId}:${message.order}:${message.role}:${message.phase}:${entryIndex}`,
                 metadata: {
                     ...message.metadata,
                     model: conversation.model,
@@ -70,7 +89,7 @@ const buildConversation = async (
         deepLinks: createDeepLinks(
             'antigravity',
             conversation.conversationId,
-            `/antigravity-conversations/${conversation.conversationId}`,
+            createConversationUiPath('antigravity-conversations', conversation.conversationId),
         ),
         id: conversation.conversationId,
         matches,
@@ -90,20 +109,6 @@ const buildConversation = async (
     };
 };
 
-const isWithinUpdatedWindow = (
-    conversation: AntigravityConversation,
-    options: Pick<ListConversationsForPathOptions, 'updatedAfterMs' | 'updatedBeforeMs'>,
-) => {
-    const updatedAtMs = conversation.lastUpdatedAtMs ?? conversation.conversationMtimeMs ?? 0;
-    if (options.updatedAfterMs !== undefined && updatedAtMs < options.updatedAfterMs) {
-        return false;
-    }
-    if (options.updatedBeforeMs !== undefined && updatedAtMs > options.updatedBeforeMs) {
-        return false;
-    }
-    return true;
-};
-
 const getReferencedPathMatch = async (
     requestedPath: string,
     messages: ConversationMessage[],
@@ -116,9 +121,10 @@ const listAntigravityConversationsForPath = async (options: ListConversationsFor
     const roots = getRoots(options);
     const conversations = await listAntigravityConversations(roots);
     const result: ConversationDetail[] = [];
+    const pathReferenceCandidates: AntigravityConversation[] = [];
 
     for (const conversation of conversations) {
-        if (!isWithinUpdatedWindow(conversation, options)) {
+        if (!isWithinUpdatedWindow(conversation.lastUpdatedAtMs ?? conversation.conversationMtimeMs, options)) {
             continue;
         }
 
@@ -129,13 +135,32 @@ const listAntigravityConversationsForPath = async (options: ListConversationsFor
             continue;
         }
 
-        const messages = await readMessages(conversation);
-        const referencedPathMatch = await getReferencedPathMatch(options.cwd, messages);
-        if (referencedPathMatch) {
-            result.push(await buildConversation(conversation, [referencedPathMatch], options, messages));
-        }
+        pathReferenceCandidates.push(conversation);
     }
 
+    const referencedConversations = await mapWithConcurrency(
+        pathReferenceCandidates.slice(0, PATH_REFERENCE_FALLBACK_LIMIT),
+        PATH_REFERENCE_CONCURRENCY,
+        async (conversation) => {
+            let messages: ConversationMessage[];
+            try {
+                messages = await readMessages(conversation);
+            } catch (error) {
+                console.warn('[spiracha:antigravity] skipped unreadable path-reference transcript', {
+                    conversationId: conversation.conversationId,
+                    error: error instanceof Error ? error.message : String(error),
+                });
+                return null;
+            }
+            const referencedPathMatch = await getReferencedPathMatch(options.cwd, messages);
+            if (referencedPathMatch) {
+                return buildConversation(conversation, [referencedPathMatch], options, messages);
+            }
+            return null;
+        },
+    );
+    result.push(...referencedConversations.flatMap((conversation) => (conversation ? [conversation] : [])));
+
     return result;
 };
 

package/src/lib/conversation-data/claude-code-adapter.ts

@@ -1,6 +1,6 @@
 import {
     deleteClaudeCodeSession,
-    listClaudeCodeSessionsForGroup,
+    listClaudeCodeSessionTranscriptsForGroup,
     listClaudeCodeWorkspaceGroups,
     readClaudeCodeSessionTranscript,
 } from '../claude-code-db';
@@ -11,12 +11,15 @@ import type {
     ClaudeCodeTranscriptPart,
 } from '../claude-code-exporter-types';
 import { getClaudeCodeAssistantMessagePhase, resolveClaudeCodeProjectsDir } from '../claude-code-exporter-types';
+import { mapWithConcurrency } from '../concurrency';
 import { cleanInlineTitle } from '../shared';
 import { runWithTranscriptLoadLimit } from '../transcript-load-limiter';
 import {
+    createConversationUiPath,
     createDeepLinks,
     createTextMessage,
     finalizeMessages,
+    isWithinUpdatedWindow,
     normalizeAssistantPhase,
     normalizeRole,
     toDateMs,
@@ -33,6 +36,8 @@ import type {
     ListConversationsForPathOptions,
 } from './types';
 
+const CLAUDE_CONVERSATION_HYDRATION_CONCURRENCY = 4;
+
 const getProjectsDir = (options: { locations?: { claudeCodeProjectsDir?: string } }) =>
     options.locations?.claudeCodeProjectsDir ?? resolveClaudeCodeProjectsDir();
 
@@ -89,6 +94,19 @@ const partToMessages = (
         });
     }
 
+    if (part.type === 'attachment') {
+        const attachmentLabel = part.attachmentType?.trim() || 'file';
+        return createTextMessage({
+            createdAtMs,
+            id: baseId,
+            metadata: { attachmentType: part.attachmentType ?? null },
+            order: partIndex,
+            phase: 'unknown',
+            role: normalizeRole(entry.role),
+            text: part.text?.trim() || `[Attachment: ${attachmentLabel}]`,
+        });
+    }
+
     return [];
 };
 
@@ -122,7 +140,11 @@ const buildConversation = async (
 
     return {
         createdAtMs: session.createdAtMs,
-        deepLinks: createDeepLinks('claude-code', session.sessionId, `/claude-code-sessions/${session.sessionId}`),
+        deepLinks: createDeepLinks(
+            'claude-code',
+            session.sessionId,
+            createConversationUiPath('claude-code-sessions', session.sessionId),
+        ),
         id: session.sessionId,
         matches,
         messageCount: options.includeMessages ? allMessages.length : session.messageCount,
@@ -155,10 +177,14 @@ const listClaudeConversationsForPath = async (
             continue;
         }
 
-        const sessions = await listClaudeCodeSessionsForGroup(group.key, projectsDir);
-        for (const session of sessions) {
-            conversations.push(await buildConversation(session, projectsDir, [match], options));
-        }
+        const transcripts = (await listClaudeCodeSessionTranscriptsForGroup(group.key, projectsDir)).filter(
+            (transcript) => isWithinUpdatedWindow(transcript.session.lastActiveAtMs, options),
+        );
+        conversations.push(
+            ...(await mapWithConcurrency(transcripts, CLAUDE_CONVERSATION_HYDRATION_CONCURRENCY, (transcript) =>
+                buildConversation(transcript.session, projectsDir, [match], options, transcript),
+            )),
+        );
     }
 
     return conversations;