fix(mothership): finish an admitted turn whose POST never answered on return

Recovery left a send alone while its POST had not answered, so a turn the server
admitted and finished, whose answer never reached the client, kept the chat on
Stop with nothing to clear it. The send now counts as admitted once the loaded
chat holds its message, and recovery resolves its stream as any other.

Author: waleedlatif1

apps/sim/app/workspace/[workspaceId]/home/hooks/use-chat.dom.test.tsx

@@ -1322,6 +1322,62 @@ describe('useChat remount send recovery', () => {
     expect(getResult().isSending).toBe(true)
   })
 
+  /**
+   * The server admitted the send and finished its turn, but the POST's answer
+   * never arrived. Once the chat holds the message, a return resolves the turn
+   * rather than leaving the chat on Stop behind a POST that will not answer.
+   */
+  it('finishes an admitted turn whose POST never answered when the user returns', async () => {
+    let admitted = false
+    const history: MothershipChatHistory = {
+      id: 'chat-admitted-unanswered',
+      mode: 'agent',
+      title: 'Admitted, unanswered',
+      messages: [],
+      activeStreamId: null,
+      resources: [],
+    }
+    mockRequestJson.mockImplementation(() => {
+      const userMessageId = state.postBodies[0]?.userMessageId
+      return Promise.resolve({
+        chat: {
+          ...history,
+          messages:
+            admitted && userMessageId
+              ? [
+                  { id: userMessageId, role: 'user', content: 'Answer lost' },
+                  { id: 'saved-answer', role: 'assistant', content: 'Done.' },
+                ]
+              : [],
+        },
+      })
+    })
+    vi.stubGlobal('fetch', async (input: RequestInfo | URL, init?: RequestInit) => {
+      const url = String(input)
+      if (url === '/api/mothership/chat' && init?.method === 'POST') {
+        state.postBodies.push(JSON.parse(String(init.body)))
+        return new Promise<Response>(() => {})
+      }
+      if (url.includes('/api/mothership/chat/stream')) {
+        return Response.json({ success: true, events: [], status: 'complete' })
+      }
+      return fetchStub(input, init)
+    })
+    const { getResult } = renderUseChatInChat(history.id, history)
+    await act(async () => {
+      void getResult().sendMessage('Answer lost')
+    })
+    await waitFor(() => state.postBodies.length === 1)
+
+    admitted = true
+    await act(async () => {
+      window.dispatchEvent(new Event('online'))
+    })
+    await waitFor(() => !getResult().isSending)
+
+    expect(state.postBodies).toHaveLength(1)
+  })
+
   it('keeps re-attaching a long turn whose tails deliver events between separate network failures', async () => {
     vi.useFakeTimers({ toFake: ['setTimeout', 'clearTimeout'] })
     try {

apps/sim/app/workspace/[workspaceId]/home/hooks/use-chat.ts

@@ -3014,10 +3014,18 @@ export function useChat(
            one: it ended while nothing here was listening (its reader went silent, or a
            recovery it superseded was attached). Resolve that stream instead of
            leaving it running: its terminal state replays the rest and finalizes. A
-           send still waiting for its POST to be admitted is not such a stream: the
-           chat cannot list it yet, and recovering it would abort that POST. */
+           send whose POST has not answered yet is such a stream only once the loaded
+           chat holds its message (the server admitted it, and the answer is lost);
+           until then it may still be on its way, and recovering it would abort it. */
+        const pendingAdmission = pendingChatAdmissionRef.current
+        const admitted =
+          !pendingAdmission ||
+          (loadedStream.loaded &&
+            queryClient
+              .getQueryData<MothershipChatHistory>(mothershipChatKeys.detail(chatId))
+              ?.messages.some((message) => message.id === pendingAdmission.userMessageId) === true)
         const locallyRunningStreamId =
-          sendingRef.current && !pendingChatAdmissionRef.current
+          sendingRef.current && admitted
             ? (streamIdRef.current ?? activeTurnRef.current?.userMessageId)
             : undefined
         const streamId = loadedStream.loaded