@@ -189,6 +189,29 @@ export function outgoingRetryDelay(attempts: number): number {
   })
 }
 
+/**
+ * Where the rest of a new chat's messages wait once its surface is gone: the handoff
+ * carries one message, and whichever surface resumes that one takes these behind it.
+ */
+export function handedOffJournalKey(resumedId: string): string {
+  return `handoff:${resumedId}`
+}
+
+/**
+ * What a new chat's message goes on to the next surface as. Nothing took it, since
+ * its chat never existed, so it starts over; one shown as not delivered stays that
+ * way until the user asks.
+ */
+export function toHandedOff(message: OutgoingMessage): JournaledOutgoing {
+  return {
+    id: message.id,
+    payload: message.payload,
+    status: message.status === 'failed' ? 'failed' : 'pending',
+    ...(message.unconfirmed ? { unconfirmed: true } : {}),
+    writtenAt: message.writtenAt,
+  }
+}
+
 type PersistedRow = MothershipChatHistory['messages'][number]
 
 /**
 
@@ -2178,6 +2178,151 @@ describe('useChat remount send recovery', () => {
     expect(MothershipHandoffStorage.consume('ws-1')?.message).toBe('must survive my own teardown')
   })
 
+  describe('a new chat’s messages when its surface unmounts', () => {
+    const idOf = (view: { getResult: () => ReturnType<typeof useChat> }, content: string) =>
+      view.getResult().messages.find((message) => message.content === content)?.id
+
+    /** From here on a send is admitted and opens its chat; its turn ends at once. */
+    function admitSends() {
+      mockRequestJson.mockImplementation(() =>
+        Promise.resolve({
+          chat: {
+            id: DEDUPED_CHAT_ID,
+            mode: 'agent',
+            title: 'Handed off',
+            messages: [],
+            activeStreamId: null,
+            resources: [],
+          } satisfies MothershipChatHistory,
+        })
+      )
+      vi.stubGlobal('fetch', (input: RequestInfo | URL, init?: RequestInit) => {
+        if (String(input) !== '/api/mothership/chat' || init?.method !== 'POST') {
+          return fetchStub(input, init)
+        }
+        state.postBodies.push(JSON.parse(String(init.body)))
+        return Promise.resolve(
+          new Response(emptySseResponse().body, {
+            headers: {
+              'Content-Type': 'text/event-stream',
+              'x-mothership-chat-id': DEDUPED_CHAT_ID,
+            },
+          })
+        )
+      })
+    }
+
+    async function sendTwoDuringAdmission() {
+      const view = renderUseChat()
+      await act(async () => {
+        void view.getResult().sendMessage('First')
+      })
+      await waitFor(() => state.postBodies.length === 1)
+      await act(async () => {
+        void view.getResult().sendMessage('Second')
+        await settle()
+      })
+      return { view, secondId: idOf(view, 'Second') }
+    }
+
+    /** Sent while the first waited on its admission, the second has no chat to wait in. */
+    it('hands off a message sent during the admission, behind the first, from storage', async () => {
+      const { view, secondId } = await sendTwoDuringAdmission()
+      expect(secondId).toBeDefined()
+      view.unmount()
+      await waitFor(() => window.localStorage.getItem('sim_mothership_handoff') !== null)
+
+      const handoff = MothershipHandoffStorage.consume('ws-1')
+      expect(handoff?.message).toBe('First')
+      admitSends()
+      const next = renderUseChat()
+      await act(async () => {
+        await next.getResult().sendMessage(handoff?.message ?? '', undefined, undefined, {
+          resumeUserMessageId: handoff?.resumeUserMessageId,
+        })
+      })
+      await waitFor(() => state.postBodies.length === 3)
+
+      expect(state.postBodies.slice(1).map((body) => [body.message, body.userMessageId])).toEqual([
+        ['First', handoff?.resumeUserMessageId],
+        ['Second', secondId],
+      ])
+    })
+
+    it('hands off a message sent during the admission to a live replacement', async () => {
+      const replacement = renderHomeLikeSurface()
+      const { view, secondId } = await sendTwoDuringAdmission()
+      admitSends()
+      view.unmount()
+      await waitFor(() => state.postBodies.length === 3)
+
+      expect(replacement.claimedByOwnListener()).toBe(1)
+      expect(state.postBodies[1].message).toBe('First')
+      expect(state.postBodies[2]).toMatchObject({ message: 'Second', userMessageId: secondId })
+      expect(window.localStorage.getItem('sim_mothership_handoff')).toBeNull()
+    })
+
+    /** Its POST came back with no answer, so no send is out to come back withdrawn. */
+    it('hands off what waits on a retry delay when no send is out', async () => {
+      vi.spyOn(window.navigator, 'onLine', 'get').mockReturnValue(true)
+      vi.stubGlobal('fetch', async (input: RequestInfo | URL, init?: RequestInit) => {
+        if (String(input) === '/api/mothership/chat' && init?.method === 'POST') {
+          state.postBodies.push(JSON.parse(String(init.body)))
+          throw new TypeError('Failed to fetch')
+        }
+        return fetchStub(input, init)
+      })
+      const view = renderUseChat()
+      await act(async () => {
+        void view.getResult().sendMessage('First')
+        await settle()
+      })
+      await act(async () => {
+        void view.getResult().sendMessage('Second')
+        await settle()
+      })
+      const firstId = idOf(view, 'First')
+      const secondId = idOf(view, 'Second')
+      const postsBefore = state.postBodies.length
+
+      view.unmount()
+      const handoff = MothershipHandoffStorage.consume('ws-1')
+      expect(handoff?.resumeUserMessageId).toBe(firstId)
+
+      admitSends()
+      const next = renderUseChat()
+      await act(async () => {
+        await next.getResult().sendMessage(handoff?.message ?? '', undefined, undefined, {
+          resumeUserMessageId: handoff?.resumeUserMessageId,
+        })
+      })
+      await waitFor(() => state.postBodies.length >= postsBefore + 2)
+
+      expect(
+        state.postBodies.slice(postsBefore).map((body) => [body.message, body.userMessageId])
+      ).toEqual([
+        ['First', firstId],
+        ['Second', secondId],
+      ])
+    })
+
+    /** What a new send of its own carries is no resume, so it takes nothing behind it. */
+    it('leaves handed-off messages for the surface that resumes the first', async () => {
+      const { view } = await sendTwoDuringAdmission()
+      view.unmount()
+      await waitFor(() => window.localStorage.getItem('sim_mothership_handoff') !== null)
+
+      admitSends()
+      const next = renderUseChat()
+      await act(async () => {
+        await next.getResult().sendMessage('Unrelated')
+      })
+      await settle()
+
+      expect(state.postBodies.slice(1).map((body) => body.message)).toEqual(['Unrelated'])
+    })
+  })
+
   describe('retrying a withdrawn send', () => {
     /**
      * The whole point of carrying the id: the server sees one logical send, so
 
@@ -113,6 +113,7 @@ import {
   canSteer,
   deliveryOf,
   fromJournaled,
+  handedOffJournalKey,
   hasOutgoingFollowUp,
   holdAfterErroredTurn,
   isDeliveredAsTurn,
@@ -125,6 +126,7 @@ import {
   orphanSteeringRows,
   outgoingRetryDelay,
   type SteeringOutcome,
+  toHandedOff,
   toJournaled,
   toMessageContexts,
 } from '@/app/workspace/[workspaceId]/home/hooks/outgoing-state'
@@ -4233,6 +4235,31 @@ export function useChat(
     [workspaceId, organizationId]
   )
 
+  /**
+   * A provisional key dies with this mount, so what it holds goes on to the next
+   * surface, in order: the first through the handoff, under its id, and the rest in
+   * the journal for the surface that resumes it, since a stored handoff holds one.
+   */
+  const handOffProvisionalOutgoing = useCallback(
+    (chatKey: string) => {
+      const undelivered = outgoingRef.current.filter(
+        (message) =>
+          message.chatKey === chatKey &&
+          message.status !== 'steered' &&
+          message.status !== 'applied'
+      )
+      writeOutgoing((current) => current.filter((message) => message.chatKey !== chatKey))
+      const resumed = undelivered.find((message) => message.status !== 'failed')
+      if (!resumed) return
+      const behind = undelivered.filter((message) => message !== resumed).map(toHandedOff)
+      if (behind.length > 0) {
+        useMothershipOutgoingStore.getState().record(handedOffJournalKey(resumed.id), behind)
+      }
+      handOffWithdrawnSend({ ...resumed.payload, userMessageId: resumed.id })
+    },
+    [handOffWithdrawnSend, writeOutgoing]
+  )
+
   /**
    * The turn a message sent now would steer: the running one, or the one whose
    * admission is still out in this chat (a message waits for that answer rather
@@ -4556,10 +4583,10 @@ export function useChat(
         }
         if (result.reason === 'withdrawn') {
           /* An unmount withdrew it before the server answered. A chat's journal keeps
-             it for the next mount of that chat; a new chat's goes to the next surface. */
+             it for the next mount of that chat; a new chat's goes to the next surface,
+             with whatever was waiting on its admission. */
           if (message.chatKey.startsWith(PENDING_CHAT_KEY_PREFIX)) {
-            settled()
-            handOffWithdrawnSend({ ...message.payload, userMessageId: result.userMessageId })
+            handOffProvisionalOutgoing(message.chatKey)
           } else {
             updateOutgoing(message.id, { status: 'pending', unconfirmed: true })
           }
@@ -4610,7 +4637,7 @@ export function useChat(
     }
   }, [
     deferOutgoing,
-    handOffWithdrawnSend,
+    handOffProvisionalOutgoing,
     liveStreamId,
     outgoingTurnSends,
     queryClient,
@@ -4788,6 +4815,12 @@ export function useChat(
       })
       const id = options?.resumeUserMessageId ?? generateId()
       const chatKey = chatKeyRef.current
+      const journal = useMothershipOutgoingStore.getState()
+      const handedOff = options?.resumeUserMessageId
+        ? (journal.chats[handedOffJournalKey(id)] ?? [])
+        : []
+      if (handedOff.length > 0) journal.record(handedOffJournalKey(id), [])
+      const now = Date.now()
       /* A new message is the user asking again, so anything held back in this chat
          (an unreachable Sim, a busy chat) tries again with it, ahead of it. */
       writeOutgoing((current) => [
@@ -4805,8 +4838,9 @@ export function useChat(
           status: 'pending',
           attempts: 0,
           reads: 0,
-          writtenAt: Date.now(),
+          writtenAt: now,
         },
+        ...handedOff.map((entry) => fromJournaled(chatKey, entry, now)),
       ])
       void deliverOutgoing()
       /* A message that goes straight out as its own turn resolves with that turn,
@@ -4860,6 +4894,22 @@ export function useChat(
     deliverOutgoing,
     writeOutgoing,
   ])
+  /* Nothing is out to come back withdrawn (a retry waiting on its delay), so nothing
+     else would carry what a new chat holds past this unmount. */
+  useEffect(
+    () => () => {
+      if (surfaceMountedRef.current) return
+      const chatKey = chatKeyRef.current
+      if (!chatKey.startsWith(PENDING_CHAT_KEY_PREFIX)) return
+      const sendOut = outgoingRef.current.some(
+        (message) =>
+          message.chatKey === chatKey &&
+          (message.status === 'sending' || message.status === 'steering')
+      )
+      if (!sendOut) handOffProvisionalOutgoing(chatKey)
+    },
+    [handOffProvisionalOutgoing]
+  )
   useEffect(() => {
     if (typeof window === 'undefined') return
     const retryOnline = () => {
 
@@ -23,7 +23,10 @@ export interface JournaledOutgoing {
 }
 
 interface MothershipOutgoingState {
-  /** Per chat id, in the order the messages were written. */
+  /**
+   * Per chat id, in the order the messages were written, and per handed-off message
+   * for what the surface that resumes it takes behind it (`handedOffJournalKey`).
+   */
   chats: Record<string, JournaledOutgoing[]>
   /** Replaces what a chat has to deliver; an empty list drops the chat. */
   record: (chatId: string, messages: JournaledOutgoing[]) => void