@@ -1871,6 +1871,51 @@ describe('useChat remount send recovery', () => {
     })
   })
 
+  /**
+   * A handoff stored before the flag existed cannot say whether its id was ever
+   * sent, so it is checked against the chat's history before it goes out again.
+   */
+  it('checks a flagless stored handoff against history before resending it', async () => {
+    const order: string[] = []
+    const history: MothershipChatHistory = {
+      id: 'chat-a',
+      mode: 'agent',
+      title: 'Invoice inspection',
+      messages: [],
+      activeStreamId: null,
+      resources: [],
+    }
+    mockRequestJson.mockImplementation(() => {
+      order.push('history')
+      return Promise.resolve({ chat: history })
+    })
+    vi.stubGlobal('fetch', async (input: RequestInfo | URL, init?: RequestInit) => {
+      const url = String(input instanceof Request ? input.url : input)
+      if (url.includes('/api/copilot/chat/abort')) {
+        state.abortBodies.push(JSON.parse(String(init?.body)))
+        return Response.json({ aborted: true, settled: true })
+      }
+      if (url === '/api/mothership/chat' && init?.method === 'POST') order.push('post')
+      return fetchStub(input, init)
+    })
+    writeQueuedSendHandoffState({
+      id: 'queued-correction',
+      chatId: 'chat-a',
+      workspaceId: 'ws-1',
+      supersededStreamId: 'previous-response',
+      userMessageId: 'prepared-correction-request',
+      message: 'inspect the second invoice instead',
+      stopRequired: true,
+      requestedAt: Date.now(),
+    })
+    renderUseChatInChat('chat-a', history)
+    await waitFor(() => state.postBodies.length === 1, 4_000)
+
+    expect(state.postBodies[0].userMessageId).toBe('prepared-correction-request')
+    expect(order.indexOf('history')).toBeGreaterThanOrEqual(0)
+    expect(order.indexOf('history')).toBeLessThan(order.indexOf('post'))
+  })
+
   it.each([false, true])(
     'the remounted handoff reader requires Stop settlement (settled: %s)',
     async (settled) => {
@@ -1892,6 +1937,8 @@ describe('useChat remount send recovery', () => {
         message: 'inspect the second invoice instead',
         requestMode: 'assistant',
         stopRequired: true,
+        /** A fresh id still waiting on its Stop, as the hook records it. */
+        admissionUnknown: false,
         requestedAt: Date.now(),
       })
       const { getResult } = renderUseChatInChat('chat-a', {
 
@@ -134,7 +134,7 @@ import { workflowKeys } from '@/hooks/queries/workflows'
 import { snapAllSmoothText } from '@/hooks/use-smooth-text'
 import { useChatPanelStore } from '@/stores/chat-panel/store'
 import { useMothershipEffortStore } from '@/stores/mothership-effort/store'
-import { useMothershipQueueStore } from '@/stores/mothership-queue/store'
+import { reusedRequestId, useMothershipQueueStore } from '@/stores/mothership-queue/store'
 import type {
   QueuedMothershipMessage,
   QueuedSendHandoffSeed,
@@ -3635,8 +3635,7 @@ export function useChat(
           organizationId,
           supersededStreamId: queuedSendHandoff.supersededStreamId,
           ...(queuedSendHandoff.stopRequired ? { stopRequired: true } : {}),
-          /** Without a pending Stop, its POST goes out next. */
-          admissionUnknown: admissionUnknown || !queuedSendHandoff.stopRequired,
+          admissionUnknown,
           userMessageId,
           message,
           ...(fileAttachments ? { fileAttachments } : {}),
@@ -3936,6 +3935,8 @@ export function useChat(
             : await getDesktopChatCapabilities(desktopScopeIdRef.current)
 
         admissionUnknown = true
+        /** A reload from here on may find the server holding this id. */
+        writeQueuedSendHandoff(requestChatId)
         const response = await fetch(apiPathRef.current, {
           method: 'POST',
           headers: { 'Content-Type': 'application/json' },
@@ -4021,7 +4022,11 @@ export function useChat(
             /** Whether this view still shows the send; otherwise only its own chat changes. */
             const viewOnSend = streamGenRef.current === gen
             const supersededStreamId = queuedSendHandoff?.supersededStreamId ?? pendingStopStreamId
-            if (supersededStreamId && conflictStreamId === supersededStreamId) {
+            if (
+              supersededStreamId &&
+              conflictStreamId === supersededStreamId &&
+              conflictStreamId !== userMessageId
+            ) {
               rollbackOptimisticSend()
               if (streamGenRef.current === gen) {
                 streamGenRef.current++
@@ -5156,7 +5161,7 @@ export function useChat(
    */
   const mustNotResend = useCallback(
     async (chatKey: string, msg: QueuedMothershipMessage): Promise<boolean> => {
-      const requestId = msg.queuedSendHandoff?.userMessageId ?? msg.resumeUserMessageId
+      const requestId = reusedRequestId(msg)
       if (!msg.admissionUnknown || !requestId || chatKey.startsWith(PENDING_CHAT_KEY_PREFIX))
         return false
       const history = await queryClient
@@ -5358,7 +5363,7 @@ export function useChat(
     const accepted = acceptedMessageIds(chatHistory)
     for (const queued of messageQueue) {
       if (queuedMessageDispatchIds.has(queued.id)) continue
-      const requestId = queued.queuedSendHandoff?.userMessageId ?? queued.resumeUserMessageId
+      const requestId = reusedRequestId(queued)
       if (!requestId || !accepted.has(requestId)) continue
       clearQueuedSendHandoffState(queued.id)
       clearQueuedSendHandoffClaim(queued.id)
 
@@ -30,6 +30,27 @@ describe('useMothershipQueueStore', () => {
   })
 
   describe('replaceAt', () => {
+    it('treats a flagless handoff still waiting on its Stop as possibly sent', () => {
+      /** Its id may be a re-queued message's earlier attempt, which a pending Stop says nothing about. */
+      useMothershipQueueStore.getState().enqueue('chat-A', {
+        id: 'legacy',
+        content: 'original',
+        queuedSendHandoff: {
+          id: 'legacy',
+          chatId: 'chat-A',
+          supersededStreamId: 'previous-response',
+          userMessageId: 'earlier-attempt',
+          stopRequired: true,
+        },
+      })
+      useMothershipQueueStore.getState().replaceAt('chat-A', 'legacy', { content: 'edited' })
+
+      expect(useMothershipQueueStore.getState().queues['chat-A']?.[0]).toMatchObject({
+        content: 'original',
+        admissionUnknown: true,
+      })
+    })
+
     it('reads a reused handoff id as possibly sent unless the entry says otherwise', () => {
       useMothershipQueueStore.getState().enqueue('chat-A', {
         id: 'sent',
 
@@ -51,6 +51,15 @@ const initialState = {
   cleared: {} as Record<string, number>,
 }
 
+/**
+ * The earlier attempt's id a queued message goes out under, if it reuses one:
+ * its Stop handoff's, else the withdrawn send's. `startSendMessage` picks the id
+ * in the same order.
+ */
+export function reusedRequestId(message: QueuedMothershipMessage): string | undefined {
+  return message.queuedSendHandoff?.userMessageId ?? message.resumeUserMessageId
+}
+
 /**
  * `admissionUnknown` is decided where a send chooses its id (`startSendMessage`)
  * and carried on the entry. A writer that has no say (a session saved before the
@@ -59,8 +68,9 @@ const initialState = {
  * write goes through this, so no path can queue such a message as editable.
  */
 function withAdmissionGuard(message: QueuedMothershipMessage): QueuedMothershipMessage {
-  const reusedId = message.resumeUserMessageId ?? message.queuedSendHandoff?.userMessageId
-  if (reusedId === undefined || message.admissionUnknown !== undefined) return message
+  if (reusedRequestId(message) === undefined || message.admissionUnknown !== undefined) {
+    return message
+  }
   return { ...message, admissionUnknown: true }
 }