fix(mothership): keep a withdrawn first message held at the queue head as written

A first message the unmount queues ahead of its follow-ups may already be a
turn on the server. Editing it dropped its resume id, so the edit went out as
a second message. The entry is now marked admissionUnknown: the store ignores
edits to it, the hook refuses to open it for editing, and its Edit button is
disabled. The ordering test's resend now gets the server's real dedupe 409.

Author: waleedlatif1

apps/sim/app/workspace/[workspaceId]/home/components/queued-messages/queued-messages.tsx

@@ -74,6 +74,7 @@ export function QueuedMessages({
           {messageQueue.map((msg) => {
             const isEditing = msg.id === editingQueuedId
             const isDispatching = msg.id === dispatchingHeadId
+            const editBlocked = isDispatching || msg.admissionUnknown === true
             return (
               <div
                 key={msg.id}
@@ -141,9 +142,15 @@ export function QueuedMessages({
                       <Tooltip.Root>
                         <Tooltip.Trigger asChild>
                           <button
-                            aria-label={isDispatching ? 'Sending now' : 'Edit queued message'}
+                            aria-label={
+                              isDispatching
+                                ? 'Sending now'
+                                : msg.admissionUnknown
+                                  ? 'Already sent; editing it would send a second message'
+                                  : 'Edit queued message'
+                            }
                             type='button'
-                            disabled={isDispatching}
+                            disabled={editBlocked}
                             onClick={(e) => {
                               e.stopPropagation()
                               onEdit(msg.id)
@@ -154,7 +161,11 @@ export function QueuedMessages({
                           </button>
                         </Tooltip.Trigger>
                         <Tooltip.Content side='top' sideOffset={4}>
-                          {isDispatching ? 'Sending now' : 'Edit queued message'}
+                          {isDispatching
+                            ? 'Sending now'
+                            : msg.admissionUnknown
+                              ? 'Already sent; editing it would send a second message'
+                              : 'Edit queued message'}
                         </Tooltip.Content>
                       </Tooltip.Root>
 

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

@@ -2053,9 +2053,11 @@ describe('useChat remount send recovery', () => {
   })
 
   /**
-   * The first POST on the new-chat surface never answers; later POSTs open a
-   * turn in the chat the first message created. The abort endpoint and the
-   * stream lookup fail, as they would for a Stop that cannot reach the server.
+   * The first POST on the new-chat surface reaches the server, which admits it,
+   * but its answer never arrives. A resend under that id gets the server's
+   * dedupe answer naming the chat it opened; any other POST opens a turn in
+   * that chat. Until the remount, the abort endpoint and the stream lookup
+   * fail, as they would for a Stop that cannot reach the server.
    */
   function stubFirstPostPendingThenAdmitted() {
     vi.stubGlobal('fetch', async (input: RequestInfo | URL, init?: RequestInit) => {
@@ -2069,6 +2071,17 @@ describe('useChat remount send recovery', () => {
             })
           })
         }
+        const firstId = state.postBodies[0].userMessageId
+        if (state.postBodies.at(-1)?.userMessageId === firstId) {
+          return Response.json(
+            {
+              error: 'This message was already sent.',
+              activeStreamId: firstId,
+              chatId: DEDUPED_CHAT_ID,
+            },
+            { status: 409 }
+          )
+        }
         return new Response(
           new ReadableStream<Uint8Array>({
             start(controller) {
@@ -2113,6 +2126,13 @@ describe('useChat remount send recovery', () => {
     })
     await waitFor(() => allQueuedMessages().length === 1)
     first.unmount()
+    /** Held first, as written: the server may already have it under its id. */
+    expect(
+      allQueuedMessages().map((message) => [message.content, message.admissionUnknown])
+    ).toEqual([
+      ['inspect the workspace', true],
+      ['follow-up while admission pending', undefined],
+    ])
 
     const second = renderHomeLikeSurface()
     await waitFor(() => state.postBodies.length >= 3, 4_000)
@@ -2136,6 +2156,54 @@ describe('useChat remount send recovery', () => {
    * intent: the Stop's POST is left to the server, nothing withdraws it, and the
    * next mount sends just the follow-up, once.
    */
+  /**
+   * A first message held at the queue head after a remount may already be a
+   * turn on the server. Editing it would send different text under a new id,
+   * a second message the user never meant to send.
+   */
+  it('does not let a withdrawn first message held at the queue head be edited', async () => {
+    const history: MothershipChatHistory = {
+      id: 'chat-running-while-held',
+      mode: 'agent',
+      title: 'Held',
+      messages: [],
+      activeStreamId: 'turn-still-running',
+      resources: [],
+    }
+    mockRequestJson.mockImplementation(() => Promise.resolve({ chat: history }))
+    vi.stubGlobal('fetch', async (input: RequestInfo | URL, init?: RequestInit) => {
+      if (String(input).includes('/api/mothership/chat/stream')) {
+        if (String(input).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: 'held-first',
+      content: 'inspect the workspace',
+      resumeUserMessageId: 'first-attempt',
+      admissionUnknown: true,
+    })
+    const { getResult } = renderUseChatInChat(history.id, history)
+    await waitFor(() => getResult().isSending)
+
+    let edited: ReturnType<ReturnType<typeof useChat>['editQueuedMessage']>
+    await act(async () => {
+      edited = getResult().editQueuedMessage('held-first')
+    })
+
+    expect(edited).toBeUndefined()
+    expect(getResult().editingQueuedId).toBeNull()
+    expect(useMothershipQueueStore.getState().queues[history.id]?.[0]).toMatchObject({
+      content: 'inspect the workspace',
+      resumeUserMessageId: 'first-attempt',
+    })
+  })
+
   it('sends only the follow-up after a failed Stop when the new-chat surface remounts', async () => {
     stubFirstPostPendingThenAdmitted()
     const first = renderHomeLikeSurface()

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

@@ -5235,7 +5235,7 @@ export function useChat(
     const activeChatKey = chatKeyRef.current
     const queue = useMothershipQueueStore.getState().queues[activeChatKey] ?? EMPTY_MESSAGE_QUEUE
     const msg = queue.find((m) => m.id === id)
-    if (!msg) return undefined
+    if (!msg || msg.admissionUnknown) return undefined
     // Evict any sessionStorage handoff — a failed prior dispatch may have left
     // a pre-edit content snapshot that the recovery effect would otherwise replay.
     clearQueuedSendHandoffState(id)
@@ -5352,6 +5352,7 @@ export function useChat(
             id: generateId(),
             content: send.content,
             resumeUserMessageId: send.userMessageId,
+            admissionUnknown: true,
             ...(send.fileAttachments ? { fileAttachments: send.fileAttachments } : {}),
             ...(send.contexts ? { contexts: send.contexts } : {}),
             ...(send.requestMode ? { requestMode: send.requestMode } : {}),

apps/sim/app/workspace/[workspaceId]/home/types.ts

@@ -34,6 +34,12 @@ export interface QueuedMessage {
   requestMode?: ChatRequestMode
   assistantSearch?: WorkspaceSearchFilters
   assistantSearchLevel?: AssistantSearchLevel
+  /**
+   * A first message withdrawn before the server answered. The server may
+   * already hold it as sent, so it goes out exactly as written, under its
+   * original id, and cannot be edited into a different message.
+   */
+  admissionUnknown?: boolean
 }
 
 export const ToolCallStatus = {

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

@@ -30,6 +30,20 @@ describe('useMothershipQueueStore', () => {
   })
 
   describe('replaceAt', () => {
+    it('leaves a first message the server may already hold unchanged, with its id', () => {
+      useMothershipQueueStore.getState().enqueue('chat-A', {
+        id: 'm1',
+        content: 'original',
+        resumeUserMessageId: 'first-attempt',
+        admissionUnknown: true,
+      })
+      useMothershipQueueStore.getState().replaceAt('chat-A', 'm1', { content: 'edited' })
+      expect(useMothershipQueueStore.getState().queues['chat-A']?.[0]).toMatchObject({
+        content: 'original',
+        resumeUserMessageId: 'first-attempt',
+      })
+    })
+
     it('editing preserves an unresolved Stop while replacing the prior request identity', () => {
       useMothershipQueueStore.getState().enqueue('chat-A', {
         id: 'm1',

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

@@ -96,6 +96,8 @@ export const useMothershipQueueStore = create<MothershipQueueState>()(
             const current = state.queues[chatKey] ?? []
             const index = current.findIndex((m) => m.id === id)
             if (index === -1) return state
+            /** The server may already hold it as sent; an edit would become a second message. */
+            if (current[index].admissionUnknown) return state
             const next = [...current]
             /** Editing changes the request identity, never an unresolved Stop dependency. */
             const {