spiracha 2.1.0 → 2.2.0

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

@@ -1,4 +1,5 @@
 import {
+    CodexThreadNotFoundError,
     deleteCodexThread,
     getThreadBrowseData,
     listScopedThreads,
@@ -9,14 +10,22 @@ import { parseCodexTranscriptFile } from '../codex-thread-parser';
 import type { ThreadRow } from '../codex-thread-types';
 import { cleanInlineTitle } from '../shared';
 import { runWithTranscriptLoadLimit } from '../transcript-load-limiter';
+import {
+    createConversationUiPath,
+    createDeepLinks,
+    createTextMessage,
+    finalizeMessages,
+    isWithinUpdatedWindow,
+    normalizeAssistantPhase,
+    normalizeRole,
+    toDateMs,
+} from './adapter-helpers';
 import { selectConversationMessages } from './message-selector';
 import { getConversationPathMatch } from './path-match';
 import type {
     ConversationAdapter,
     ConversationDetail,
     ConversationMessage,
-    ConversationMessagePhase,
-    ConversationMessageRole,
     ConversationPathMatch,
     DeleteConversationOptions,
     GetConversationOptions,
@@ -35,36 +44,6 @@ const toCreatedAtMs = (thread: ThreadRow) => {
     return thread.created_at_ms ?? thread.created_at * 1000;
 };
 
-const buildCodexDeepLinks = (id: string) => ({
-    native: `codex://threads/${id}`,
-    spiracha: `spiracha://conversation/codex/${id}`,
-    ui: `/threads/${id}`,
-});
-
-const normalizeRole = (role: string): ConversationMessageRole => {
-    if (role === 'assistant' || role === 'user' || role === 'system') {
-        return role;
-    }
-
-    return 'unknown';
-};
-
-const normalizeMessagePhase = (event: MessageEvent): ConversationMessagePhase => {
-    if (event.role !== 'assistant') {
-        return 'unknown';
-    }
-
-    if (event.phase === 'final_answer' || event.phase === 'final') {
-        return 'final_answer';
-    }
-
-    if (event.phase === 'commentary' || event.isHiddenByDefault) {
-        return 'commentary';
-    }
-
-    return 'final_answer';
-};
-
 const toMessageEventMessage = (event: MessageEvent): ConversationMessage | null => {
     const text = event.text.trim();
     if (!text) {
@@ -72,14 +51,17 @@ const toMessageEventMessage = (event: MessageEvent): ConversationMessage | null
     }
 
     return {
-        createdAtMs: event.timestamp ? Date.parse(event.timestamp) : null,
+        createdAtMs: toDateMs(event.timestamp),
         id: `codex:${event.sequence}`,
         metadata: {
             model: event.model,
             variant: event.variant,
         },
         order: event.sequence,
-        phase: normalizeMessagePhase(event),
+        phase:
+            event.role === 'assistant'
+                ? normalizeAssistantPhase(event.isHiddenByDefault ? 'commentary' : event.phase, 'unknown')
+                : 'unknown',
         role: normalizeRole(event.role),
         text,
     };
@@ -87,37 +69,41 @@ const toMessageEventMessage = (event: MessageEvent): ConversationMessage | null
 
 const toToolMessage = (event: ThreadEvent): ConversationMessage | null => {
     if (event.kind === 'tool_call') {
-        return {
-            createdAtMs: event.timestamp ? Date.parse(event.timestamp) : null,
-            id: `codex:${event.sequence}`,
-            metadata: {
-                callId: event.callId,
-                command: event.command,
-                name: event.name,
-                workdir: event.workdir,
-            },
-            order: event.sequence,
-            phase: 'tool_call',
-            role: 'tool',
-            text: event.command ?? event.name,
-        };
+        return (
+            createTextMessage({
+                createdAtMs: toDateMs(event.timestamp),
+                id: `codex:${event.sequence}`,
+                metadata: {
+                    callId: event.callId,
+                    command: event.command,
+                    name: event.name,
+                    workdir: event.workdir,
+                },
+                order: event.sequence,
+                phase: 'tool_call',
+                role: 'tool',
+                text: event.command || event.name,
+            })[0] ?? null
+        );
     }
 
     if (event.kind === 'tool_output') {
         const text = event.summary || event.outputText;
-        return {
-            createdAtMs: event.timestamp ? Date.parse(event.timestamp) : null,
-            id: `codex:${event.sequence}`,
-            metadata: {
-                callId: event.callId,
-                exitCode: event.exitCode,
-                wallTime: event.wallTime,
-            },
-            order: event.sequence,
-            phase: 'tool_output',
-            role: 'tool',
-            text,
-        };
+        return (
+            createTextMessage({
+                createdAtMs: toDateMs(event.timestamp),
+                id: `codex:${event.sequence}`,
+                metadata: {
+                    callId: event.callId,
+                    exitCode: event.exitCode,
+                    wallTime: event.wallTime,
+                },
+                order: event.sequence,
+                phase: 'tool_output',
+                role: 'tool',
+                text,
+            })[0] ?? null
+        );
     }
 
     return null;
@@ -125,6 +111,10 @@ const toToolMessage = (event: ThreadEvent): ConversationMessage | null => {
 
 const toConversationMessage = (event: ThreadEvent): ConversationMessage | null => {
     if (event.kind === 'message') {
+        if (event.isHiddenByDefault) {
+            return null;
+        }
+
         return toMessageEventMessage(event);
     }
 
@@ -132,7 +122,7 @@ const toConversationMessage = (event: ThreadEvent): ConversationMessage | null =
         const text = event.summary.join('\n').trim();
         return text
             ? {
-                  createdAtMs: event.timestamp ? Date.parse(event.timestamp) : null,
+                  createdAtMs: toDateMs(event.timestamp),
                   id: `codex:${event.sequence}`,
                   metadata: {
                       hasEncryptedContent: event.hasEncryptedContent,
@@ -149,22 +139,33 @@ const toConversationMessage = (event: ThreadEvent): ConversationMessage | null =
 };
 
 const readCodexMessages = async (thread: ThreadRow): Promise<ConversationMessage[]> => {
-    const transcript = await runWithTranscriptLoadLimit(
-        () =>
-            parseCodexTranscriptFile(thread.rollout_path, {
-                includeRaw: false,
-            }),
-        {
-            id: thread.id,
-            path: thread.rollout_path,
-            source: 'codex-api',
-        },
-    );
+    let transcript: Awaited<ReturnType<typeof parseCodexTranscriptFile>>;
+    try {
+        transcript = await runWithTranscriptLoadLimit(
+            () =>
+                parseCodexTranscriptFile(thread.rollout_path, {
+                    includeRaw: false,
+                }),
+            {
+                id: thread.id,
+                path: thread.rollout_path,
+                source: 'codex-api',
+            },
+        );
+    } catch (error) {
+        if (error && typeof error === 'object' && 'code' in error && error.code === 'ENOENT') {
+            return [];
+        }
 
-    return transcript.events.flatMap((event) => {
-        const message = toConversationMessage(event);
-        return message ? [message] : [];
-    });
+        throw error;
+    }
+
+    return finalizeMessages(
+        transcript.events.flatMap((event) => {
+            const message = toConversationMessage(event);
+            return message ? [message] : [];
+        }),
+    );
 };
 
 const buildCodexConversation = async (
@@ -179,7 +180,12 @@ const buildCodexConversation = async (
 
     return {
         createdAtMs: toCreatedAtMs(thread),
-        deepLinks: buildCodexDeepLinks(thread.id),
+        deepLinks: createDeepLinks(
+            'codex',
+            thread.id,
+            createConversationUiPath('threads', thread.id),
+            `codex://threads/${encodeURIComponent(thread.id)}`,
+        ),
         id: thread.id,
         matches,
         messageCount: options.includeMessages ? allMessages.length : null,
@@ -221,8 +227,13 @@ const listCodexConversationsForPath = async (
     options: ListConversationsForPathOptions,
 ): Promise<ConversationDetail[]> => {
     const dbPath = getCodexDbPath(options);
+    if (!(await Bun.file(dbPath).exists())) {
+        return [];
+    }
     const threads = listScopedThreads(dbPath, null);
-    const matchedThreads = await filterThreadsForPath(threads, options.cwd);
+    const matchedThreads = (await filterThreadsForPath(threads, options.cwd)).filter(({ thread }) =>
+        isWithinUpdatedWindow(toTimestampMs(thread), options),
+    );
 
     return Promise.all(
         matchedThreads.map(({ matches, thread }) =>
@@ -240,7 +251,7 @@ const getCodexConversation = async (options: GetConversationOptions): Promise<Co
     try {
         browseData = getThreadBrowseData(dbPath, options.id);
     } catch (error) {
-        if (error instanceof Error && /not found/i.test(error.message)) {
+        if (error instanceof CodexThreadNotFoundError) {
             return null;
         }
 

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

@@ -12,9 +12,16 @@ import type {
 } from '../cursor-exporter-types';
 import { getCursorGlobalDbPath, resolveCursorUserDir } from '../cursor-exporter-types';
 import { collectCursorThreadsForDeletion, isCursorRunning, pruneCursorThreads } from '../cursor-recovery';
+import { getCursorTextBubblePhase, getFinalCursorAssistantTextBubbleIds } from '../cursor-transcript-phase';
 import { cleanInlineTitle } from '../shared';
 import { runWithTranscriptLoadLimit } from '../transcript-load-limiter';
-import { createDeepLinks, createTextMessage, finalizeMessages } from './adapter-helpers';
+import {
+    createConversationUiPath,
+    createDeepLinks,
+    createTextMessage,
+    finalizeMessages,
+    isWithinUpdatedWindow,
+} from './adapter-helpers';
 import { selectConversationMessages } from './message-selector';
 import { getFirstConversationPathMatch } from './path-match';
 import type {
@@ -32,21 +39,11 @@ const CURSOR_CONVERSATION_HYDRATION_CONCURRENCY = 4;
 const getUserDir = (options: { locations?: { cursorUserDir?: string } }) =>
     options.locations?.cursorUserDir ?? resolveCursorUserDir();
 
-const isWithinUpdatedWindow = (
-    thread: CursorThreadSummary,
-    options: Pick<ListConversationsForPathOptions, 'updatedAfterMs' | 'updatedBeforeMs'>,
-): boolean => {
-    const updatedAtMs = thread.lastUpdatedAtMs ?? 0;
-    if (options.updatedAfterMs !== undefined && updatedAtMs < options.updatedAfterMs) {
-        return false;
-    }
-    if (options.updatedBeforeMs !== undefined && updatedAtMs > options.updatedBeforeMs) {
-        return false;
-    }
-    return true;
-};
-
-const bubbleToMessages = (bubble: CursorBubble, order: number): ConversationMessage[] => {
+const bubbleToMessages = (
+    bubble: CursorBubble,
+    finalAssistantTextBubbleIds: Set<string>,
+    order: number,
+): ConversationMessage[] => {
     const thinking = createTextMessage({
         createdAtMs: bubble.createdAtMs,
         id: `${bubble.bubbleId}:thinking`,
@@ -59,27 +56,41 @@ const bubbleToMessages = (bubble: CursorBubble, order: number): ConversationMess
         createdAtMs: bubble.createdAtMs,
         id: bubble.bubbleId,
         order,
-        phase: bubble.kind === 'assistant' ? 'final_answer' : 'unknown',
+        phase: getCursorTextBubblePhase(bubble, finalAssistantTextBubbleIds) ?? 'unknown',
         role: bubble.kind === 'assistant' ? 'assistant' : bubble.kind === 'user' ? 'user' : 'unknown',
         text: bubble.text,
     });
-    const tool = bubble.toolCall
+    const toolCall = bubble.toolCall
+        ? createTextMessage({
+              createdAtMs: bubble.createdAtMs,
+              id: `${bubble.bubbleId}:tool_call`,
+              metadata: { callId: bubble.toolCall.callId, status: bubble.toolCall.status },
+              order,
+              phase: 'tool_call',
+              role: 'tool',
+              text: [bubble.toolCall.name, bubble.toolCall.argumentsText].filter(Boolean).join('\n'),
+          })
+        : [];
+    const toolOutput = bubble.toolCall
         ? createTextMessage({
               createdAtMs: bubble.createdAtMs,
-              id: `${bubble.bubbleId}:tool`,
+              id: `${bubble.bubbleId}:tool_output`,
               metadata: { callId: bubble.toolCall.callId, status: bubble.toolCall.status },
               order,
-              phase: bubble.toolCall.resultText ? 'tool_output' : 'tool_call',
+              phase: 'tool_output',
               role: 'tool',
-              text: bubble.toolCall.resultText ?? bubble.toolCall.argumentsText ?? bubble.toolCall.name,
+              text: bubble.toolCall.resultText,
           })
         : [];
 
-    return [...thinking, ...text, ...tool];
+    return [...thinking, ...text, ...toolCall, ...toolOutput];
 };
 
 const transcriptToMessages = (transcript: CursorThreadTranscript) => {
-    return finalizeMessages(transcript.bubbles.flatMap((bubble, order) => bubbleToMessages(bubble, order)));
+    const finalAssistantTextBubbleIds = getFinalCursorAssistantTextBubbleIds(transcript.bubbles);
+    return finalizeMessages(
+        transcript.bubbles.flatMap((bubble, order) => bubbleToMessages(bubble, finalAssistantTextBubbleIds, order)),
+    );
 };
 
 const getWorkspacePath = (group: CursorWorkspaceGroup) => {
@@ -111,7 +122,11 @@ const buildConversation = async (
 
     return {
         createdAtMs: thread.createdAtMs,
-        deepLinks: createDeepLinks('cursor', thread.composerId, `/cursor-threads/${thread.composerId}`),
+        deepLinks: createDeepLinks(
+            'cursor',
+            thread.composerId,
+            createConversationUiPath('cursor-threads', thread.composerId),
+        ),
         id: thread.composerId,
         matches,
         messageCount: options.includeMessages ? allMessages.length : thread.bubbleCount,
@@ -120,7 +135,6 @@ const buildConversation = async (
             bubbleBytes: thread.bubbleBytes,
             bucketId: thread.bucketId,
             mode: thread.mode,
-            transcriptDirs: thread.transcriptDirs,
         },
         source: 'cursor',
         title: cleanInlineTitle(thread.name),
@@ -132,7 +146,7 @@ const buildConversation = async (
 
 const listCursorConversationsForPath = async (options: ListConversationsForPathOptions) => {
     const userDir = getUserDir(options);
-    const groups = await listCursorWorkspaceGroups(userDir, { updatedAfterMs: options.updatedAfterMs });
+    const groups = await listCursorWorkspaceGroups(userDir);
     const candidates: { group: CursorWorkspaceGroup; match: ConversationPathMatch; thread: CursorThreadSummary }[] = [];
 
     for (const group of groups) {
@@ -142,10 +156,9 @@ const listCursorConversationsForPath = async (options: ListConversationsForPathO
         }
         const threads = await listCursorThreadsForGroup(group, userDir, {
             includeTranscriptDirs: false,
-            updatedAfterMs: options.updatedAfterMs,
         });
         for (const thread of threads) {
-            if (!isWithinUpdatedWindow(thread, options)) {
+            if (!isWithinUpdatedWindow(thread.lastUpdatedAtMs, options)) {
                 continue;
             }
 
@@ -175,20 +188,21 @@ const getCursorConversation = async (options: GetConversationOptions): Promise<C
     return null;
 };
 
-const deleteCursorConversation = async (options: DeleteConversationOptions) => {
+export const deleteCursorConversation = async (
+    options: DeleteConversationOptions,
+    checkCursorRunning: () => Promise<boolean> = isCursorRunning,
+) => {
     const userDir = getUserDir(options);
-    if (!options.locations?.cursorUserDir && (await isCursorRunning())) {
+    if (await checkCursorRunning()) {
         throw new Error(
             'Quit Cursor before deleting. It rewrites chat history on exit, which can resurrect deleted threads.',
         );
     }
 
-    const existing = await getCursorConversation(options);
-    if (!existing) {
+    const threads = await collectCursorThreadsForDeletion([options.id], userDir);
+    if (threads.length === 0) {
         return { deletedFiles: [], deletedIds: [] };
     }
-
-    const threads = await collectCursorThreadsForDeletion([options.id], userDir);
     const deletedFiles = threads.flatMap((thread) => thread.transcriptDirs);
     const result = await pruneCursorThreads(threads, true, userDir);
     return {

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

@@ -1,6 +1,7 @@
+import { mapWithConcurrency } from '../concurrency';
 import {
     deleteGrokSession,
-    listGrokSessionsForGroup,
+    listGrokSessionTranscriptsForGroup,
     listGrokWorkspaceGroups,
     readGrokSessionTranscript,
     resolveGrokSessionsDir,
@@ -15,9 +16,11 @@ import { getFinalGrokAssistantTextPartIds, getGrokTextPartPhase } from '../grok-
 import { cleanInlineTitle } from '../shared';
 import { runWithTranscriptLoadLimit } from '../transcript-load-limiter';
 import {
+    createConversationUiPath,
     createDeepLinks,
     createTextMessage,
     finalizeMessages,
+    isWithinUpdatedWindow,
     normalizeAssistantPhase,
     normalizeRole,
 } from './adapter-helpers';
@@ -33,6 +36,8 @@ import type {
     ListConversationsForPathOptions,
 } from './types';
 
+const GROK_CONVERSATION_HYDRATION_CONCURRENCY = 4;
+
 const getSessionsDir = (options: { locations?: { grokSessionsDir?: string } }) =>
     options.locations?.grokSessionsDir ?? resolveGrokSessionsDir();
 
@@ -129,7 +134,11 @@ const buildConversation = async (
 
     return {
         createdAtMs: session.createdAtMs,
-        deepLinks: createDeepLinks('grok', session.sessionId, `/grok-sessions/${session.sessionId}`),
+        deepLinks: createDeepLinks(
+            'grok',
+            session.sessionId,
+            createConversationUiPath('grok-sessions', session.sessionId),
+        ),
         id: session.sessionId,
         matches,
         messageCount: options.includeMessages ? allMessages.length : session.messageCount,
@@ -161,10 +170,14 @@ const listGrokConversationsForPath = async (options: ListConversationsForPathOpt
         if (!match) {
             continue;
         }
-        const sessions = await listGrokSessionsForGroup(group.key, sessionsDir);
-        for (const session of sessions) {
-            conversations.push(await buildConversation(session, sessionsDir, [match], options));
-        }
+        const transcripts = (await listGrokSessionTranscriptsForGroup(group.key, sessionsDir)).filter((transcript) =>
+            isWithinUpdatedWindow(transcript.session.lastActiveAtMs, options),
+        );
+        conversations.push(
+            ...(await mapWithConcurrency(transcripts, GROK_CONVERSATION_HYDRATION_CONCURRENCY, (transcript) =>
+                buildConversation(transcript.session, sessionsDir, [match], options, transcript),
+            )),
+        );
     }
 
     return conversations;

package/src/lib/conversation-data/index.ts

@@ -104,7 +104,7 @@ const getEnabledSources = (sources: ListConversationsForPathOptions['sources']):
         return SOURCE_INFOS.map((sourceInfo) => sourceInfo.source);
     }
 
-    return sources;
+    return [...new Set(sources)];
 };
 
 const isAllSourcesRequest = (sources: ListConversationsForPathOptions['sources']) => !sources || sources === 'all';
@@ -118,8 +118,16 @@ const decodeCursor = (cursor: string | null | undefined) => {
         return 0;
     }
 
-    const parsed = Number.parseInt(Buffer.from(cursor, 'base64url').toString('utf8'), 10);
-    return Number.isFinite(parsed) && parsed >= 0 ? parsed : 0;
+    const decoded = Buffer.from(cursor, 'base64url').toString('utf8');
+    if (!/^\d+$/u.test(decoded)) {
+        throw new Error('Invalid conversation pagination cursor.');
+    }
+
+    const parsed = Number(decoded);
+    if (!Number.isSafeInteger(parsed) || parsed < 0) {
+        throw new Error('Invalid conversation pagination cursor.');
+    }
+    return parsed;
 };
 
 const encodeCursor = (offset: number) => Buffer.from(String(offset), 'utf8').toString('base64url');
@@ -157,7 +165,7 @@ const sortConversations = (conversations: Awaited<ReturnType<ConversationAdapter
     );
 };
 
-export const listConversationSources = async (): Promise<ConversationSourceInfo[]> => SOURCE_INFOS;
+export const listConversationSources = async (): Promise<ConversationSourceInfo[]> => [...SOURCE_INFOS];
 
 const listSourceConversationsForPath = async (
     source: ConversationSource,
@@ -175,6 +183,10 @@ const listSourceConversationsForPath = async (
         if (!ignoreSourceFailures) {
             throw error;
         }
+        console.warn(`[spiracha:conversation-data] skipped ${source} during all-source collection`, {
+            error: error instanceof Error ? error.message : String(error),
+            source,
+        });
         return [];
     }
 };
@@ -314,14 +326,21 @@ const refFromPathSegmentAt = (segments: string[], index: number): ResolvedConver
 };
 
 const refFromPathSegments = (segments: string[]): ResolvedConversationRef | null => {
-    for (let index = 0; index < segments.length - 1; index += 1) {
-        const ref = refFromPathSegmentAt(segments, index);
-        if (ref) {
-            return ref;
-        }
+    if (
+        segments[0] === 'api' &&
+        segments[1] === 'v1' &&
+        segments[2] === 'conversations' &&
+        (segments.length === 5 || (segments.length === 6 && segments[5] === 'export'))
+    ) {
+        return refFromPathSegmentAt(segments, 2);
     }
 
-    return null;
+    if (segments[0] === 'app') {
+        return refFromPathSegments(segments.slice(1));
+    }
+
+    const expectedLength = segments[0] === 'conversations' ? 3 : 2;
+    return segments.length === expectedLength ? refFromPathSegmentAt(segments, 0) : null;
 };
 
 const parseUrlRef = (ref: string): ResolvedConversationRef | null => {

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

@@ -1,3 +1,4 @@
+import { mapWithConcurrency } from '../concurrency';
 import {
     deleteKiroSession,
     listKiroSessionsForGroup,
@@ -15,9 +16,11 @@ import { getFinalKiroAssistantMessageEntryIds, getKiroMessagePhase } from '../ki
 import { cleanInlineTitle } from '../shared';
 import { runWithTranscriptLoadLimit } from '../transcript-load-limiter';
 import {
+    createConversationUiPath,
     createDeepLinks,
     createTextMessage,
     finalizeMessages,
+    isWithinUpdatedWindow,
     normalizeAssistantPhase,
     normalizeRole,
     toDateMs,
@@ -34,6 +37,8 @@ import type {
     ListConversationsForPathOptions,
 } from './types';
 
+const KIRO_CONVERSATION_HYDRATION_CONCURRENCY = 4;
+
 const getSessionsDir = (options: { locations?: { kiroWorkspaceSessionsDir?: string } }) =>
     options.locations?.kiroWorkspaceSessionsDir ?? resolveKiroWorkspaceSessionsDir();
 
@@ -98,7 +103,11 @@ const buildConversation = async (
 
     return {
         createdAtMs: session.createdAtMs,
-        deepLinks: createDeepLinks('kiro', session.sessionId, `/kiro-sessions/${session.sessionId}`),
+        deepLinks: createDeepLinks(
+            'kiro',
+            session.sessionId,
+            createConversationUiPath('kiro-sessions', session.sessionId),
+        ),
         id: session.sessionId,
         matches,
         messageCount: options.includeMessages ? allMessages.length : session.messageCount,
@@ -128,10 +137,14 @@ const listKiroConversationsForPath = async (options: ListConversationsForPathOpt
         if (!match) {
             continue;
         }
-        const sessions = await listKiroSessionsForGroup(group.key, sessionsDir);
-        for (const session of sessions) {
-            conversations.push(await buildConversation(session, sessionsDir, [match], options));
-        }
+        const sessions = (await listKiroSessionsForGroup(group.key, sessionsDir)).filter((session) =>
+            isWithinUpdatedWindow(session.lastActiveAtMs, options),
+        );
+        conversations.push(
+            ...(await mapWithConcurrency(sessions, KIRO_CONVERSATION_HYDRATION_CONCURRENCY, (session) =>
+                buildConversation(session, sessionsDir, [match], options),
+            )),
+        );
     }
 
     return conversations;

package/src/lib/conversation-data/message-selector.ts

@@ -14,12 +14,9 @@ const selectLastAssistantMessage = (messages: ConversationMessage[]) => {
     return latestByOrder(messages.filter((message) => message.role === 'assistant'));
 };
 
-// Not every integration can identify final answers. In that case, API list/export defaults still
-// return the latest assistant message instead of silently omitting the conversation.
 const selectLastFinalAnswer = (messages: ConversationMessage[]) => {
-    return (
-        latestByOrder(messages.filter((message) => message.role === 'assistant' && message.phase === 'final_answer')) ??
-        selectLastAssistantMessage(messages)
+    return latestByOrder(
+        messages.filter((message) => message.role === 'assistant' && message.phase === 'final_answer'),
     );
 };