fix(source-chat): adopt session transcript

  before claiming the shared list and restore console spy
  safely

Author: AugustoSandim

frontend/src/lib/hooks/use-source-chat.test.tsx

@@ -5,7 +5,7 @@ import { QueryClient, QueryClientProvider } from '@tanstack/react-query'
 import { describe, it, expect, vi, beforeEach } from 'vitest'
 import { useSourceChat } from './use-source-chat'
 import { sourceChatApi } from '@/lib/api/source-chat'
-import { SourceChatSession, SourceChatSessionWithMessages } from '@/lib/types/api'
+import { SourceChatSession, SourceChatSessionWithMessages, SourceChatMessage } from '@/lib/types/api'
 
 // useTranslation is mocked globally in setup.ts (t returns the key string).
 
@@ -451,19 +451,24 @@ describe('useSourceChat sendMessage streaming', () => {
     vi.mocked(sourceChatApi.sendMessage).mockRejectedValue(axiosError)
 
     const consoleError = vi.spyOn(console, 'error').mockImplementation(() => {})
-    const { result } = renderHook(() => useSourceChat('source:1'), { wrapper: makeWrapper() })
+    // A failing assertion must not leave the spy installed — it would silence
+    // console.error for every test that runs after this one.
+    try {
+      const { result } = renderHook(() => useSourceChat('source:1'), { wrapper: makeWrapper() })
 
-    await waitFor(() => expect(result.current.currentSessionId).toBe('session:1'))
+      await waitFor(() => expect(result.current.currentSessionId).toBe('session:1'))
 
-    await act(async () => {
-      await result.current.sendMessage('hello')
-    })
+      await act(async () => {
+        await result.current.sendMessage('hello')
+      })
 
-    expect(consoleError).toHaveBeenCalled()
-    const logged = JSON.stringify(consoleError.mock.calls)
-    expect(logged).not.toContain('secret-token')
-    expect(logged).not.toContain('Authorization')
-    consoleError.mockRestore()
+      expect(consoleError).toHaveBeenCalled()
+      const logged = JSON.stringify(consoleError.mock.calls)
+      expect(logged).not.toContain('secret-token')
+      expect(logged).not.toContain('Authorization')
+    } finally {
+      consoleError.mockRestore()
+    }
   })
 
   it('keeps a send on its own session when the user switches during pre-send hydration', async () => {
@@ -528,6 +533,68 @@ describe('useSourceChat sendMessage streaming', () => {
     expect(result.current.messages).toEqual(otherMessages)
   })
 
+  it("adopts the switched-to session's cached messages before a submit claims the shared list", async () => {
+    const otherSession: SourceChatSession = { ...session, id: 'session:2', title: 'Other' }
+    const aMessages = [
+      { id: 'msg-a', type: 'ai' as const, content: 'answered in A', timestamp: '2026-01-01T00:00:00Z' },
+    ]
+    const pendingInB = [
+      { id: 'msg-b-pending', type: 'human' as const, content: 'hello', timestamp: '2026-01-01T00:00:00Z' },
+    ]
+    vi.mocked(sourceChatApi.listSessions).mockResolvedValue([session, otherSession])
+    // The backend persists the exchange, so the send's final refetch sees it.
+    let bMessages: SourceChatMessage[] = pendingInB
+    vi.mocked(sourceChatApi.getSession).mockImplementation(
+      (_sourceId, sessionId) =>
+        Promise.resolve(
+          sessionId === 'session:2'
+            ? { ...otherSession, messages: bMessages }
+            : { ...session, messages: aMessages },
+        ) as any
+    )
+    vi.mocked(sourceChatApi.sendMessage).mockImplementation(() => {
+      bMessages = [
+        ...pendingInB,
+        { id: 'ai-b', type: 'ai' as const, content: 'answer', timestamp: '2026-01-01T00:00:01Z' },
+      ]
+      return Promise.resolve(
+        sseStream([{ type: 'ai_message', content: 'answer' }, { type: 'complete' }]) as any
+      )
+    })
+
+    const { result } = renderHook(() => useSourceChat('source:1'), { wrapper: makeWrapper() })
+
+    // Visit session:2 so its query is cached, then return to session:1 — the
+    // shared list belongs to session:1 again.
+    act(() => {
+      result.current.switchSession('session:2')
+    })
+    await waitFor(() => expect(result.current.messages).toEqual(pendingInB))
+    act(() => {
+      result.current.switchSession('session:1')
+    })
+    await waitFor(() => expect(result.current.messages).toEqual(aMessages))
+
+    // Submit in the same tick as the switch, before the session-query effect
+    // can swap the list over — the send must bring session:2's transcript with
+    // it instead of writing into session:1's.
+    let sendPromise!: Promise<void>
+    act(() => {
+      result.current.switchSession('session:2')
+      sendPromise = result.current.sendMessage('hello')
+    })
+
+    await act(async () => {
+      await sendPromise
+    })
+
+    // The trailing turn is one session:2 already holds server-side — reusing
+    // its id lets the backend dedup instead of appending a duplicate human turn.
+    const [, , payload] = vi.mocked(sourceChatApi.sendMessage).mock.calls[0]
+    expect(payload.message_id).toBe('msg-b-pending')
+    expect(result.current.messages.map((m) => m.content)).toEqual(['hello', 'answer'])
+  })
+
   it('rehydrates the streaming session when the user switches away and back', async () => {
     const otherSession: SourceChatSession = { ...session, id: 'session:2', title: 'Other' }
     const persisted = [

frontend/src/lib/hooks/use-source-chat.ts

@@ -9,6 +9,7 @@ import { sourceChatApi } from '@/lib/api/source-chat'
 import { selectMessageId } from '@/lib/utils/source-chat-message'
 import {
   SourceChatSession,
+  SourceChatSessionWithMessages,
   SourceChatMessage,
   SourceChatContextIndicator,
   CreateSourceChatSessionRequest,
@@ -249,7 +250,6 @@ export function useSourceChat(sourceId: string) {
 
     const streamSessionId = sessionId
     streamingSessionRef.current = streamSessionId
-    messagesSessionRef.current = streamSessionId
 
     // The turn belongs to the session it was composed in, so it is still sent
     // after the user navigates away — but the shared list then shows another
@@ -259,20 +259,45 @@ export function useSourceChat(sourceId: string) {
       currentSessionIdRef.current === streamSessionId &&
       messagesSessionRef.current === streamSessionId
 
+    // The shared list must actually represent this session before the send
+    // writes into it. A submit can land between `switchSession` (which changes
+    // the selected session) and the session-query effect (which swaps the list
+    // to that session's messages), so the list may still show the previous
+    // session's transcript here — claiming it without first applying this
+    // session's messages would append the turn and its streamed answer to the
+    // wrong transcript, and the cached-snapshot path below would never replace
+    // the list. Adopt this session's own state instead: a list that already
+    // represents the session keeps its content (it can be fresher than the
+    // cache — it carries optimistic turns), and a user who navigated away
+    // during hydration gets neither the claim nor the overwrite.
+    const adoptSessionList = (authoritative: SourceChatMessage[]): SourceChatMessage[] => {
+      if (currentSessionIdRef.current !== streamSessionId) return authoritative
+      if (messagesSessionRef.current === streamSessionId) return messagesRef.current
+      messagesSessionRef.current = streamSessionId
+      applyMessages(authoritative)
+      return messagesRef.current
+    }
+
     // `messages` only holds authoritative state once the session query has
     // resolved, and the composer is gated on `isStreaming` alone — a send can
     // land while that query is still in flight. Deriving the id from the empty
     // list would mint a fresh one for a turn the server still holds as pending,
     // and the backend would append a duplicate human turn.
     let knownMessages = messagesRef.current
-    if (!sessionJustCreated && !queryClient.getQueryData(['sourceChatSession', sourceId, streamSessionId])) {
+    const cachedSnapshot = sessionJustCreated
+      ? undefined
+      : queryClient.getQueryData<SourceChatSessionWithMessages>([
+          'sourceChatSession',
+          sourceId,
+          streamSessionId
+        ])
+    if (cachedSnapshot?.messages) {
+      knownMessages = adoptSessionList(cachedSnapshot.messages)
+    } else if (!sessionJustCreated) {
       try {
         const hydrated = await fetchSession(streamSessionId)
         if (hydrated?.messages) {
-          knownMessages = hydrated.messages
-          if (ownsMessages()) {
-            applyMessages(knownMessages)
-          }
+          knownMessages = adoptSessionList(hydrated.messages)
         }
       } catch (err) {
         console.error('Error loading chat session before send:', getLogSafeErrorMessage(err))