fix(chat): probe the orphaned stream before re-sending a withdrawn send

The cleanup-abort recovery treated "no response headers yet" as "the server
never got it" and re-sent. It is not the same thing: the mothership chat route
never reads `request.signal`, so a request it had already accepted still runs
to completion — resolveOrCreateChat, persistUserMessage, and the billed turn
all commit even though the client socket is gone. Re-sending blind therefore
left the user with two chats and two billed runs for one message.

Recovery now carries the withdrawn send's `userMessageId` as a stream id
through both lanes (the live `mothership-send-message` event and the stored
one-shot handoff) and through a restored queue entry. Before re-sending, the
dispatcher polls that stream: when it resolves to a chat, the server already
has the message, so the chat is adopted instead of sent again. Only a stream
the server has no record of — a 404, i.e. genuinely never accepted — re-sends.
Timing out re-sends too, which is the safe direction.

Also corrects the root cause recorded in the comments. A Suspense hide/reveal
cannot run this cleanup: React 19 disappears layout effects only, and this is
a passive effect (verified against react-dom 19.2.4). What does run it is
StrictMode's dev double-mount and a real client-side navigation away, both
mid-flight — and because MothershipHandoffStorage consumes atomically, the
replacement mount finds nothing left to retry.

Author: waleedlatif1

apps/sim/app/workspace/[workspaceId]/home/home.tsx

@@ -341,7 +341,9 @@ export function Home({ chatId, userName, userId, tableViewsEnabled }: HomeProps)
       const detail = (e as CustomEvent<MothershipSendMessageDetail>).detail
       if (!detail?.message) return
       e.preventDefault()
-      sendMessage(detail.message, detail.fileAttachments, detail.contexts)
+      sendMessage(detail.message, detail.fileAttachments, detail.contexts, {
+        ...(detail.recoverStreamId ? { recoverStreamId: detail.recoverStreamId } : {}),
+      })
     }
     window.addEventListener(MOTHERSHIP_SEND_MESSAGE_EVENT, handler)
     return () => window.removeEventListener(MOTHERSHIP_SEND_MESSAGE_EVENT, handler)
@@ -370,7 +372,9 @@ export function Home({ chatId, userName, userId, tableViewsEnabled }: HomeProps)
     const handoff = MothershipHandoffStorage.consume(workspaceId)
     if (!handoff) return
     if (handoff.message) {
-      sendMessage(handoff.message, handoff.fileAttachments, handoff.contexts)
+      sendMessage(handoff.message, handoff.fileAttachments, handoff.contexts, {
+        ...(handoff.recoverStreamId ? { recoverStreamId: handoff.recoverStreamId } : {}),
+      })
       return
     }
     const contexts = handoff.contexts ?? []

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

@@ -1,14 +1,22 @@
 /**
  * @vitest-environment jsdom
  *
- * Regression tests for the mount-settling send loss: a send started on a
- * fresh chat surface used to be silently dropped when React ran the unmount
- * cleanup mid-flight (a Suspense hide/reveal cycles every effect shortly
- * after Home mounts), aborting the fetch before it dispatched. The fix routes
- * idle sends through the durable message queue and restores the queued entry
- * when the cleanup abort strikes before the server received the request.
+ * Regression tests for the remount send loss: a send started on a fresh chat
+ * surface was silently dropped when the hook's unmount cleanup ran mid-flight
+ * and aborted the POST. Two things run that cleanup while an auto-send from a
+ * cross-route handoff is still in flight — StrictMode's dev double-mount, and a
+ * real client-side navigation away — and because `MothershipHandoffStorage`
+ * consumes atomically, the second mount finds nothing left to retry.
+ *
+ * (A Suspense hide/reveal does NOT cause this: React 19 disappears layout
+ * effects only, so this passive cleanup never runs for it.)
+ *
+ * The fix routes idle sends through the durable queue so every send has a
+ * recoverable entry, and recovers one the cleanup withdrew — probing the
+ * orphaned stream first so a request the server had already accepted is
+ * adopted rather than sent twice.
  */
-import { act, type ReactNode } from 'react'
+import { act, type ReactNode, StrictMode, useEffect } from 'react'
 import { sleep } from '@sim/utils/helpers'
 import { QueryClient, QueryClientProvider } from '@tanstack/react-query'
 import { createRoot, type Root } from 'react-dom/client'
