refactor(mothership): tidy the forwarding of late queue writes

- one lookup instead of a hop loop: only a new-chat key moves, and only to
  its chat's key, which never does; liveQueueKey derives from
  liveQueuePosition
- migrate keeps the first record, so a repeat cannot rewrite what was ahead
- the history check drops its no-op forwarding: it never runs on a new-chat key
- the dead-key DOM test waits on the queue instead of a fixed sleep

Author: waleedlatif1

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

@@ -2866,9 +2866,12 @@ describe('useChat remount send recovery', () => {
         .catch(() => {})
     })
     await waitFor(() => state.postBodies.length === 2)
-    await act(async () => {
-      await sleep(200)
-    })
+    /** The refusal goes back to a queue; the assertions below say which one. */
+    await waitFor(() =>
+      Object.values(useMothershipQueueStore.getState().queues).some((queue) =>
+        queue.some((message) => message.content === 'Follow-up')
+      )
+    )
 
     const queues = useMothershipQueueStore.getState().queues
     expect(queues[DEDUPED_CHAT_ID]?.map((message) => message.content)).toEqual(['Follow-up'])

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

@@ -5077,7 +5077,7 @@ export function useChat(
       }
       clearQueuedSendHandoffState(msg.id)
       clearQueuedSendHandoffClaim(msg.id)
-      useMothershipQueueStore.getState().remove(liveQueueKey(chatKey), msg.id)
+      useMothershipQueueStore.getState().remove(chatKey, msg.id)
       return true
     },
     [queryClient]

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

@@ -135,17 +135,6 @@ const setQueueForChat = (
 ): Record<string, QueuedMothershipMessage[]> =>
   next.length === 0 ? omitKey(queues, chatKey) : { ...queues, [chatKey]: next }
 
-/**
- * The queue key a write captured before an `await` should use now: the key a
- * new-chat queue migrated to once its chat became known, if it did.
- */
-export function liveQueueKey(chatKey: string): string {
-  const { migratedTo } = useMothershipQueueStore.getState()
-  let key = chatKey
-  for (let hops = 0; hops < 8 && migratedTo[key] !== undefined; hops++) key = migratedTo[key].key
-  return key
-}
-
 /**
  * Where a message goes back into its queue after a write captured before an
  * `await`: in the queue's live key, right after the last message still there
@@ -158,14 +147,10 @@ export function liveQueuePosition(
   aheadIds: readonly string[]
 ): { chatKey: string; index: number } {
   const { migratedTo, queues } = useMothershipQueueStore.getState()
-  const ahead = new Set(aheadIds)
-  let key = chatKey
-  for (let hops = 0; hops < 8; hops++) {
-    const migration = migratedTo[key]
-    if (!migration) break
-    for (const id of migration.ahead) ahead.add(id)
-    key = migration.key
-  }
+  /** One lookup: only a new-chat key moves, and only to its chat's key, which never does. */
+  const migration = migratedTo[chatKey]
+  const key = migration?.key ?? chatKey
+  const ahead = new Set([...aheadIds, ...(migration?.ahead ?? [])])
   const queue = queues[key] ?? []
   let index = 0
   queue.forEach((message, position) => {
@@ -174,6 +159,11 @@ export function liveQueuePosition(
   return { chatKey: key, index }
 }
 
+/** The queue key a write captured before an `await` should use now (see `liveQueuePosition`). */
+export function liveQueueKey(chatKey: string): string {
+  return liveQueuePosition(chatKey, []).chatKey
+}
+
 export const useMothershipQueueStore = create<MothershipQueueState>()(
   devtools(
     persist(
@@ -259,7 +249,8 @@ export const useMothershipQueueStore = create<MothershipQueueState>()(
             if (fromKey === toKey) return state
             const migratedTo = {
               ...state.migratedTo,
-              [fromKey]: {
+              /** The first move is the real one; a repeat must not rewrite what was ahead. */
+              [fromKey]: state.migratedTo[fromKey] ?? {
                 key: toKey,
                 ahead: (state.queues[toKey] ?? []).map((message) => message.id),
               },