@@ -65,7 +65,10 @@ import {
 } from '@/app/workspace/[workspaceId]/home/components/user-input'
 import type { ModelSelectorOptions } from '@/app/workspace/[workspaceId]/home/components/user-input/components/model-selector'
 import { UserMessageContent } from '@/app/workspace/[workspaceId]/home/components/user-message-content'
-import { findLiveResponseId } from '@/app/workspace/[workspaceId]/home/hooks/steered-messages'
+import {
+  findLastConversationIndex,
+  findLiveResponseId,
+} from '@/app/workspace/[workspaceId]/home/hooks/steered-messages'
 import {
   fetchWorkspaceResourceRef,
   readCachedWorkspaceResourceRef,
@@ -746,6 +749,7 @@ export function MothershipChat({
     }
   }
   const lastIndex = messages.length - 1
+  const lastConversationIndex = findLastConversationIndex(messages)
   const lastRowKey = lastIndex >= 0 ? rowKeyByIndex[lastIndex] : undefined
   useEffect(() => {
     setLastRowAnimating(false)
@@ -975,7 +979,7 @@ export function MothershipChat({
               {virtualItems.map((virtualItem) => {
                 const index = virtualItem.index
                 const msg = messages[index]
-                const isLast = index === lastIndex
+                const isLast = index === lastConversationIndex
                 return (
                   <div
                     key={virtualItem.key}
 
@@ -0,0 +1,140 @@
+/**
+ * @vitest-environment jsdom
+ *
+ * Messages on their way into a turn, or shown as not delivered, render after its answer. Failure
+ * modes: the running answer loses its thinking indicator because a steered message trails it (an
+ * empty one disappears altogether); the last answer's choices stop responding because a message
+ * not delivered trails it; a real next message leaves the old answer's choices live.
+ */
+import { act } from 'react'
+import { integrationMatcherMock } from '@sim/testing/mocks/integration-matcher.mock'
+import { libDesktopMock } from '@sim/testing/mocks/lib-desktop.mock'
+import { nextNavigationMock } from '@sim/testing/mocks/next-navigation.mock'
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query'
+import { createRoot, type Root } from 'react-dom/client'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import { FeatureFlagsProvider } from '@/lib/core/config/feature-flags-context'
+import { MothershipChat } from '@/app/workspace/[workspaceId]/home/components/mothership-chat/mothership-chat'
+import type { ChatMessage } from '@/app/workspace/[workspaceId]/home/types'
+
+vi.mock('next/navigation', () => nextNavigationMock)
+vi.mock('@/lib/desktop', () => libDesktopMock)
+vi.mock('@/blocks/integration-matcher', () => integrationMatcherMock)
+
+const owner: ChatMessage = { id: 'turn', role: 'user', content: 'Count' }
+const steered: ChatMessage = {
+  id: 'steer',
+  role: 'user',
+  content: 'Stop at two',
+  steering: { streamId: 'turn' },
+  delivery: 'sending',
+}
+const notDelivered: ChatMessage = {
+  id: 'failed',
+  role: 'user',
+  content: 'Then summarize',
+  delivery: 'failed',
+}
+const choices: ChatMessage = {
+  id: 'answer',
+  role: 'assistant',
+  content: '',
+  contentBlocks: [{ type: 'options', options: [{ id: '1', label: 'Pick this one' }] }],
+}
+
+let root: Root
+let container: HTMLDivElement
+let client: QueryClient
+const onSubmit = vi.fn()
+
+beforeEach(() => {
+  vi.stubGlobal('IS_REACT_ACT_ENVIRONMENT', true)
+  vi.stubGlobal(
+    'ResizeObserver',
+    class {
+      observe() {}
+      unobserve() {}
+      disconnect() {}
+    }
+  )
+  vi.stubGlobal('matchMedia', () => ({
+    matches: true,
+    addEventListener: vi.fn(),
+    removeEventListener: vi.fn(),
+  }))
+  /* The virtualizer renders nothing into a viewport with no size. */
+  vi.spyOn(HTMLElement.prototype, 'offsetHeight', 'get').mockReturnValue(2_000)
+  vi.spyOn(HTMLElement.prototype, 'offsetWidth', 'get').mockReturnValue(800)
+  onSubmit.mockReset()
+  client = new QueryClient({ defaultOptions: { queries: { retry: false } } })
+  container = document.createElement('div')
+  document.body.append(container)
+  root = createRoot(container)
+})
+
+afterEach(async () => {
+  await act(async () => root.unmount())
+  client.clear()
+  container.remove()
+})
+
+async function renderChat(messages: ChatMessage[], isSending: boolean) {
+  await act(async () =>
+    root.render(
+      <QueryClientProvider client={client}>
+        <FeatureFlagsProvider
+          flags={{
+            dashboards: false,
+            'workflow-tests': false,
+            changelog: false,
+            'mothership-model-selector': false,
+            'mothership-plan-mode': false,
+            'mothership-computer-use': false,
+          }}
+        >
+          <MothershipChat
+            messages={messages}
+            isSending={isSending}
+            onSubmit={onSubmit}
+            onStopGeneration={vi.fn()}
+            composer={<div />}
+          />
+        </FeatureFlagsProvider>
+      </QueryClientProvider>
+    )
+  )
+}
+
+function findOption(): HTMLElement {
+  const option = [...container.querySelectorAll('button')].find((button) =>
+    button.textContent?.includes('Pick this one')
+  )
+  if (!option) throw new Error('The answer rendered no choice')
+  return option
+}
+
+describe('rows trailing an answer', () => {
+  it('keeps the thinking indicator on a running answer a steered message trails', async () => {
+    await renderChat(
+      [owner, { id: 'live', role: 'assistant', content: '', contentBlocks: [] }, steered],
+      true
+    )
+    expect(container.textContent).toContain('Stop at two')
+    expect(container.textContent).toContain('Thinking')
+  })
+
+  it('keeps the last answer’s choices live under a message shown as not delivered', async () => {
+    await renderChat([owner, choices, notDelivered], false)
+    await act(async () => findOption().click())
+    expect(onSubmit).toHaveBeenCalledOnce()
+  })
+
+  it('leaves an answer’s choices dead once a real next message follows it', async () => {
+    await renderChat(
+      [owner, choices, { id: 'next', role: 'user', content: 'Something else' }],
+      false
+    )
+    await act(async () => findOption().click())
+    expect(onSubmit).not.toHaveBeenCalled()
+  })
+})
@@ -248,7 +248,10 @@ export function findStreamOwnerIndex(messages: PersistedMessage[], streamId: str
 }
 
 /** The turn's response after its owner, past any steering the user sent into that turn. */
-export function findAssistantAfterOwner(messages: PersistedMessage[], ownerIndex: number): number {
+export function findAssistantAfterOwner(
+  messages: ReadonlyArray<Pick<PersistedMessage, 'role' | 'steering'>>,
+  ownerIndex: number
+): number {
   for (let index = ownerIndex + 1; index < messages.length; index++) {
     const message = messages[index]
     if (message.role === 'user' && !message.steering) return -1
 
@@ -24,6 +24,7 @@ import {
   isDeliveredAsTurn,
   MAX_OUTGOING_DELIVERY_ATTEMPTS,
   nextOutgoingStep,
+  nextOutgoingWake,
   ORPHAN_AUTO_SEND_MAX_AGE_MS,
   type OutgoingMessage,
   orphanSteeringRows,
@@ -262,6 +263,54 @@ describe('transitions', () => {
     expect(notBefore).toBeGreaterThan(NOW)
   })
 
+  it('never steers a message with a search scope, and shows it waits for its own turn', () => {
+    const scoped = entry('a', {
+      payload: { content: 'Summarize', assistantSearch: { startDate: '2026-11-01T00:00:00.000Z' } },
+    })
+    expect(nextOutgoingStep([scoped], view({ liveStreamId: 'turn' })).kind).toBe('idle')
+    expect(deliveryOf(scoped, true)).toBe('waiting')
+    expect(nextOutgoingStep([scoped], view())).toMatchObject({ kind: 'send', message: scoped })
+  })
+
+  it('clears the retry delay on every move to not delivered or applied', () => {
+    const delayed = { notBefore: NOW - 1 }
+    const context = { streamId: 'turn', turnErrored: false, now: NOW }
+    const steered = entry('a', { status: 'steered', streamId: 'turn', ...delayed })
+    for (const patch of [
+      afterUnsentAttempt(entry('a', { attempts: MAX_OUTGOING_DELIVERY_ATTEMPTS - 1, ...delayed }), {
+        online: true,
+        now: NOW,
+      }),
+      afterDispositionRead({ ...steered, reads: 7 }, { status: 'queued' }, context),
+      afterDispositionRead(steered, { status: 'applied' }, context),
+      afterDispositionRead(
+        { ...steered, attempts: 2 },
+        { status: 'not_applied' },
+        { ...context, turnErrored: true }
+      ),
+    ]) {
+      expect('notBefore' in patch && patch.notBefore === undefined).toBe(true)
+    }
+  })
+
+  it('wakes only for a delay the last pass could have skipped', () => {
+    const wake = (message: OutgoingMessage) => nextOutgoingWake([message], NOW)
+    for (const status of ['pending', 'steered'] as const) {
+      expect(wake(entry('a', { status, notBefore: NOW + 5 }))).toBe(NOW + 5)
+      expect(wake(entry('a', { status, notBefore: NOW }))).toBe(Number.POSITIVE_INFINITY)
+    }
+    for (const status of ['failed', 'applied'] as const) {
+      expect(wake(entry('a', { status, notBefore: NOW + 5 }))).toBe(Number.POSITIVE_INFINITY)
+    }
+    expect(wake(entry('a'))).toBe(Number.POSITIVE_INFINITY)
+    expect(
+      nextOutgoingWake(
+        [entry('a', { notBefore: NOW + 9 }), entry('b', { notBefore: NOW + 3 })],
+        NOW
+      )
+    ).toBe(NOW + 3)
+  })
+
   it('leaves reads out of the budget for sends', () => {
     const read = afterDispositionRead(
       entry('a', { status: 'steered', streamId: 'turn' }),
 
@@ -126,10 +126,16 @@ export function optimisticUserMessageFor(id: string, payload: SendPayload): Chat
 
 /**
  * Whether a message can be steered: steering carries its files and mentions like a
- * turn, but needs text, so a message of files alone goes out as a turn.
+ * turn, but needs text, so a message of files alone goes out as a turn. It has no
+ * search scope, so a message asking for one (a Summarize of found documents) goes
+ * out as a turn too, rather than running without it.
  */
-function canSteer(payload: SendPayload): boolean {
-  return payload.content.trim().length > 0 && payload.content.length <= MAX_STEERING_CONTENT_LENGTH
+export function canSteer(payload: SendPayload): boolean {
+  return (
+    !payload.assistantSearch &&
+    payload.content.trim().length > 0 &&
+    payload.content.length <= MAX_STEERING_CONTENT_LENGTH
+  )
 }
 
 /** The journal entry an outgoing message is restored from; a steer in flight restores as sent. */
@@ -183,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]
 
 /**
@@ -273,6 +302,7 @@ export function notSteered(streamId: string, turnErrored: boolean): Partial<Outg
     refusedBy: streamId,
     streamId: undefined,
     unconfirmed: false,
+    notBefore: undefined,
   }
 }
 
@@ -283,7 +313,7 @@ export function afterUnsentAttempt(
 ): Partial<OutgoingMessage> {
   const attempts = message.attempts + 1
   if (attempts >= MAX_OUTGOING_DELIVERY_ATTEMPTS) {
-    return { status: 'failed', attempts, unconfirmed: true }
+    return { status: 'failed', attempts, unconfirmed: true, notBefore: undefined }
   }
   return {
     status: 'pending',
@@ -304,13 +334,15 @@ export function afterDispositionRead(
   if (outcome.status === 'applied') {
     return {
       status: 'applied',
+      notBefore: undefined,
       ...(outcome.textOffset !== undefined ? { textOffset: outcome.textOffset } : {}),
     }
   }
   if (outcome.status === 'not_applied') {
+    const refused = notSteered(context.streamId, context.turnErrored || message.noAutoSend === true)
     return {
-      ...notSteered(context.streamId, context.turnErrored || message.noAutoSend === true),
-      ...(message.attempts > 0
+      ...refused,
+      ...(refused.status === 'pending' && message.attempts > 0
         ? { notBefore: context.now + outgoingRetryDelay(message.attempts) }
         : {}),
     }
@@ -319,14 +351,33 @@ export function afterDispositionRead(
      as one whose owner died, does not keep it waiting forever. */
   const reads = message.reads + 1
   return reads >= MAX_DISPOSITION_READS
-    ? { status: 'failed', reads }
+    ? { status: 'failed', reads, notBefore: undefined }
     : {
         reads,
         unconfirmed: outcome.status === 'unknown',
         notBefore: context.now + outgoingRetryDelay(reads),
       }
 }
 
+/**
+ * When a delivery pass next has to run for a chat's messages: the earliest delay
+ * that was still running when the last pass began, so that pass could have skipped
+ * it. A delay already over by then decides nothing: what still waits after it waits
+ * on a turn's end or the network, which wake delivery themselves, and arming for it
+ * would run passes back to back until they do. Infinite when nothing is due.
+ */
+export function nextOutgoingWake(inChat: readonly OutgoingMessage[], passBegan: number): number {
+  return Math.min(
+    ...inChat.flatMap((message) =>
+      (message.status === 'pending' || message.status === 'steered') &&
+      message.notBefore !== undefined &&
+      message.notBefore > passBegan
+        ? [message.notBefore]
+        : []
+    )
+  )
+}
+
 /**
  * The user asked again: one steered reads its disposition again rather than going
  * out twice, and what never reached a turn goes out, through the steering gate if a
 
@@ -78,6 +78,18 @@ export function findLiveResponseId(messages: readonly ChatMessage[]): string | u
   return undefined
 }
 
+/**
+ * The last row of the conversation proper: messages on their way into a turn, or
+ * shown as not delivered, trail it without being its end. The answer here is the one
+ * still thinking, and the one whose choices can still be picked.
+ */
+export function findLastConversationIndex(messages: readonly ChatMessage[]): number {
+  for (let index = messages.length - 1; index >= 0; index--) {
+    if (!messages[index].steering && !messages[index].delivery) return index
+  }
+  return -1
+}
+
 const ANSWER_SEGMENT_MARKER = ':before:'
 
 /**