fix(mothership): keep a chatless surface's queue when it remounts

A follow-up queued on the new-chat surface waits until the first message's
chat is known. If the surface remounted first (for example after that
message's Stop failed), the queue stayed under the dead mount's key, neither
sent nor shown. The unmount now marks that queue held for its surface, and
the next mount of the surface adopts it like other held sends.

Author: waleedlatif1

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

@@ -2052,6 +2052,57 @@ describe('useChat remount send recovery', () => {
     expect(state.abortBodies[0]).not.toHaveProperty('chatId')
   })
 
+  /**
+   * A follow-up sent on the new-chat surface while the first message's Stop is
+   * pending waits in that surface's queue until the first message's chat is
+   * known. If the Stop fails and the surface remounts first, the queue key dies
+   * with the mount: the next new-chat surface must show the follow-up (and may
+   * send it), not leave it under the dead key, neither sent nor visible.
+   */
+  it('keeps a follow-up queued behind a failed chatless Stop when the surface remounts', async () => {
+    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>((_, reject) => {
+          init.signal?.addEventListener('abort', () => reject(init.signal?.reason), { once: true })
+        })
+      }
+      if (url.includes('/api/copilot/chat/abort')) {
+        state.abortBodies.push(JSON.parse(String(init?.body)))
+        return Response.json({ error: 'Internal error' }, { status: 500 })
+      }
+      if (url.includes('/api/mothership/chat/stream')) {
+        return Response.json({ error: 'Internal error' }, { status: 500 })
+      }
+      return fetchStub(input, init)
+    })
+    const first = renderUseChat()
+    await act(async () => {
+      void first.getResult().sendMessage('inspect the workspace')
+    })
+    await waitFor(() => state.postBodies.length === 1)
+    await act(async () => {
+      void first
+        .getResult()
+        .stopGeneration()
+        .catch(() => {})
+      void first.getResult().sendMessage('Sent while the Stop was failing')
+      await sleep(1_000)
+    })
+    first.unmount()
+
+    const second = renderUseChat()
+    await waitFor(
+      () =>
+        second
+          .getResult()
+          .messageQueue.some((message) => message.content === 'Sent while the Stop was failing') ||
+        state.postBodies.some((body) => body.message === 'Sent while the Stop was failing'),
+      4_000
+    )
+  })
+
   it('stopping a chat preserves an unrelated manual workflow execution', async () => {
     const executionStore = useExecutionStore.getState()
     executionStore.setIsExecuting('manual-workflow', true)

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

@@ -770,6 +770,8 @@ export function useChat(
   const onlineEventsRef = useRef(0)
   /** Identifies this chatless surface across mounts, for the sends it holds. */
   const heldSendSurface = `${scopeKey}:${options?.workflowId ?? 'home'}`
+  const heldSendSurfaceRef = useRef(heldSendSurface)
+  heldSendSurfaceRef.current = heldSendSurface
   const onToolResultRef = useRef(options?.onToolResult)
   onToolResultRef.current = options?.onToolResult
   const onTitleUpdateRef = useRef(options?.onTitleUpdate)
@@ -5317,6 +5319,14 @@ export function useChat(
       sendingRef.current = false
       // Release the editing slot — the composer it binds to is unmounting.
       useMothershipQueueStore.getState().setEditing(chatKeyRef.current, null)
+      /* A chatless mount's queue key dies with it. Messages still queued there
+         (behind a first message whose chat is not known yet, or a Stop that
+         failed) go to the next mount of this surface, as held sends do. */
+      if (chatKeyRef.current.startsWith(PENDING_CHAT_KEY_PREFIX)) {
+        useMothershipQueueStore
+          .getState()
+          .holdForSurface(chatKeyRef.current, heldSendSurfaceRef.current)
+      }
     }
   }, [
     cancelActiveStreamRecovery,

apps/sim/stores/mothership-queue/store.test.ts

@@ -75,6 +75,21 @@ describe('useMothershipQueueStore', () => {
     })
   })
 
+  describe('holdForSurface', () => {
+    it("hands a dead chatless mount's queue to the next mount of its surface only", () => {
+      useMothershipQueueStore.getState().enqueue('pending::dead', message('m1'))
+      useMothershipQueueStore.getState().holdForSurface('pending::dead', 'ws-1:home')
+
+      useMothershipQueueStore.getState().adoptHeldSends('pending::other', 'ws-1:workflow-1')
+      expect(useMothershipQueueStore.getState().queues['pending::other']).toBeUndefined()
+
+      useMothershipQueueStore.getState().adoptHeldSends('pending::next', 'ws-1:home')
+      const state = useMothershipQueueStore.getState()
+      expect(state.queues['pending::next']?.map((m) => m.id)).toEqual(['m1'])
+      expect(state.queues['pending::dead']).toBeUndefined()
+    })
+  })
+
   describe('migrate', () => {
     it('merges into an existing destination bucket instead of overwriting', () => {
       useMothershipQueueStore.getState().enqueue('chat-X', message('existing-1'))

apps/sim/stores/mothership-queue/store.ts

@@ -205,6 +205,19 @@ export const useMothershipQueueStore = create<MothershipQueueState>()(
             }
           }),
 
+        holdForSurface: (chatKey, surface) =>
+          set((state) => {
+            const queue = state.queues[chatKey]
+            if (!queue?.some((message) => message.heldSurface !== surface)) return state
+            return {
+              queues: setQueueForChat(
+                state.queues,
+                chatKey,
+                queue.map((message) => ({ ...message, heldSurface: surface }))
+              ),
+            }
+          }),
+
         clearChat: (chatKey) =>
           set((state) => ({
             queues: omitKey(state.queues, chatKey),

apps/sim/stores/mothership-queue/types.ts

@@ -69,6 +69,12 @@ export interface MothershipQueueState {
   releaseHeldUntilOnline: () => void
   /** Moves the sends a dead chatless mount of `surface` held onto `toKey`. */
   adoptHeldSends: (toKey: string, surface: string) => void
+  /**
+   * Marks everything queued under a chatless mount's key as held for its
+   * `surface`, as that mount goes away: the key dies with it, and the next
+   * mount of the surface adopts the messages instead of losing them.
+   */
+  holdForSurface: (chatKey: string, surface: string) => void
   clearChat: (chatKey: string) => void
   /**
    * Lifts the delete an operation saw when it began (`cleared[chatKey]` read