@@ -38,9 +46,21 @@ interface NetworkState {
   /** How the chat POST behaves for the next call. */
   postBehavior: 'hang' | 'accept'
   postCalls: number
+  /**
+   * Chat the orphaned-stream probe resolves to, standing in for a request the
+   * server accepted before the client's cleanup abort tore the socket down.
+   * `null` means the server has no such stream (it never accepted the request).
+   */
+  orphanedStreamChatId: string | null
+  streamProbes: number
 }
 
-const state: NetworkState = { postBehavior: 'hang', postCalls: 0 }
+const state: NetworkState = {
+  postBehavior: 'hang',
+  postCalls: 0,
+  orphanedStreamChatId: null,
+  streamProbes: 0,
+}
 
 /** An SSE response whose stream ends immediately without a terminal event. */
 function emptySseResponse(): Response {
@@ -55,6 +75,26 @@ function emptySseResponse(): Response {
 async function fetchStub(input: RequestInfo | URL, init?: RequestInit): Promise<Response> {
   const url = String(input instanceof Request ? input.url : input)
 
+  // The orphaned-stream probe: does the server hold a stream for the send the
+  // cleanup abort withdrew?
+  if (url.includes('/api/mothership/chat/stream')) {
+    state.streamProbes++
+    // 404 is what the server returns for a stream it never registered — i.e.
+    // the request really was withdrawn before it was accepted.
+    if (!state.orphanedStreamChatId) {
+      return new Response(JSON.stringify({ error: 'stream gone' }), { status: 404 })
+    }
+    return new Response(
+      JSON.stringify({
+        success: true,
+        events: [],
+        status: 'streaming',
+        chatId: state.orphanedStreamChatId,
+      }),
+      { status: 200, headers: { 'Content-Type': 'application/json' } }
+    )
+  }
+
   if (url.includes('/api/mothership/chat') && init?.method === 'POST') {
     state.postCalls++
     if (state.postBehavior === 'accept') return emptySseResponse()
@@ -108,6 +148,43 @@ function renderUseChat(): {
   }
 }
 
+/**
+ * Mounts the hook under StrictMode with a handoff already in storage, mirroring
+ * `home.tsx`'s consume-and-auto-send effect. This is the production-shaped
+ * failure: the dev double-mount runs the passive cleanup between the two
+ * mounts, aborting the in-flight POST, and `consume` has already cleared the
+ * entry so the second mount has nothing to replay.
+ */
+function renderStrictModeHandoffConsumer(): { unmount: () => void } {
+  ;(globalThis as { IS_REACT_ACT_ENVIRONMENT?: boolean }).IS_REACT_ACT_ENVIRONMENT = true
+  queryClient = new QueryClient({ defaultOptions: { queries: { retry: false } } })
+  const container = document.createElement('div')
+  const root = createRoot(container)
+  mountedRoots.push(root)
+
+  function Probe() {
+    const { sendMessage } = useChat('ws-1', undefined)
+    useEffect(() => {
+      const handoff = MothershipHandoffStorage.consume('ws-1')
+      if (!handoff?.message) return
+      sendMessage(handoff.message, handoff.fileAttachments, handoff.contexts, {
+        ...(handoff.recoverStreamId ? { recoverStreamId: handoff.recoverStreamId } : {}),
+      })
+    }, [sendMessage])
+    return null
+  }
+
+  act(() => {
+    root.render(
+      <StrictMode>
+        <QueryClientProvider client={queryClient}>{(<Probe />) as ReactNode}</QueryClientProvider>
+      </StrictMode>
+    )
+  })
+
+  return { unmount: () => act(() => root.unmount()) }
+}
+
 /** Every queued message across all chat keys, flattened. */
 function allQueuedMessages() {
   return Object.values(useMothershipQueueStore.getState().queues).flat()
@@ -123,11 +200,13 @@ async function waitFor(predicate: () => boolean, budgetMs = 2000): Promise<void>
   }
 }
 
-describe('useChat mount-settling send recovery', () => {
+describe('useChat remount send recovery', () => {
   beforeEach(() => {
     vi.stubGlobal('fetch', fetchStub)
     state.postBehavior = 'hang'
     state.postCalls = 0
+    state.orphanedStreamChatId = null
+    state.streamProbes = 0
     mockRequestJson.mockResolvedValue({ chats: [] })
     useMothershipQueueStore.setState({ queues: {}, editing: {} })
     window.sessionStorage.clear()
@@ -195,11 +274,11 @@ describe('useChat mount-settling send recovery', () => {
     // The dispatch claimed the queue head when the optimistic send applied.
     expect(allQueuedMessages()).toHaveLength(0)
 
-    // The cleanup abort (the same code path the mount-settling remount runs)
-    // fires while the POST is still awaiting the server. A chatless surface
-    // regenerates its queue key per mount, so recovery re-persists the send
-    // as a one-shot handoff for the next mount's consumer instead of
-    // restoring the dead instance's queue.
+    // The cleanup abort (the same code path a StrictMode remount or a real
+    // navigation away runs) fires while the POST is still awaiting the server.
+    // A chatless surface regenerates its queue key per mount, so recovery
+    // re-persists the send as a one-shot handoff for the next mount's consumer
+    // instead of restoring the dead instance's queue.
     unmount()
     await waitFor(() => window.localStorage.getItem('sim_mothership_handoff') !== null)
 
@@ -226,4 +305,84 @@ describe('useChat mount-settling send recovery', () => {
     expect(allQueuedMessages()).toHaveLength(0)
     expect(MothershipHandoffStorage.consume('ws-1')).toBeNull()
   })
+
+  /**
+   * The end-to-end failure, driven by the thing that actually runs the cleanup
+   * mid-flight rather than by a hand-rolled unmount. On the unfixed hook the
+   * handoff is consumed, the POST is aborted, and nothing survives to retry.
+   */
+  it('keeps a cross-route handoff recoverable across a StrictMode double-mount', async () => {
+    MothershipHandoffStorage.store({ message: 'investigate this failed run' }, 'ws-1')
+
+    renderStrictModeHandoffConsumer()
+    await waitFor(() => state.postCalls >= 1)
+
+    // Something must still be holding the message: either the live event was
+    // claimed and it is queued/in flight again, or it is back in storage.
+    await waitFor(() => {
+      const stored = window.localStorage.getItem('sim_mothership_handoff')
+      return stored !== null || allQueuedMessages().length > 0 || state.postCalls > 1
+    })
+  })
+
+  /**
+   * The abort tears down the client socket but the route handler never reads
+   * `request.signal` — a request the server had already accepted still creates
+   * the chat, persists the user message, and runs (and bills) the turn. So the
+   * recovered send has to ask whether that happened before sending again.
+   */
+  describe('recovered send probes the orphaned stream before re-sending', () => {
+    it('adopts the chat the server already created instead of sending twice', async () => {
+      // The server accepted the withdrawn request and registered its stream.
+      state.orphanedStreamChatId = 'chat-server-already-made'
+
+      const { getResult, unmount } = renderUseChat()
+      await act(async () => {
+        void getResult().sendMessage('only once please')
+      })
+      await waitFor(() => state.postCalls === 1)
+      unmount()
+      await waitFor(() => window.localStorage.getItem('sim_mothership_handoff') !== null)
+
+      // The next mount consumes the handoff, exactly as home.tsx does.
+      const handoff = MothershipHandoffStorage.consume('ws-1')
+      expect(handoff?.recoverStreamId).toBeTruthy()
+
+      const replacement = renderUseChat()
+      await act(async () => {
+        void replacement.getResult().sendMessage(handoff?.message as string, undefined, undefined, {
+          recoverStreamId: handoff?.recoverStreamId as string,
+        })
+      })
+      await waitFor(() => state.streamProbes > 0)
+      await waitFor(() => replacement.getResult().resolvedChatId === 'chat-server-already-made')
+
+      expect(state.postCalls).toBe(1)
+      expect(allQueuedMessages()).toHaveLength(0)
+    })
+
+    it('re-sends when the server has no stream for it', async () => {
+      // 404 from the probe: the request really was withdrawn before acceptance.
+      state.orphanedStreamChatId = null
+
+      const { getResult, unmount } = renderUseChat()
+      await act(async () => {
+        void getResult().sendMessage('please actually send me')
+      })
+      await waitFor(() => state.postCalls === 1)
+      unmount()
+      await waitFor(() => window.localStorage.getItem('sim_mothership_handoff') !== null)
+
+      const handoff = MothershipHandoffStorage.consume('ws-1')
+      const replacement = renderUseChat()
+      await act(async () => {
+        void replacement.getResult().sendMessage(handoff?.message as string, undefined, undefined, {
+          recoverStreamId: handoff?.recoverStreamId as string,
+        })
+      })
+      await waitFor(() => state.postCalls === 2)
+
+      expect(state.streamProbes).toBeGreaterThan(0)
+    })
+  })
 })