fix(chat): hand an aborted chatless send to the next mount

The mount-settling cycle is a full remount — the pending chat key is
regenerated per instance, so restoring the aborted send into the dead
instance's queue orphaned it (verified live). A chatless send now
re-persists as a one-shot MothershipHandoffStorage handoff the next
mount's consumer re-sends; chat-bound sends keep the queue restore.

Author: j15z

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

@@ -30,6 +30,7 @@ vi.mock('@/lib/api/client/request', async (importOriginal) => ({
   requestJson: mockRequestJson,
 }))
 
+import { MothershipHandoffStorage } from '@/lib/core/utils/browser-storage'
 import { useChat } from '@/app/workspace/[workspaceId]/home/hooks/use-chat'
 import { useMothershipQueueStore } from '@/stores/mothership-queue/store'
 
@@ -130,6 +131,7 @@ describe('useChat mount-settling send recovery', () => {
     mockRequestJson.mockResolvedValue({ chats: [] })
     useMothershipQueueStore.setState({ queues: {}, editing: {} })
     window.sessionStorage.clear()
+    window.localStorage.clear()
   })
 
   afterEach(() => {
@@ -141,7 +143,7 @@ describe('useChat mount-settling send recovery', () => {
     vi.clearAllMocks()
   })
 
-  it('restores a send the unmount cleanup aborted before the server received it', async () => {
+  it('re-persists an aborted chatless send as a handoff for the next mount', async () => {
     const { getResult, unmount } = renderUseChat()
 
     await act(async () => {
@@ -152,12 +154,16 @@ describe('useChat mount-settling send recovery', () => {
     // The dispatch claimed the queue head when the optimistic send applied.
     expect(allQueuedMessages()).toHaveLength(0)
 
-    // The cleanup abort (same code path a Suspense hide/reveal runs during
-    // mount-settling) fires while the POST is still awaiting the server.
+    // 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.
     unmount()
-    await waitFor(() => allQueuedMessages().length === 1)
+    await waitFor(() => window.localStorage.getItem('sim_mothership_handoff') !== null)
 
-    expect(allQueuedMessages()[0].content).toBe('hello from the palette')
+    expect(allQueuedMessages()).toHaveLength(0)
+    expect(MothershipHandoffStorage.consume('ws-1')?.message).toBe('hello from the palette')
   })
 
   it('does not re-queue a send the server already received', async () => {
@@ -175,5 +181,6 @@ describe('useChat mount-settling send recovery', () => {
     })
 
     expect(allQueuedMessages()).toHaveLength(0)
+    expect(MothershipHandoffStorage.consume('ws-1')).toBeNull()
   })
 })

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

@@ -82,6 +82,7 @@ import { executeTerminalToolOnClient } from '@/lib/copilot/tools/client/terminal
 import { setCurrentChatTraceparent } from '@/lib/copilot/tools/client/trace-context'
 import { isUserLocalVfsToolCall } from '@/lib/copilot/tools/local-filesystem'
 import { isWorkflowToolName } from '@/lib/copilot/tools/workflow-tools'
+import { MothershipHandoffStorage } from '@/lib/core/utils/browser-storage'
 import { readSSELines } from '@/lib/core/utils/sse'
 import { getDesktopBridge, getDesktopChatCapabilities } from '@/lib/desktop'
 import {
@@ -4505,6 +4506,27 @@ export function useChat(
         if (userRemovedDuringDispatchRef.current.delete(msg.id)) {
           return
         }
+        /* A pending (chatless) surface regenerates its chat key per mount, and
+           the cleanup that aborted this send belongs to a full remount — a
+           queue restore would orphan the message under the dead instance's
+           key. Re-persist it as a one-shot handoff instead: the next mount's
+           consumer re-sends it. Chat-bound sends keep the queue restore (their
+           key is the stable chat id). Attachment payloads exceed what the
+           handoff carries, so they fall back to the queue restore. */
+        if (
+          restorableCleanupAbortRef.current &&
+          dispatchChatKey.startsWith(PENDING_CHAT_KEY_PREFIX) &&
+          !msg.fileAttachments?.length
+        ) {
+          MothershipHandoffStorage.store(
+            {
+              message: msg.content,
+              ...(msg.contexts?.length ? { contexts: msg.contexts } : {}),
+            },
+            workspaceId
+          )
+          return
+        }
         useMothershipQueueStore.getState().insertAt(dispatchChatKey, originalIndex, msg)
       }
 
@@ -4545,7 +4567,7 @@ export function useChat(
         userRemovedDuringDispatchRef.current.delete(msg.id)
       }
     },
-    [startSendMessage]
+    [startSendMessage, workspaceId]
   )
 
   const runQueueDispatchLoop = useCallback(async () => {