fix(mothership): guard a Send-now restored from its stored handoff against edits

A Send-now whose Stop settled has its POST out under the id its stored
handoff carries. Restored after a reload it had no resumeUserMessageId, so
the queue guard missed it, and an edit could run as a second turn. The guard
now treats a settled handoff's id as an earlier attempt. A direct send can't
reach the never-sent branch (a pending Stop queues it), so that restore now
treats anything but a refusal as unknown. Docs: the 1-hour claim TTL, the
claim failing closed, and the superseded admission conflict classed as busy.

Author: waleedlatif1

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

@@ -2329,6 +2329,70 @@ describe('useChat remount send recovery', () => {
     expect(edited).toBeUndefined()
   })
 
+  /**
+   * A Send-now whose Stop settled has its POST out under the id its stored
+   * handoff carries. Reloaded before the answer, the handoff comes back into the
+   * queue; the server may already have admitted that id, so the restored entry
+   * must not be editable into a second message.
+   */
+  it.each([
+    { stopRequired: false, editable: false },
+    { stopRequired: true, editable: true },
+  ])(
+    'guards a Send-now restored from its stored handoff (Stop still required: $stopRequired)',
+    async ({ stopRequired, editable }) => {
+      const history: MothershipChatHistory = {
+        id: 'chat-a',
+        mode: 'agent',
+        title: 'Restored handoff',
+        messages: [],
+        activeStreamId: null,
+        resources: [],
+      }
+      let loadHistory: (() => void) | undefined
+      mockRequestJson.mockImplementation(
+        () =>
+          new Promise((resolve) => {
+            loadHistory = () => resolve({ chat: history })
+          })
+      )
+      writeQueuedSendHandoffState({
+        id: 'restored-send-now',
+        chatId: 'chat-a',
+        workspaceId: 'ws-1',
+        supersededStreamId: 'previous-response',
+        userMessageId: 'send-now-request',
+        message: 'inspect the second invoice instead',
+        ...(stopRequired ? { stopRequired: true } : {}),
+        requestedAt: Date.now(),
+      })
+      const { getResult } = renderUseChatInChat('chat-a')
+      /** The first moment a user could act on the restored entry, before dispatch. */
+      const editAtRestore: Array<ReturnType<ReturnType<typeof useChat>['editQueuedMessage']>> = []
+      let tried = false
+      const unsubscribe = useMothershipQueueStore.subscribe((queueState) => {
+        if (tried) return
+        if (!queueState.queues['chat-a']?.some((message) => message.id === 'restored-send-now'))
+          return
+        /** Set first: opening the entry for editing writes the store and re-enters here. */
+        tried = true
+        editAtRestore.push(getResult().editQueuedMessage('restored-send-now'))
+      })
+      try {
+        await waitFor(() => loadHistory !== undefined)
+        await act(async () => {
+          loadHistory?.()
+          await sleep(50)
+        })
+        await waitFor(() => editAtRestore.length === 1)
+      } finally {
+        unsubscribe()
+      }
+
+      expect(editAtRestore[0] !== undefined).toBe(editable)
+    }
+  )
+
   /**
    * 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

@@ -236,8 +236,9 @@ interface WithdrawnSendResult {
   held?: boolean
   /**
    * 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.
+   * down). Within the 1-hour claim TTL 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
   /**
@@ -4052,6 +4053,10 @@ export function useChat(
                   exact: true,
                   refetchType: 'none',
                 })
+              /* Admission's "superseded" conflict (another attempt re-took this id's
+                 claim) also lands here with no stream named. That needs this attempt to
+                 hold its claim past the 60s in-progress TTL before admitting, which a
+                 lock wait of at most 5s does not reach. */
               return { userMessageId, busy: true, notAdmitted: true }
             }
             /* "Already sent" with no stream for it means the earlier attempt is still
@@ -4426,11 +4431,9 @@ export function useChat(
           : {}),
         ...(result.held ? { retryRequired: true } : {}),
         ...(result.busy ? busyRetry(1) : {}),
-        admissionUnknown: result.notAdmitted
-          ? false
-          : result.neverSent
-            ? options?.resumeUserMessageId !== undefined
-            : true,
+        /* Only a refusal of this id settles it. A direct send never waits on a Stop
+           (one pending queues it instead), so `neverSent` cannot occur here. */
+        admissionUnknown: !result.notAdmitted,
         ...((result.unreachable || result.busy) && activeChatKey.startsWith(PENDING_CHAT_KEY_PREFIX)
           ? { heldSurface: heldSendSurface }
           : {}),

