improvement(mothership): contain hung chat hook tests and name the delete-lifting actions

- bound async act in the use-chat DOM tests, so a send that never settles
  fails its own test instead of every later one
- note at the deduped stream lookup that a timeout abort is retried on purpose
- split reopenChat into liftDelete (token required) and reopenRestoredChat

Author: waleedlatif1

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

@@ -19,7 +19,7 @@
  * request it aborted was accepted.
  */
 
-import { act, type ReactNode, StrictMode, useEffect, useState } from 'react'
+import { type ReactNode, act as reactAct, StrictMode, useEffect, useState } from 'react'
 import { authClientMock, authClientMockFns } from '@sim/testing/mocks/auth-client.mock'
 import { libDesktopMock, libDesktopMockFns } from '@sim/testing/mocks/lib-desktop.mock'
 import { nextNavigationMock, nextNavigationMockFns } from '@sim/testing/mocks/next-navigation.mock'
@@ -103,6 +103,36 @@ import { useExecutionStore } from '@/stores/execution/store'
 import { useMothershipEffortStore } from '@/stores/mothership-effort/store'
 import { useMothershipQueueStore } from '@/stores/mothership-queue/store'
 
+/** Captured before any test fakes timers, so the act budget below runs in real time. */
+const realSetTimeout = globalThis.setTimeout
+const realClearTimeout = globalThis.clearTimeout
+/** Well under the 10s test timeout: the scope must end before the runner abandons the test. */
+const ACT_BUDGET_MS = 6_000
+
+/**
+ * React's `act`, with async callbacks bounded. A callback that never settles (a
+ * regressed send stuck reconnecting) used to run into the test timeout while
+ * still inside React's act scope, and the renders of every later test queued
+ * behind it ("Hook result is not ready"). Failing the act after a budget ends
+ * the scope, so one regression is one red test. Sync callbacks stay synchronous.
+ */
+function act(callback: () => unknown): Promise<void> {
+  return reactAct((): undefined | Promise<void> => {
+    const result = callback()
+    if (!(result instanceof Promise)) return undefined
+    let budget: ReturnType<typeof setTimeout> | undefined
+    const budgetSpent = new Promise<never>((_, reject) => {
+      budget = realSetTimeout(
+        () => reject(new Error(`act callback still pending after ${ACT_BUDGET_MS}ms`)),
+        ACT_BUDGET_MS
+      )
+    })
+    return Promise.race([result.then(() => undefined), budgetSpent]).finally(() =>
+      realClearTimeout(budget)
+    )
+  })
+}
+
 authClientMockFns.mockUseSession.mockImplementation(() => ({
   data: { user: { id: 'test-viewer' } },
 }))

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

