fix(mothership): keep earlier-attempt uncertainty through a failed Stop and a reload

A Send-now whose Stop did not settle sent nothing, but was treated as proof
the server lacked the message, so a resumed message became editable. Only a
refusal of its id clears that now; an attempt that never left keeps the
earlier uncertainty. Queues saved before the guard are normalized when the
session restores them.

Author: waleedlatif1

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

@@ -2289,6 +2289,46 @@ describe('useChat remount send recovery', () => {
     })
   })
 
+  /**
+   * Send-now on a resumed message whose Stop of the running turn does not
+   * settle sends nothing. That says nothing about the earlier attempt the
+   * message resumes, so it must stay uneditable.
+   */
+  it('keeps a resumed message uneditable when its Send-now Stop does not settle', async () => {
+    state.abortSettlements = [false, false, false, false]
+    const { getResult } = renderUseChatInChat('chat-a')
+    await act(async () => {
+      void getResult().sendMessage('Original request')
+    })
+    await waitFor(() => state.postBodies.length === 1 && getResult().isSending)
+    await act(async () => {
+      await getResult().sendMessage('handed over from another surface', undefined, undefined, {
+        resumeUserMessageId: 'withdrawn-attempt',
+      })
+    })
+    await waitFor(() => useMothershipQueueStore.getState().queues['chat-a']?.length === 1)
+
+    await act(async () => {
+      await getResult()
+        .sendNow()
+        .catch(() => {})
+      await sleep(200)
+    })
+    const queued = useMothershipQueueStore.getState().queues['chat-a']?.[0]
+    let edited: ReturnType<ReturnType<typeof useChat>['editQueuedMessage']>
+    await act(async () => {
+      edited = getResult().editQueuedMessage(queued?.id ?? '')
+    })
+
+    expect(state.postBodies).toHaveLength(1)
+    expect(queued).toMatchObject({
+      content: 'handed over from another surface',
+      resumeUserMessageId: 'withdrawn-attempt',
+      admissionUnknown: true,
+    })
+    expect(edited).toBeUndefined()
+  })
+
   /**
    * A held message the server then refuses as busy is known not to be a turn
    * there: the server answers a retry of an admitted id as a duplicate, never

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

@@ -235,10 +235,17 @@ interface WithdrawnSendResult {
   /** Not sent at all (its Stop handoff failed); kept queued for the user to send. */
   held?: boolean
   /**
-   * The server is known not to have it: it was never sent, or the server
-   * refused it outright. Its queue entry can be edited.
+   * The server refused this id outright (busy, or a predecessor still shutting
+   * down). It answers a retry of an admitted id as a duplicate instead, so the
+   * server is known not to have it, and its queue entry can be edited.
    */
   notAdmitted?: boolean
+  /**
+   * This attempt never reached the server (its Stop did not settle). That says
+   * nothing about an earlier attempt the message resumes, whose uncertainty it
+   * keeps.
+   */
+  neverSent?: boolean
 }
 
 /**
@@ -3892,7 +3899,7 @@ export function useChat(
             setError(getErrorMessage(err, 'Failed to stop the previous response'))
             /* Nothing was sent. Hand the message back so it stays in its chat's queue
                even if the user has switched chats since the Stop began. */
-            return { userMessageId, held: true, notAdmitted: true }
+            return { userMessageId, held: true, neverSent: true }
           }
         }
 
@@ -4419,7 +4426,11 @@ export function useChat(
           : {}),
         ...(result.held ? { retryRequired: true } : {}),
         ...(result.busy ? busyRetry(1) : {}),
-        ...(result.notAdmitted ? { admissionUnknown: false } : {}),
+        admissionUnknown: result.notAdmitted
+          ? false
+          : result.neverSent
+            ? options?.resumeUserMessageId !== undefined
+            : true,
         ...((result.unreachable || result.busy) && activeChatKey.startsWith(PENDING_CHAT_KEY_PREFIX)
           ? { heldSurface: heldSendSurface }
           : {}),
@@ -5049,8 +5060,17 @@ export function useChat(
             ? { heldSurface: heldSendSurface }
             : {}),
           ...(withdrawnUserMessageId ? { resumeUserMessageId: withdrawnUserMessageId } : {}),