apps/sim/lib/mothership/chat/post.ts

@@ -939,9 +939,9 @@ const CHAT_SEND_IDEMPOTENCY_PROVIDER = 'user-message'
 /**
  * Claims this send so a retry of it can be recognised.
  *
- * Fails open: a missed deduplication costs a duplicate chat and turn, but
- * refusing the send loses the user's message. Returns `undefined` when the
- * store is unreachable, which sends normally with no claim to finalize.
+ * Fails closed: the claim is stored in Postgres (`chatSendIdempotency` forces
+ * database storage), so a store failure throws and the send is answered with a
+ * 500 rather than run without deduplication.
  *
  * The key is scoped to the caller — `userMessageId` is client-supplied, so an
  * unscoped one would let a user probe another's sends for their chat id.

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

@@ -30,6 +30,39 @@ describe('useMothershipQueueStore', () => {
   })
 
   describe('replaceAt', () => {
+    it('treats a Send-now whose Stop settled as possibly sent under its handoff id', () => {
+      useMothershipQueueStore.getState().enqueue('chat-A', {
+        id: 'sent',
+        content: 'original',
+        queuedSendHandoff: {
+          id: 'sent',
+          chatId: 'chat-A',
+          supersededStreamId: 'previous-response',
+          userMessageId: 'send-now-request',
+        },
+      })
+      useMothershipQueueStore.getState().enqueue('chat-A', {
+        id: 'waiting',
+        content: 'original',
+        queuedSendHandoff: {
+          id: 'waiting',
+          chatId: 'chat-A',
+          supersededStreamId: 'previous-response',
+          userMessageId: 'not-sent-yet',
+          stopRequired: true,
+        },
+      })
+      useMothershipQueueStore.getState().replaceAt('chat-A', 'sent', { content: 'edited' })
+      useMothershipQueueStore.getState().replaceAt('chat-A', 'waiting', { content: 'edited' })
+
+      const [sent, waiting] = useMothershipQueueStore.getState().queues['chat-A'] ?? []
+      expect(sent).toMatchObject({
+        content: 'original',
+        queuedSendHandoff: { userMessageId: 'send-now-request' },
+      })
+      expect(waiting?.content).toBe('edited')
+    })
+
     it('treats any message resuming an earlier attempt as possibly sent, unless told otherwise', () => {
       useMothershipQueueStore
         .getState()

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

@@ -52,15 +52,19 @@ const initialState = {
 }
 
 /**
- * A message resuming an earlier attempt (`resumeUserMessageId`) may already be
- * a turn on the server, unless the writer knows it is not
- * (`admissionUnknown: false`). Every queue write goes through this, so no path
- * can queue such a message as editable by leaving the flag out.
+ * A message carrying an earlier attempt's id may already be a turn on the
+ * server, unless the writer knows it is not (`admissionUnknown: false`). The id
+ * rides as `resumeUserMessageId` (a withdrawn send) or as its Stop handoff's
+ * `userMessageId` (a Send-now restored from its stored handoff). A handoff
+ * still waiting on its Stop (`stopRequired`) never sent that id: the handoff is
+ * rewritten without it just before the POST. Every queue write goes through
+ * this, so no path can queue such a message as editable by leaving the flag out.
  */
 function withAdmissionGuard(message: QueuedMothershipMessage): QueuedMothershipMessage {
-  if (message.resumeUserMessageId === undefined || message.admissionUnknown !== undefined) {
-    return message
-  }
+  const handoff = message.queuedSendHandoff
+  const earlierAttempt =
+    message.resumeUserMessageId ?? (handoff?.stopRequired ? undefined : handoff?.userMessageId)
+  if (earlierAttempt === undefined || message.admissionUnknown !== undefined) return message
   return { ...message, admissionUnknown: true }
 }