@@ -4025,9 +4025,10 @@ export function useChat(
                message. Retry it later like a busy refusal; the server's claim settles.
                This is checked before adopting the chat the answer names, so a retried
                message stays under the key it was sent from. A lookup that fails for
-               another reason proves nothing either way, so it is retried too: the server
-               deduplicates the retry by id. Only a lookup this send aborted (Stop, or the
-               user moving on) is not retried. */
+               another reason proves nothing either way, so it is retried on purpose; that
+               includes the lookup's own timeout abort, which leaves this send's signal
+               untouched. The server deduplicates the retry by id. Only an abort of this
+               send itself (Stop, or the user moving on) is not retried. */
             const dedupedStreamExists = await fetchStreamBatch(
               conflictStreamId,
               '0',

apps/sim/hooks/queries/mothership-chat-history-restore.test.ts

@@ -90,7 +90,7 @@ describe('lifting a chat delete', () => {
     useMothershipQueueStore.getState().clearChat(history.id)
     const answer = deferredAnswer({ chat: history })
     const read = fetchMothershipChatHistory(history.id)
-    useMothershipQueueStore.getState().reopenChat(history.id)
+    useMothershipQueueStore.getState().reopenRestoredChat(history.id)
     useMothershipQueueStore.getState().clearChat(history.id)
     answer()
     await read
@@ -110,7 +110,7 @@ describe('lifting a chat delete', () => {
     useMothershipQueueStore.getState().clearChat(history.id)
 
     await restore(history.id, () => {
-      useMothershipQueueStore.getState().reopenChat(history.id)
+      useMothershipQueueStore.getState().reopenRestoredChat(history.id)
       useMothershipQueueStore.getState().clearChat(history.id)
     })
 

apps/sim/hooks/queries/mothership-chats.ts

@@ -321,7 +321,7 @@ export async function fetchMothershipChatHistory(
 ): Promise<MothershipChatHistory> {
   const deleteSeen = useMothershipQueueStore.getState().cleared[chatId]
   const history = await readMothershipChatHistory(chatId, signal)
-  if (deleteSeen !== undefined) useMothershipQueueStore.getState().reopenChat(chatId, deleteSeen)
+  if (deleteSeen !== undefined) useMothershipQueueStore.getState().liftDelete(chatId, deleteSeen)
   return history
 }
 
@@ -385,7 +385,7 @@ export function useRestoreMothershipChat(owner?: MothershipChatOwner) {
     onMutate: (chatId) => ({ deleteSeen: useMothershipQueueStore.getState().cleared[chatId] }),
     onSuccess: (_data, chatId, context) => {
       if (context?.deleteSeen === undefined) return
-      useMothershipQueueStore.getState().reopenChat(chatId, context.deleteSeen)
+      useMothershipQueueStore.getState().liftDelete(chatId, context.deleteSeen)
     },
     onSettled: () => {
       queryClient.invalidateQueries({ queryKey: mothershipChatKeys.ownerLists(owner) })

apps/sim/hooks/use-mothership-chat-events.ts

@@ -125,7 +125,8 @@ export function handleMothershipChatStatusEvent(
     return
   }
   /** A restore is published as `created`; the chat takes queued sends again. */
-  if (payload.type === 'created') useMothershipQueueStore.getState().reopenChat(payload.chatId)
+  if (payload.type === 'created')
+    useMothershipQueueStore.getState().reopenRestoredChat(payload.chatId)
   if (payload.type === 'renamed') {
     /**
      * The lists invalidated above carry the title every surface renders; the

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

@@ -92,15 +92,15 @@ describe('useMothershipQueueStore', () => {
     it('lifts only the delete a restore saw, never a later one', () => {
       useMothershipQueueStore.getState().clearChat('chat-X')
       const seen = useMothershipQueueStore.getState().cleared['chat-X']
-      useMothershipQueueStore.getState().reopenChat('chat-X')
+      useMothershipQueueStore.getState().reopenRestoredChat('chat-X')
       useMothershipQueueStore.getState().clearChat('chat-X')
 
-      useMothershipQueueStore.getState().reopenChat('chat-X', seen)
+      useMothershipQueueStore.getState().liftDelete('chat-X', seen)
       useMothershipQueueStore.getState().enqueue('chat-X', message('after-stale-restore'))
       expect(useMothershipQueueStore.getState().queues['chat-X']).toBeUndefined()
 
       const latest = useMothershipQueueStore.getState().cleared['chat-X']
-      useMothershipQueueStore.getState().reopenChat('chat-X', latest)
+      useMothershipQueueStore.getState().liftDelete('chat-X', latest)
       useMothershipQueueStore.getState().enqueue('chat-X', message('after-restore'))
       expect(useMothershipQueueStore.getState().queues['chat-X']?.map((m) => m.id)).toEqual([
         'after-restore',

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

@@ -212,13 +212,19 @@ export const useMothershipQueueStore = create<MothershipQueueState>()(
             cleared: { ...state.cleared, [chatKey]: ++deleteCount },
           })),
 
-        reopenChat: (chatKey, deleteToken) =>
-          set((state) => {
-            const current = state.cleared[chatKey]
-            if (current === undefined) return state
-            if (deleteToken !== undefined && deleteToken !== current) return state
-            return { cleared: omitKey(state.cleared, chatKey) }
-          }),
+        liftDelete: (chatKey, deleteToken) =>
+          set((state) =>
+            state.cleared[chatKey] === deleteToken
+              ? { cleared: omitKey(state.cleared, chatKey) }
+              : state
+          ),
+
+        reopenRestoredChat: (chatKey) =>
+          set((state) =>
+            state.cleared[chatKey] === undefined
+              ? state
+              : { cleared: omitKey(state.cleared, chatKey) }
+          ),
 
         reset: () => set(initialState),
       }),

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

@@ -71,9 +71,15 @@ export interface MothershipQueueState {
   adoptHeldSends: (toKey: string, surface: string) => void
   clearChat: (chatKey: string) => void
   /**
-   * Lifts `cleared` for a restored chat. Given the delete token an operation
-   * saw when it began, lifts only that delete, never one that landed after it.
+   * Lifts the delete an operation saw when it began (`cleared[chatKey]` read
+   * then), for a read or restore that found the chat. A delete that landed
+   * after it has a newer token and stays.
    */
-  reopenChat: (chatKey: string, deleteToken?: number) => void
+  liftDelete: (chatKey: string, deleteToken: number) => void
+  /**
+   * Lifts any delete of a chat the server announced as restored (its `created`
+   * event, published after every delete before it).
+   */
+  reopenRestoredChat: (chatKey: string) => void
   reset: () => void
 }