@@ -39,6 +39,8 @@ export interface QueuedSendHandoffState extends QueuedSendHandoffSeed {
   assistantSearchLevel?: AssistantSearchLevel
   requestedAt: number
   resolveAttempts?: number
+  /** Whether the server may already hold `userMessageId` (see `startSendMessage`). */
+  admissionUnknown?: boolean
 }
 
 interface QueuedSendHandoffClaim {
@@ -191,6 +193,9 @@ export function readQueuedSendHandoffState(): QueuedSendHandoffState | null {
       organizationId: parsed.organizationId,
       supersededStreamId,
       ...(parsed.stopRequired === true ? { stopRequired: true } : {}),
+      ...(typeof parsed.admissionUnknown === 'boolean'
+        ? { admissionUnknown: parsed.admissionUnknown }
+        : {}),
       userMessageId: parsed.userMessageId,
       message: parsed.message,
       ...(Array.isArray(parsed.fileAttachments)
 
@@ -2336,11 +2336,11 @@ describe('useChat remount send recovery', () => {
    * must not be editable into a second message.
    */
   it.each([
-    { stopRequired: false, editable: false },
-    { stopRequired: true, editable: true },
+    { stopRequired: false, admissionUnknown: true, editable: false },
+    { stopRequired: true, admissionUnknown: false, editable: true },
   ])(
-    'guards a Send-now restored from its stored handoff (Stop still required: $stopRequired)',
-    async ({ stopRequired, editable }) => {
+    'guards a Send-now restored from its stored handoff (possibly sent: $admissionUnknown)',
+    async ({ stopRequired, admissionUnknown, editable }) => {
       const history: MothershipChatHistory = {
         id: 'chat-a',
         mode: 'agent',
@@ -2364,6 +2364,7 @@ describe('useChat remount send recovery', () => {
         userMessageId: 'send-now-request',
         message: 'inspect the second invoice instead',
         ...(stopRequired ? { stopRequired: true } : {}),
+        admissionUnknown,
         requestedAt: Date.now(),
       })
       const { getResult } = renderUseChatInChat('chat-a')
@@ -2393,6 +2394,127 @@ describe('useChat remount send recovery', () => {
     }
   )
 
+  /**
+   * The id a Send-now stores is not always fresh: a re-queued message reuses its
+   * earlier attempt's id, which may already be on the server. Reloaded while the
+   * Stop is still pending, the restored entry must stay uneditable.
+   */
+  it('keeps a resumed Send-now uneditable when the page reloads before its Stop settles', async () => {
+    const first = renderUseChatInChat('chat-a')
+    await act(async () => {
+      void first.getResult().sendMessage('Original request')
+    })
+    await waitFor(() => state.postBodies.length === 1 && first.getResult().isSending)
+    vi.stubGlobal('fetch', async (input: RequestInfo | URL, init?: RequestInit) => {
+      /** The Stop never settles before the reload. */
+      if (String(input).includes('/api/copilot/chat/abort')) return new Promise<Response>(() => {})
+      return fetchStub(input, init)
+    })
+    useMothershipQueueStore.getState().enqueue('chat-a', {
+      id: 'resumed',
+      content: 'sent earlier with no answer',
+      resumeUserMessageId: 'unanswered-attempt',
+      admissionUnknown: true,
+    })
+    await act(async () => {
+      void first.getResult().sendNow('resumed')
+    })
+    await waitFor(() => readQueuedSendHandoffState()?.userMessageId === 'unanswered-attempt')
+    first.unmount()
+
+    /** After the reload: the previous turn is over and the stored handoff comes back. */
+    const history: MothershipChatHistory = {
+      id: 'chat-a',
+      mode: 'agent',
+      title: 'Reloaded',
+      messages: [],
+      activeStreamId: null,
+      resources: [],
+    }
+    let loadHistory: (() => void) | undefined
+    mockRequestJson.mockImplementation(
+      () =>
+        new Promise((resolve) => {
+          loadHistory = () => resolve({ chat: history })
+        })
+    )
+    const reloaded = renderUseChatInChat('chat-a')
+    const editAtRestore: Array<ReturnType<ReturnType<typeof useChat>['editQueuedMessage']>> = []
+    let tried = false
+    const unsubscribe = useMothershipQueueStore.subscribe((queueState) => {
+      if (tried) return
+      const restored = queueState.queues['chat-a']?.find(
+        (message) => message.content === 'sent earlier with no answer'
+      )
+      if (!restored) return
+      tried = true
+      editAtRestore.push(reloaded.getResult().editQueuedMessage(restored.id))
+    })
+    try {
+      await waitFor(() => loadHistory !== undefined)
+      await act(async () => {
+        loadHistory?.()
+        await sleep(50)
+      })
+      await waitFor(() => tried)
+    } finally {
+      unsubscribe()
+    }
+
+    expect(editAtRestore[0]).toBeUndefined()
+  })
+
+  /**
+   * A send superseded at admission is answered like a duplicate, naming its own
+   * id with no stream yet: another attempt holding that id may still admit it.
+   * The message waits uneditable, then goes out again under the same id.
+   */
+  it('keeps a send answered as a duplicate with no stream uneditable, then retries it', async () => {
+    const history: MothershipChatHistory = {
+      id: 'chat-superseded-send',
+      mode: 'agent',
+      title: 'Superseded',
+      messages: [],
+      activeStreamId: null,
+      resources: [],
+    }
+    mockRequestJson.mockImplementation(() => Promise.resolve({ chat: history }))
+    vi.stubGlobal('fetch', async (input: RequestInfo | URL, init?: RequestInit) => {
+      const url = String(input)
+      if (url === '/api/mothership/chat' && init?.method === 'POST') {
+        state.postBodies.push(JSON.parse(String(init.body)))
+        if (state.postBodies.length === 1) {
+          return Response.json(
+            {
+              error: 'This message was already sent.',
+              activeStreamId: state.postBodies[0].userMessageId,
+            },
+            { status: 409 }
+          )
+        }
+        return emptySseResponse()
+      }
+      if (url.includes('/api/mothership/chat/stream') && state.postBodies.length === 1) {
+        return Response.json({ error: 'Stream not found' }, { status: 404 })
+      }
+      return fetchStub(input, init)
+    })
+    const { getResult } = renderUseChatInChat(history.id, history)
+    await act(async () => {
+      await getResult().sendMessage('Superseded at admission')
+    })
+    const waiting = useMothershipQueueStore.getState().queues[history.id]?.[0]
+    let edited: ReturnType<ReturnType<typeof useChat>['editQueuedMessage']>
+    await act(async () => {
+      edited = getResult().editQueuedMessage(waiting?.id ?? '')
+    })
+
+    expect(waiting?.admissionUnknown).toBe(true)
+    expect(edited).toBeUndefined()
+    await waitFor(() => state.postBodies.length === 2, 5_000)
+    expect(state.postBodies[1].userMessageId).toBe(state.postBodies[0].userMessageId)
+  })
+
   /**
    * 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
 
@@ -234,19 +234,8 @@ interface WithdrawnSendResult {
   busy?: boolean
   /** Not sent at all (its Stop handoff failed); kept queued for the user to send. */
   held?: boolean
-  /**
-   * The server refused this id outright (busy, or a predecessor still shutting
-   * 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
-  /**
-   * 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
+  /** Whether the server may hold `userMessageId`; see `admissionUnknown` in `startSendMessage`. */
+  admissionUnknown: boolean
 }
 
 /**
@@ -270,6 +259,8 @@ interface StartSendMessageOptions {
    * opening a second chat and billing a second turn.
    */
   resumeUserMessageId?: string
+  /** The queued entry's `admissionUnknown`, for the id it reuses. */
+  admissionUnknown?: boolean
   requestMode?: ChatRequestMode
   assistantSearch?: WorkspaceSearchFilters
   assistantSearchLevel?: AssistantSearchLevel
@@ -3575,8 +3566,15 @@ export function useChat(
 
       /* A retry of a withdrawn send reuses its id so the server deduplicates
          the two attempts; anything else mints a fresh one. */
-      const userMessageId =
-        queuedSendHandoff?.userMessageId ?? options?.resumeUserMessageId ?? generateId()
+      const reusedId = queuedSendHandoff?.userMessageId ?? options?.resumeUserMessageId
+      const userMessageId = reusedId ?? generateId()
+      /* Whether the server may already hold `userMessageId`: the one fact that keeps a
+         queued message from being edited into a second turn. A reused id may have been
+         sent before, unless its entry knows the server refused it; a fresh id is unsent
+         until its POST goes out. Only the server refusing the id clears it again
+         (within the 1-hour claim TTL a retry of an admitted id is answered as a
+         duplicate, never refused). It rides the stored handoff and every withdrawal. */
+      let admissionUnknown = reusedId !== undefined && options?.admissionUnknown !== false
       const assistantId = getLiveAssistantMessageId(userMessageId)
 
       const storedAttachments: PersistedFileAttachment[] | undefined =
@@ -3626,6 +3624,8 @@ export function useChat(
           organizationId,
           supersededStreamId: queuedSendHandoff.supersededStreamId,
           ...(queuedSendHandoff.stopRequired ? { stopRequired: true } : {}),
+          /** Without a pending Stop, its POST goes out next. */
+          admissionUnknown: admissionUnknown || !queuedSendHandoff.stopRequired,
           userMessageId,
           message,
           ...(fileAttachments ? { fileAttachments } : {}),
@@ -3900,7 +3900,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, neverSent: true }
+            return { userMessageId, held: true, admissionUnknown }
           }
         }
 
@@ -3924,6 +3924,7 @@ export function useChat(
             ? {}
             : await getDesktopChatCapabilities(desktopScopeIdRef.current)
 
+        admissionUnknown = true
         const response = await fetch(apiPathRef.current, {
           method: 'POST',
           headers: { 'Content-Type': 'application/json' },
@@ -4017,7 +4018,7 @@ export function useChat(
               }
               if (viewOnSend)
                 setError('Previous response is still shutting down; queued message was restored.')
-              return { userMessageId, held: true, notAdmitted: true }
+              return { userMessageId, held: true, admissionUnknown: false }
             }
             /** Withdraws this refused send so the queue retries it, under the same id, later. */
             const releaseRefusedSend = () => {
@@ -4056,7 +4057,7 @@ export function useChat(
               /* Only the chat lock refuses without naming this id. Admission's
                  "superseded" conflict, where another attempt took this id's claim and may
                  admit it, is answered as a duplicate naming this id instead. */
-              return { userMessageId, busy: true, notAdmitted: true }
+              return { userMessageId, busy: true, admissionUnknown: false }
             }
             /* "Already sent" with no stream for it means the earlier attempt is still
                in flight on the server (or died before starting a turn), not that a turn
@@ -4078,7 +4079,7 @@ export function useChat(
             )
             if (!dedupedStreamExists) {
               releaseRefusedSend()
-              return { userMessageId, busy: true }
+              return { userMessageId, busy: true, admissionUnknown }
             }
             /** The user may have moved on (another chat, another send) during the check. */
             if (streamGenRef.current !== gen) return consumedByTranscript
@@ -4189,7 +4190,7 @@ export function useChat(
                server deduplicates it against that turn instead of billing
                another one. */
             rollbackOptimisticSend()
-            return { userMessageId }
+            return { userMessageId, admissionUnknown }
           }
           return consumedByTranscript
         }
@@ -4224,6 +4225,7 @@ export function useChat(
           )
           return {
             userMessageId,
+            admissionUnknown,
             unreachable: true,
             ...(onlineEventsRef.current !== onlineEventsAtSend ? { networkReturned: true } : {}),
           }
@@ -4430,9 +4432,7 @@ export function useChat(
           : {}),
         ...(result.held ? { retryRequired: true } : {}),
         ...(result.busy ? busyRetry(1) : {}),
-        /* 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,
+        admissionUnknown: result.admissionUnknown,
         ...((result.unreachable || result.busy) && activeChatKey.startsWith(PENDING_CHAT_KEY_PREFIX)
           ? { heldSurface: heldSendSurface }
           : {}),
@@ -4648,6 +4648,9 @@ export function useChat(
         userMessageId: handoff.userMessageId,
         ...(handoff.stopRequired ? { stopRequired: true } : {}),
       },
+      ...(handoff.admissionUnknown !== undefined
+        ? { admissionUnknown: handoff.admissionUnknown }
+        : {}),
     })
     clearQueuedSendHandoffState(handoff.id)
     clearQueuedSendHandoffClaim(handoff.id)
@@ -5062,17 +5065,7 @@ export function useChat(
             ? { heldSurface: heldSendSurface }
             : {}),
           ...(withdrawnUserMessageId ? { resumeUserMessageId: withdrawnUserMessageId } : {}),
-          /* 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,
-              }
-            : {}),
+          ...(withdrawn ? { admissionUnknown: withdrawn.admissionUnknown } : {}),
         })
       }
 
@@ -5104,6 +5097,9 @@ export function useChat(
             ...(liveMsg.resumeUserMessageId
               ? { resumeUserMessageId: liveMsg.resumeUserMessageId }
               : {}),
+            ...(liveMsg.admissionUnknown !== undefined
+              ? { admissionUnknown: liveMsg.admissionUnknown }
+              : {}),
             ...(liveMsg.requestMode ? { requestMode: liveMsg.requestMode } : {}),
             ...(liveMsg.assistantSearch ? { assistantSearch: liveMsg.assistantSearch } : {}),
             ...(liveMsg.assistantSearchLevel !== undefined
 
@@ -23,6 +23,7 @@ import {
 } from '@sim/testing/mocks/permission-groups-resolve.mock'
 import { afterAll, beforeEach, describe, expect, it, vi } from 'vitest'
 import { admitChatTurn, turnDesktopDevice } from '@/lib/mothership/chat/application/admit-turn'
+import { ChatSendSupersededError } from '@/lib/mothership/chat/application/send-superseded'
 
 const hoisted = vi.hoisted(() => ({
   lease: vi.fn(),
@@ -123,6 +124,22 @@ describe('organization turn admission through current private-chat authorization
       expect.anything()
     )
   })
+  /**
+   * Another attempt with this id re-took the claim after this one's in-progress
+   * TTL ran out. That attempt may admit the turn, so this one must not, and the
+   * route answers it as a duplicate.
+   */
+  it('refuses to admit a send whose claim another attempt took', async () => {
+    queueTableRows(copilotChats, [chat])
+    queueTableRows(member, [{ role: 'member' }])
+    dbChainMockFns.returning
+      .mockResolvedValueOnce([{ model: null }])
+      .mockResolvedValueOnce([{ id: 'run-1', organizationId: 'org-1', workspaceId: null }])
+      .mockResolvedValueOnce([])
+    await expect(admitChatTurn.execute({ principal, input: input() })).rejects.toBeInstanceOf(
+      ChatSendSupersededError
+    )
+  })
   it("keeps an organization chat's turn with its chat view, never on a desktop", async () => {
     hoisted.resolveDesktop.mockResolvedValue('device-1')
     const offered = '33333333-3333-4333-8333-333333333333'
 
@@ -30,7 +30,7 @@ describe('useMothershipQueueStore', () => {
   })
 
   describe('replaceAt', () => {
-    it('treats a Send-now whose Stop settled as possibly sent under its handoff id', () => {
+    it('reads a reused handoff id as possibly sent unless the entry says otherwise', () => {
       useMothershipQueueStore.getState().enqueue('chat-A', {
         id: 'sent',
         content: 'original',
@@ -51,6 +51,8 @@ describe('useMothershipQueueStore', () => {
           userMessageId: 'not-sent-yet',
           stopRequired: true,
         },
+        /** A fresh id still waiting on its Stop, as the hook records it. */
+        admissionUnknown: false,
       })
       useMothershipQueueStore.getState().replaceAt('chat-A', 'sent', { content: 'edited' })
       useMothershipQueueStore.getState().replaceAt('chat-A', 'waiting', { content: 'edited' })