-          /** This attempt's outcome decides; an earlier refusal says nothing about it. */
-          ...(withdrawn ? { admissionUnknown: !withdrawn.notAdmitted } : {}),
+          /* A refusal of this id settles it; an attempt that never left keeps the
+             earlier uncertainty; any other withdrawal may have reached the server. */
+          ...(withdrawn
+            ? {
+                admissionUnknown: withdrawn.notAdmitted
+                  ? false
+                  : withdrawn.neverSent
+                    ? dispatched.admissionUnknown === true
+                    : true,
+              }
+            : {}),
         })
       }
 

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

@@ -0,0 +1,42 @@
+/**
+ * @vitest-environment jsdom
+ */
+import { beforeEach, describe, expect, it } from 'vitest'
+import { useMothershipQueueStore } from '@/stores/mothership-queue/store'
+
+describe('useMothershipQueueStore rehydration', () => {
+  beforeEach(() => {
+    useMothershipQueueStore.getState().reset()
+    sessionStorage.clear()
+  })
+
+  it('treats a resumed message saved before the edit guard as possibly sent', async () => {
+    sessionStorage.setItem(
+      'mothership-queue',
+      JSON.stringify({
+        state: {
+          queues: {
+            'chat-A': [
+              { id: 'saved-before', content: 'original', resumeUserMessageId: 'attempt-1' },
+              {
+                id: 'refused',
+                content: 'original',
+                resumeUserMessageId: 'attempt-2',
+                admissionUnknown: false,
+              },
+              { id: 'plain', content: 'never sent' },
+            ],
+          },
+        },
+        version: 0,
+      })
+    )
+
+    await useMothershipQueueStore.persist.rehydrate()
+
+    const [savedBefore, refused, plain] = useMothershipQueueStore.getState().queues['chat-A'] ?? []
+    expect(savedBefore?.admissionUnknown).toBe(true)
+    expect(refused?.admissionUnknown).toBe(false)
+    expect(plain?.admissionUnknown).toBeUndefined()
+  })
+})

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

@@ -1,5 +1,6 @@
 import { createLogger } from '@sim/logger'
 import { toError } from '@sim/utils/errors'
+import { toRecord, toRecordOrNull } from '@sim/utils/object'
 import { create } from 'zustand'
 import { createJSONStorage, devtools, persist } from 'zustand/middleware'
 import type { MothershipQueueState, QueuedMothershipMessage } from '@/stores/mothership-queue/types'
@@ -63,6 +64,25 @@ function withAdmissionGuard(message: QueuedMothershipMessage): QueuedMothershipM
   return { ...message, admissionUnknown: true }
 }
 
+function isQueuedMessage(value: unknown): value is QueuedMothershipMessage {
+  const record = toRecordOrNull(value)
+  return record !== null && typeof record.id === 'string' && typeof record.content === 'string'
+}
+
+/**
+ * Queues saved to this tab's session, guarded on the way back in: an entry
+ * saved before `admissionUnknown` existed would otherwise be editable.
+ */
+function restoredQueues(persisted: unknown): Record<string, QueuedMothershipMessage[]> {
+  const queues: Record<string, QueuedMothershipMessage[]> = {}
+  for (const [chatKey, queue] of Object.entries(toRecord(toRecord(persisted).queues))) {
+    if (!Array.isArray(queue)) continue
+    const messages = queue.filter(isQueuedMessage).map(withAdmissionGuard)
+    if (messages.length > 0) queues[chatKey] = messages
+  }
+  return queues
+}
+
 const omitKey = <V>(record: Record<string, V>, key: string): Record<string, V> => {
   if (!(key in record)) return record
   const { [key]: _removed, ...rest } = record
@@ -263,6 +283,7 @@ export const useMothershipQueueStore = create<MothershipQueueState>()(
         // edit text is component-local and empty after reload, so a persisted
         // editing flag would render an in-edit row with nothing bound.
         partialize: (state) => ({ queues: state.queues }),
+        merge: (persisted, current) => ({ ...current, queues: restoredQueues(persisted) }),
       }
     ),
     { name: 'mothership-queue-store' }