fix(mothership): send released held messages through the queue's own drain rules

Releasing held sends on mount kicked the queue dispatcher directly, which skips
the drain's guards. After a reload the chat history is not loaded yet, so a
follow-up queued behind a still-running turn went out at once and was refused as
busy. The release now only clears the hold; the drain effect, which waits for
the history and for the running turn to end, sends a released head, and now
also re-runs when the head's hold clears.

Author: waleedlatif1

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

@@ -2114,6 +2114,48 @@ describe('useChat remount send recovery', () => {
       expect(state.postBodies.at(-1)?.message).toBe('First message, sent offline')
     })
 
+    /**
+     * Releasing held sends on mount must not bypass the queue's own rules: a
+     * follow-up queued behind a turn that is still running (here, restored after a
+     * reload) waits for that turn instead of being sent into a busy chat.
+     */
+    it('keeps a queued follow-up waiting on mount while the chat is still running', async () => {
+      const history: MothershipChatHistory = {
+        ...idleHistory('chat-still-running'),
+        activeStreamId: 'turn-still-running',
+      }
+      mockRequestJson.mockImplementation(() => Promise.resolve({ chat: history }))
+      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 emptySseResponse()
+        }
+        if (url.includes('/api/mothership/chat/stream')) {
+          if (url.includes('batch=true')) {
+            return Response.json({ success: true, events: [], status: 'streaming' })
+          }
+          return new Response(new ReadableStream<Uint8Array>(), {
+            headers: { 'Content-Type': 'text/event-stream' },
+          })
+        }
+        return fetchStub(input, init)
+      })
+      useMothershipQueueStore
+        .getState()
+        .enqueue(history.id, { id: 'queued-before-reload', content: 'Queued before the reload' })
+      renderUseChatInChat(history.id)
+
+      await act(async () => {
+        await sleep(1000)
+      })
+
+      expect(state.postBodies).toHaveLength(0)
+      expect(useMothershipQueueStore.getState().queues[history.id]?.[0]?.content).toBe(
+        'Queued before the reload'
+      )
+    })
+
     /** The `online` event can fire while no surface for the chat is mounted. */
     it('sends a held message when its chat mounts after the network came back', async () => {
       const history = idleHistory('chat-held-while-away')

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

@@ -5043,23 +5043,16 @@ export function useChat(
   }, [])
 
   /**
-   * Sends held because the server could not be reached go out once the browser is
-   * online: on the `online` event, and on mount in case it fired while no chat
-   * surface was listening. A chatless surface first adopts what a dead mount of the
-   * same surface held, since that mount's queue key died with it.
+   * Sends held because the server could not be reached are released once the
+   * browser is online: on the `online` event, and on mount in case it fired while
+   * no chat surface was listening. The queue drain below sends a released head
+   * under its usual rules (history loaded, no running turn). A chatless surface
+   * first adopts what a dead mount of the same surface held, since that mount's
+   * queue key died with it.
    */
   useEffect(() => {
     if (typeof window === 'undefined') return
-    const releaseHeldSends = () => {
-      useMothershipQueueStore.getState().releaseHeldUntilOnline()
-      if (
-        useMothershipQueueStore.getState().queues[chatKeyRef.current]?.length &&
-        !sendingRef.current &&
-        !pendingStopPromiseRef.current
-      ) {
-        void enqueueQueueDispatchRef.current({ type: 'send_head' })
-      }
-    }
+    const releaseHeldSends = () => useMothershipQueueStore.getState().releaseHeldUntilOnline()
     if (chatKey.startsWith(PENDING_CHAT_KEY_PREFIX)) {
       useMothershipQueueStore.getState().adoptHeldSends(chatKey, heldSendSurface)
     }
@@ -5091,9 +5084,10 @@ export function useChat(
   // `notifyTurnEnded`. Idempotent — the dispatch loop dedupes.
   const chatHistoryReady = chatHistory !== undefined
   const remoteActiveStreamId = chatHistory?.activeStreamId ?? null
+  const queueHeadHeld = messageQueue[0]?.retryRequired === true
   useEffect(() => {
     if (!scopeKey) return
-    if (messageQueue.length === 0) return
+    if (messageQueue.length === 0 || queueHeadHeld) return
     if (sendingRef.current || pendingStopPromiseRef.current) return
     if (queueDispatchTaskRef.current) return
     if (resolvedChatId && !chatHistoryReady) return
@@ -5104,6 +5098,7 @@ export function useChat(
     organizationId,
     scopeKey,
     messageQueue.length,
+    queueHeadHeld,
     resolvedChatId,
     chatHistoryReady,
     remoteActiveStreamId,