diff --git a/src/renderer/src/components/native-chat/NativeChatComposer.tsx b/src/renderer/src/components/native-chat/NativeChatComposer.tsx
index 44a6d8b865dc..e4e9e97659a5 100644
--- a/src/renderer/src/components/native-chat/NativeChatComposer.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatComposer.tsx
@@ -66,6 +66,7 @@ const NativeChatComposerPane = forwardRef<NativeChatComposerHandle, NativeChatCo
       optimisticSendOutcome,
       onOptimisticSendCanceled,
       onSlashCommand,
+      onSubmitted,
       answerCommandLocally,
       onSwitchToTerminal,
       readTerminalScreen,
@@ -225,6 +226,7 @@ const NativeChatComposerPane = forwardRef<NativeChatComposerHandle, NativeChatCo
         agent,
         disabled,
         onSlashCommand,
+        onSubmitted,
         resolveTarget,
         setHistory
       })
@@ -255,23 +257,16 @@ const NativeChatComposerPane = forwardRef<NativeChatComposerHandle, NativeChatCo
       setCaret
     })
 
-    const sendPty = useNativeChatPtyComposerSend({
+    // What both terminal send paths share: where a command goes and what the composer resets.
+    const ptyCommandRouting = {
       agent,
-      draft,
-      imageAttachments,
       disabled,
       isDispatchingSessionOption,
-      launchDraft: launchSeed?.launchDraft,
-      launchDraftResolved: launchSeed?.launchDraftResolved === true,
-      readTerminalScreen,
       resolveTarget,
-      classifySend,
-      onOptimisticSend,
-      optimisticSendOutcome,
       onSlashCommand,
+      onSubmitted,
       answerCommandLocally,
       sessionOptionsSurface: ptySessionOptionsSurface,
-      terminalTabId,
       trackPendingSend,
       setHistory,
       setDraft,
@@ -279,6 +274,18 @@ const NativeChatComposerPane = forwardRef<NativeChatComposerHandle, NativeChatCo
       clearSkillOrigin,
       clearImageAttachments,
       setNotice
+    }
+    const sendPty = useNativeChatPtyComposerSend({
+      ...ptyCommandRouting,
+      draft,
+      imageAttachments,
+      launchDraft: launchSeed?.launchDraft,
+      launchDraftResolved: launchSeed?.launchDraftResolved === true,
+      readTerminalScreen,
+      classifySend,
+      onOptimisticSend,
+      optimisticSendOutcome,
+      terminalTabId
     })
     const { send, goalMode } = useNativeChatComposerSubmit({
       structuredTransport,
@@ -303,21 +310,8 @@ const NativeChatComposerPane = forwardRef<NativeChatComposerHandle, NativeChatCo
     })
 
     const dispatchPtyPickerCommand = useNativeChatPickerCommandDispatch({
-      agent,
-      disabled,
-      isDispatchingSessionOption,
-      resolveTarget,
-      onSlashCommand,
-      answerCommandLocally,
-      sessionOptionsSurface: ptySessionOptionsSurface,
-      trackPendingSend,
-      setHistory,
-      setDraft,
-      setCaret,
-      setActiveSuggestion,
-      clearSkillOrigin,
-      clearImageAttachments,
-      setNotice
+      ...ptyCommandRouting,
+      setActiveSuggestion
     })
     const dispatchPickerCommand = useCallback(
       (command: Parameters<typeof dispatchPtyPickerCommand>[0]) =>
diff --git a/src/renderer/src/components/native-chat/NativeChatJumpToLatest.tsx b/src/renderer/src/components/native-chat/NativeChatJumpToLatest.tsx
index 66a0d4e88306..7b041b3c4b7b 100644
--- a/src/renderer/src/components/native-chat/NativeChatJumpToLatest.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatJumpToLatest.tsx
@@ -7,7 +7,7 @@ import { ArrowDown } from 'lucide-react'
 import { translate } from '@/i18n/i18n'
 
 /** Keeps focus where the reader was typing: a pointer press never moves it here. */
-function keepFocus(event: React.MouseEvent): void {
+export function keepFocus(event: React.MouseEvent): void {
   event.preventDefault()
 }
 
@@ -27,7 +27,7 @@ export function NativeChatJumpToLatest({
       aria-hidden={!visible || undefined}
       onMouseDown={keepFocus}
       onClick={onJump}
-      className="absolute bottom-3 left-1/2 flex h-8 -translate-x-1/2 items-center gap-1.5 rounded-full border border-border bg-popover px-3 text-xs font-medium text-popover-foreground shadow-floating transition-[opacity,translate] duration-150 ease-out hover:bg-accent hover:text-accent-foreground focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring motion-reduce:transition-none data-[shown=false]:pointer-events-none data-[shown=false]:translate-y-1 data-[shown=false]:opacity-0"
+      className="pointer-events-auto flex h-8 items-center gap-1.5 rounded-full border border-border bg-popover px-3 text-xs font-medium text-popover-foreground shadow-floating transition-[opacity,translate] duration-150 ease-out hover:bg-accent hover:text-accent-foreground focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring motion-reduce:transition-none data-[shown=false]:pointer-events-none data-[shown=false]:translate-y-1 data-[shown=false]:opacity-0"
     >
       <ArrowDown className="size-3.5" />
       <span>{label}</span>
diff --git a/src/renderer/src/components/native-chat/NativeChatJumpToTop.test.tsx b/src/renderer/src/components/native-chat/NativeChatJumpToTop.test.tsx
new file mode 100644
index 000000000000..0ba0c5c028fc
--- /dev/null
+++ b/src/renderer/src/components/native-chat/NativeChatJumpToTop.test.tsx
@@ -0,0 +1,45 @@
+// @vitest-environment happy-dom
+
+import '@testing-library/jest-dom/vitest'
+
+import { cleanup, screen } from '@testing-library/react'
+import userEvent from '@testing-library/user-event'
+import { afterEach, expect, it, vi } from 'vitest'
+import { render } from './native-chat-app-root-test-render'
+import { NativeChatJumpToTop } from './NativeChatJumpToTop'
+
+afterEach(cleanup)
+
+// The reader is usually mid-draft when they reach for this: a press must not take the caret.
+it('leaves focus in the composer when pressed with the pointer', async () => {
+  const startFromBeginning = vi.fn()
+  render(
+    <>
+      <NativeChatJumpToTop visible historyJump={{ startPending: false, startFromBeginning }} />
+      <textarea aria-label="Message" />
+    </>
+  )
+  const composer = screen.getByRole('textbox', { name: 'Message' })
+  composer.focus()
+
+  await userEvent.click(screen.getByRole('button', { name: 'Jump to top' }))
+
+  // Anti-vacuous: the press did act.
+  expect(startFromBeginning).toHaveBeenCalledOnce()
+  expect(document.activeElement).toBe(composer)
+})
+
+// Mounted while hidden so it can fade out; it must not stay reachable meanwhile.
+it('stays mounted but unreachable while hidden', () => {
+  const { container } = render(
+    <NativeChatJumpToTop
+      visible={false}
+      historyJump={{ startPending: false, startFromBeginning: vi.fn() }}
+    />
+  )
+
+  expect(screen.queryByRole('button', { name: 'Jump to top' })).toBeNull()
+  const button = container.querySelector('button')
+  expect(button).toHaveAttribute('inert')
+  expect(button).toHaveAttribute('data-shown', 'false')
+})
diff --git a/src/renderer/src/components/native-chat/NativeChatJumpToTop.tsx b/src/renderer/src/components/native-chat/NativeChatJumpToTop.tsx
new file mode 100644
index 000000000000..ecc413e90129
--- /dev/null
+++ b/src/renderer/src/components/native-chat/NativeChatJumpToTop.tsx
@@ -0,0 +1,49 @@
+// The way to the start of the conversation, offered beside "Jump to latest".
+//
+// Mounted and inert while hidden, like "Jump to latest", so it fades rather than pops.
+
+import { ArrowUp, Loader2 } from 'lucide-react'
+import { Tooltip, TooltipContent, TooltipTrigger } from '@/components/ui/tooltip'
+import { translate } from '@/i18n/i18n'
+import { keepFocus } from './NativeChatJumpToLatest'
+import type { useNativeChatRailHistoryJump } from './use-native-chat-rail-history-jump'
+
+export function NativeChatJumpToTop({
+  visible,
+  historyJump
+}: {
+  visible: boolean
+  historyJump: Pick<
+    ReturnType<typeof useNativeChatRailHistoryJump>,
+    'startPending' | 'startFromBeginning'
+  >
+}): React.JSX.Element {
+  const pending = historyJump.startPending
+  const label = translate('components.native-chat.jumpToTop', 'Jump to top')
+  return (
+    <Tooltip>
+      <TooltipTrigger asChild>
+        <button
+          type="button"
+          aria-label={label}
+          aria-busy={pending || undefined}
+          data-shown={visible}
+          inert={!visible}
+          aria-hidden={!visible || undefined}
+          onMouseDown={keepFocus}
+          onClick={historyJump.startFromBeginning}
+          className="pointer-events-auto flex size-8 items-center justify-center rounded-full border border-border bg-popover text-popover-foreground shadow-floating transition-[opacity,translate] duration-150 ease-out hover:bg-accent hover:text-accent-foreground focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring motion-reduce:transition-none data-[shown=false]:pointer-events-none data-[shown=false]:translate-y-1 data-[shown=false]:opacity-0"
+        >
+          {pending ? (
+            <Loader2 className="size-3.5 animate-spin motion-reduce:animate-none" />
+          ) : (
+            <ArrowUp className="size-3.5" />
+          )}
+        </button>
+      </TooltipTrigger>
+      <TooltipContent side="top" sideOffset={4}>
+        {label}
+      </TooltipContent>
+    </Tooltip>
+  )
+}
diff --git a/src/renderer/src/components/native-chat/NativeChatMessageList.growth-windowing.test.tsx b/src/renderer/src/components/native-chat/NativeChatMessageList.growth-windowing.test.tsx
index f74ace43e501..973bdf66d041 100644
--- a/src/renderer/src/components/native-chat/NativeChatMessageList.growth-windowing.test.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatMessageList.growth-windowing.test.tsx
@@ -2,7 +2,8 @@
 
 import '@testing-library/jest-dom/vitest'
 
-import { act, cleanup, fireEvent, render, screen } from '@testing-library/react'
+import { act, cleanup, fireEvent, screen } from '@testing-library/react'
+import { render } from './native-chat-app-root-test-render'
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 import type { NativeChatMessage } from '../../../../shared/native-chat-types'
 import { NativeChatMessageList } from './NativeChatMessageList'
@@ -453,6 +454,7 @@ describe('transcript follow ownership across growth and appends', () => {
     const scheduleSpy = vi.spyOn(window, 'requestAnimationFrame')
     const scrollToSpy = vi.spyOn(scroller, 'scrollTo')
     const readingAt = 2000
+    fireEvent.wheel(scroller, { deltaY: -100 })
     scroller.scrollTop = readingAt
     fireEvent.scroll(scroller)
     expect(scrollToSpy).toHaveBeenLastCalledWith({ behavior: 'auto', top: readingAt })
diff --git a/src/renderer/src/components/native-chat/NativeChatMessageList.interrupted-turn-fold.test.tsx b/src/renderer/src/components/native-chat/NativeChatMessageList.interrupted-turn-fold.test.tsx
index f9d2ee5e3a14..bfffd1925b4b 100644
--- a/src/renderer/src/components/native-chat/NativeChatMessageList.interrupted-turn-fold.test.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatMessageList.interrupted-turn-fold.test.tsx
@@ -2,7 +2,8 @@
 
 import '@testing-library/jest-dom/vitest'
 
-import { cleanup, render, screen } from '@testing-library/react'
+import { cleanup, screen } from '@testing-library/react'
+import { render } from './native-chat-app-root-test-render'
 import { afterAll, afterEach, beforeAll, describe, expect, it, vi } from 'vitest'
 import type {
   AgentJournalRenderItem,
diff --git a/src/renderer/src/components/native-chat/NativeChatMessageList.live-reasoning.test.tsx b/src/renderer/src/components/native-chat/NativeChatMessageList.live-reasoning.test.tsx
index 505c87d763e0..7c0643c00984 100644
--- a/src/renderer/src/components/native-chat/NativeChatMessageList.live-reasoning.test.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatMessageList.live-reasoning.test.tsx
@@ -2,7 +2,8 @@
 
 import '@testing-library/jest-dom/vitest'
 
-import { cleanup, fireEvent, render, screen } from '@testing-library/react'
+import { cleanup, fireEvent, screen } from '@testing-library/react'
+import { render } from './native-chat-app-root-test-render'
 import { afterAll, afterEach, beforeAll, describe, expect, it, vi } from 'vitest'
 import type { NativeChatLiveSession } from './use-native-chat-live-session'
 import { NativeChatMessageList } from './NativeChatMessageList'
diff --git a/src/renderer/src/components/native-chat/NativeChatMessageList.message-rail-windowing.test.tsx b/src/renderer/src/components/native-chat/NativeChatMessageList.message-rail-windowing.test.tsx
index 858eb230c299..9afb8a749e14 100644
--- a/src/renderer/src/components/native-chat/NativeChatMessageList.message-rail-windowing.test.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatMessageList.message-rail-windowing.test.tsx
@@ -2,7 +2,8 @@
 
 import '@testing-library/jest-dom/vitest'
 
-import { act, cleanup, fireEvent, render, screen } from '@testing-library/react'
+import { act, cleanup, fireEvent, screen } from '@testing-library/react'
+import { render } from './native-chat-app-root-test-render'
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 import type {
   AgentJournalItemBody,
@@ -26,7 +27,19 @@ afterEach(cleanup)
 describe('revealing a diff from a turn rollup', () => {
   let restoreLayout = (): void => {}
   beforeEach(() => {
-    restoreLayout = stubLayout()
+    restoreLayout = stubLayout({ scrollGeometry: true })
+    vi.spyOn(HTMLElement.prototype, 'getBoundingClientRect').mockImplementation(function (
+      this: HTMLElement
+    ) {
+      const row = this.closest<HTMLElement>('[data-index]')
+      const scroller = this.closest<HTMLElement>('[data-native-chat-scroll]')
+      return new DOMRect(
+        0,
+        row ? Number.parseFloat(row.style.top) - (scroller?.scrollTop ?? 0) : 0,
+        100,
+        this.offsetHeight
+      )
+    })
   })
   afterEach(() => {
     restoreLayout()
@@ -79,7 +92,7 @@ describe('revealing a diff from a turn rollup', () => {
     ].map((item, index) => ({ ...item, sequence: index + 1 }))
     const scrollTo = vi.fn()
     vi.spyOn(HTMLElement.prototype, 'scrollTo').mockImplementation(scrollTo)
-    const { container } = render(
+    const transcript = (): React.JSX.Element => (
       <NativeChatMessageList
         session={session(projectStructuredItemsToNativeChat(withPrompts))}
         journalItems={withPrompts}
@@ -87,6 +100,11 @@ describe('revealing a diff from a turn rollup', () => {
         expandSignal={false}
       />
     )
+    const { container, rerender } = render(transcript())
+    const selectedTop = Number.parseFloat(
+      screen.getByText('Second prompt').closest<HTMLElement>('[data-index]')?.style.top ?? ''
+    )
+    expect(selectedTop).toBeGreaterThan(0)
     fireEvent.click(screen.getByRole('button', { name: /1 changed file/ }))
     fireEvent.click(screen.getByRole('button', { name: /src\/a.ts/ }))
     scrollTranscript(container, 6000)
@@ -94,14 +112,27 @@ describe('revealing a diff from a turn rollup', () => {
     scrollTo.mockClear()
     fireEvent.click(screen.getByRole('button', { name: 'Your messages' }))
     fireEvent.click(screen.getByRole('button', { name: 'Second prompt' }))
-    expect(scrollTo).toHaveBeenCalledTimes(1)
+    expect(scrollTo.mock.calls).toEqual([
+      [{ top: 6000, behavior: 'auto' }],
+      [{ top: selectedTop, behavior: 'smooth' }]
+    ])
     expect(screen.queryByRole('button', { name: /^Edited .*a\.ts(?:\s|$)/ })).toBeNull()
+    scrollTo.mockClear()
+    rerender(transcript())
+    rerender(transcript())
+    expect(scrollTo).not.toHaveBeenCalled()
 
     scrollTranscript(container, 0)
     scrollTo.mockClear()
     fireEvent.click(screen.getByRole('button', { name: /1 changed file/ }))
     fireEvent.click(screen.getByRole('button', { name: /src\/a.ts/ }))
-    expect(scrollTo).toHaveBeenCalledTimes(1)
+    const diffTop = Number.parseFloat(
+      screen.getByText('Edited').closest<HTMLElement>('[data-index]')?.style.top ?? ''
+    )
+    expect(Number.isFinite(diffTop)).toBe(true)
+    expect(scrollTo.mock.calls.filter(([options]) => options?.behavior === 'smooth')).toEqual([
+      [{ top: diffTop, behavior: 'smooth' }]
+    ])
   })
 })
 
diff --git a/src/renderer/src/components/native-chat/NativeChatMessageList.older-history.test.tsx b/src/renderer/src/components/native-chat/NativeChatMessageList.older-history.test.tsx
index 7bcf897db66f..4ba45d354ddf 100644
--- a/src/renderer/src/components/native-chat/NativeChatMessageList.older-history.test.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatMessageList.older-history.test.tsx
@@ -2,7 +2,8 @@
 
 import '@testing-library/jest-dom/vitest'
 
-import { act, cleanup, fireEvent, render, screen } from '@testing-library/react'
+import { act, cleanup, fireEvent, screen } from '@testing-library/react'
+import { render } from './native-chat-app-root-test-render'
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 import type { NativeChatMessage } from '../../../../shared/native-chat-types'
 import { NativeChatMessageList } from './NativeChatMessageList'
diff --git a/src/renderer/src/components/native-chat/NativeChatMessageList.provider-retry-runs.test.tsx b/src/renderer/src/components/native-chat/NativeChatMessageList.provider-retry-runs.test.tsx
index 06bc89d8c16c..6cbf9746e2a4 100644
--- a/src/renderer/src/components/native-chat/NativeChatMessageList.provider-retry-runs.test.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatMessageList.provider-retry-runs.test.tsx
@@ -2,7 +2,8 @@
 
 import '@testing-library/jest-dom/vitest'
 
-import { cleanup, render, screen } from '@testing-library/react'
+import { cleanup, screen } from '@testing-library/react'
+import { render } from './native-chat-app-root-test-render'
 import { afterAll, afterEach, beforeAll, describe, expect, it, vi } from 'vitest'
 import { agentSessionFailureWords } from '../../../../shared/agent-session-failure-words'
 import type { AgentJournalRenderItem } from '../../../../shared/agent-session-journal-types'
diff --git a/src/renderer/src/components/native-chat/NativeChatMessageList.queued-turn-order.test.tsx b/src/renderer/src/components/native-chat/NativeChatMessageList.queued-turn-order.test.tsx
index c50397706f6a..0e3a5020e600 100644
--- a/src/renderer/src/components/native-chat/NativeChatMessageList.queued-turn-order.test.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatMessageList.queued-turn-order.test.tsx
@@ -2,7 +2,8 @@
 
 import '@testing-library/jest-dom/vitest'
 
-import { cleanup, render, screen } from '@testing-library/react'
+import { cleanup, screen } from '@testing-library/react'
+import { render } from './native-chat-app-root-test-render'
 import { afterAll, afterEach, beforeAll, describe, expect, it, vi } from 'vitest'
 import type {
   AgentJournalItemBody,
diff --git a/src/renderer/src/components/native-chat/NativeChatMessageList.rail-history-jump.test.tsx b/src/renderer/src/components/native-chat/NativeChatMessageList.rail-history-jump.test.tsx
index 9155f50f4215..294a0a53e809 100644
--- a/src/renderer/src/components/native-chat/NativeChatMessageList.rail-history-jump.test.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatMessageList.rail-history-jump.test.tsx
@@ -2,8 +2,9 @@
 
 import '@testing-library/jest-dom/vitest'
 
-import { act, cleanup, fireEvent, render, screen } from '@testing-library/react'
-import { useCallback, useMemo, useState } from 'react'
+import { act, cleanup, fireEvent, screen } from '@testing-library/react'
+import { render } from './native-chat-app-root-test-render'
+import { createRef, useCallback, useMemo, useState } from 'react'
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 import type {
   AgentJournalItemBody,
@@ -14,6 +15,7 @@ import { projectStructuredItemsToNativeChat } from '../../../../shared/structure
 import { NativeChatMessageList } from './NativeChatMessageList'
 import type { NativeChatRailOutlineEntry } from './native-chat-message-rail-items'
 import type { NativeChatOlderPageResult } from './native-chat-pagination'
+import type { NativeChatMessageListHandle } from './use-native-chat-reveal-latest'
 import {
   estimateNativeChatRowHeight,
   nativeChatRowContentMetrics
@@ -70,17 +72,23 @@ const ROW_HEIGHT_BY_TEXT = new Map(
 /** A lane that pages older history in the way the structured lane does: the page
  *  lands, then the returned promise settles. The outline is the unloaded prompts. */
 function PagedTranscript({
-  holdPage
+  holdPage,
+  listRef
 }: {
   /** Awaited before a page lands, to keep it in flight. */
   holdPage?: () => Promise<void>
+  /** What a send reaches to reveal the latest. */
+  listRef?: React.Ref<NativeChatMessageListHandle>
 }): React.JSX.Element {
   const [loaded, setLoaded] = useState(PAGE)
   const loadEarlier = useCallback(async (): Promise<NativeChatOlderPageResult> => {
+    if (loaded >= TOTAL) {
+      return 'exhausted'
+    }
     await (holdPage?.() ?? Promise.resolve())
     setLoaded((current) => Math.min(TOTAL, current + PAGE))
     return 'applied'
-  }, [holdPage])
+  }, [holdPage, loaded])
   const messages = useMemo(() => HISTORY.slice(TOTAL - loaded), [loaded])
   const railOutline = useMemo<NativeChatRailOutlineEntry[]>(
     () =>
@@ -95,6 +103,7 @@ function PagedTranscript({
   )
   return (
     <NativeChatMessageList
+      ref={listRef}
       session={{ ...session(messages), hasMore: loaded < TOTAL, loadEarlier }}
       railOutline={railOutline}
       isWorking={false}
@@ -435,6 +444,7 @@ describe('jumping from the rail while following the end', () => {
     await settle(10)
     // A reader parked above the end, so the button shows.
     act(() => {
+      fireEvent.wheel(scroller(), { deltaY: -100 })
       scroller().scrollTop = 200
     })
     await settle(2)
@@ -450,6 +460,122 @@ describe('jumping from the rail while following the end', () => {
     expect(screen.queryByText('prompt-5')).toBeNull()
     expect(distanceFromBottom()).toBe(0)
   })
+
+  /** A reader parked above the end, so the jump buttons show. */
+  async function parkAboveTheEnd(): Promise<void> {
+    act(() => {
+      fireEvent.wheel(scroller(), { deltaY: -100 })
+      scroller().scrollTop = 200
+    })
+    await settle(2)
+  }
+
+  it('"Jump to top" loads every older page and lands on the first message', async () => {
+    render(<PagedTranscript />)
+    await settle(10)
+    // Anti-vacuous: only the newest page is loaded, and the controls hide at the end.
+    expect(screen.queryByText('prompt-0')).toBeNull()
+    expect(screen.queryByRole('button', { name: 'Jump to top' })).toBeNull()
+    await parkAboveTheEnd()
+
+    fireEvent.click(screen.getByRole('button', { name: 'Jump to top' }))
+    await settle(60)
+
+    expect(screen.getByText('prompt-0')).toBeTruthy()
+    expect(scroller().scrollTop).toBe(0)
+    expect(screen.queryByRole('button', { name: /load earlier messages/i })).toBeNull()
+  })
+
+  it('marks "Jump to top" busy, with a reduced-motion-safe spinner, while its pages load', async () => {
+    const pages = holdFirstPage()
+    render(<PagedTranscript holdPage={pages.holdPage} />)
+    await settle(10)
+    await parkAboveTheEnd()
+    const top = screen.getByRole('button', { name: 'Jump to top' })
+    // Anti-vacuous: idle until pressed.
+    expect(top).not.toHaveAttribute('aria-busy')
+
+    fireEvent.click(top)
+    await frame()
+
+    expect(pages.asked()).toBe(1)
+    expect(top).toHaveAttribute('aria-busy', 'true')
+    expect(top.querySelector('svg')).toHaveClass('animate-spin', 'motion-reduce:animate-none')
+    pages.release()
+    await settle(60)
+    expect(scroller().scrollTop).toBe(0)
+    expect(top).not.toHaveAttribute('aria-busy')
+  })
+
+  it.each([
+    ['the reader wheels the transcript', () => fireEvent.wheel(scroller(), { deltaY: -40 })],
+    ['the reader presses a scroll key', () => fireEvent.keyDown(scroller(), { key: 'PageUp' })]
+  ])('abandons "Jump to top" when %s while it pages', async (_case, input) => {
+    const pages = holdFirstPage()
+    render(<PagedTranscript holdPage={pages.holdPage} />)
+    await settle(10)
+    await parkAboveTheEnd()
+    const top = screen.getByRole('button', { name: 'Jump to top' })
+    fireEvent.click(top)
+    await frame()
+    // Anti-vacuous: the older page is in flight.
+    expect(pages.asked()).toBe(1)
+
+    input()
+    await frame()
+    expect(top).not.toHaveAttribute('aria-busy')
+    pages.release()
+    await settle(60)
+
+    // The abandoned jump would have paged on and pulled the reader up to the first message.
+    expect(pages.asked()).toBe(1)
+    expect(screen.queryByText('prompt-0')).toBeNull()
+    expect(scroller().scrollTop).toBeGreaterThan(0)
+  })
+
+  it('abandons "Jump to top" when the reader sends while it pages', async () => {
+    const pages = holdFirstPage()
+    const listRef = createRef<NativeChatMessageListHandle>()
+    render(<PagedTranscript holdPage={pages.holdPage} listRef={listRef} />)
+    await settle(10)
+    await parkAboveTheEnd()
+    fireEvent.click(screen.getByRole('button', { name: 'Jump to top' }))
+    await frame()
+    expect(pages.asked()).toBe(1)
+
+    // What a send does to the transcript.
+    act(() => listRef.current?.revealLatest())
+    await frame()
+    pages.release()
+    await settle(60)
+
+    expect(pages.asked()).toBe(1)
+    expect(screen.queryByText('prompt-0')).toBeNull()
+    expect(distanceFromBottom()).toBe(0)
+  })
+
+  it('jumps to a message without animating when the reader asks for reduced motion', async () => {
+    vi.spyOn(window, 'matchMedia').mockImplementation((query: string) => ({
+      matches: query === '(prefers-reduced-motion: reduce)',
+      media: query,
+      onchange: null,
+      addEventListener: () => {},
+      removeEventListener: () => {},
+      addListener: () => {},
+      removeListener: () => {},
+      dispatchEvent: () => false
+    }))
+    render(<PagedTranscript />)
+    await settle(10)
+
+    fireEvent.click(screen.getByRole('button', { name: 'Your messages' }))
+    await frame()
+    fireEvent.click(screen.getByRole('button', { name: 'prompt-45' }))
+    await frame()
+
+    // A smooth scroll would still be easing in here, a few pixels from where it started.
+    expect(Math.abs(rowOffsetFromViewportTop('prompt-45'))).toBeLessThanOrEqual(2)
+  })
 })
 
 describe('revealing a diff while a rail jump pages', () => {
diff --git a/src/renderer/src/components/native-chat/NativeChatMessageList.reader-navigation.test.tsx b/src/renderer/src/components/native-chat/NativeChatMessageList.reader-navigation.test.tsx
new file mode 100644
index 000000000000..08e1b29a9a60
--- /dev/null
+++ b/src/renderer/src/components/native-chat/NativeChatMessageList.reader-navigation.test.tsx
@@ -0,0 +1,453 @@
+// @vitest-environment happy-dom
+
+import '@testing-library/jest-dom/vitest'
+
+import { act, cleanup, fireEvent, screen } from '@testing-library/react'
+import { render } from './native-chat-app-root-test-render'
+import { createRef } from 'react'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import type { NativeChatMessage } from '../../../../shared/native-chat-types'
+import { routeNativeChatRootKeyToInput } from './native-chat-root-key-routing'
+import { NativeChatMessageList } from './NativeChatMessageList'
+import type { NativeChatMessageListHandle } from './use-native-chat-reveal-latest'
+import {
+  BELOW_TRANSCRIPT_PX,
+  deliverResizes,
+  layout,
+  list,
+  marker,
+  ROW_PX,
+  scrollTranscript,
+  session,
+  stubLayout,
+  stubResizeObserver,
+  TRANSCRIPT_LENGTH,
+  VIEWPORT_PX
+} from './native-chat-windowing-test-harness'
+
+afterEach(cleanup)
+
+function scrollRoot(container: HTMLElement): HTMLElement {
+  const scroller = container.querySelector<HTMLElement>('[data-native-chat-scroll]')
+  if (!scroller) {
+    throw new Error('no transcript scroll root')
+  }
+  return scroller
+}
+
+/** Deliver resize and scroll events to a fixed point, as a painted frame would. */
+function paint(container: HTMLElement): void {
+  const scroller = scrollRoot(container)
+  let lastScrollTop = scroller.scrollTop
+  for (let pass = 0; pass < 12; pass += 1) {
+    let changed = false
+    act(() => {
+      changed = deliverResizes()
+      vi.advanceTimersByTime(16)
+    })
+    if (scroller.scrollTop !== lastScrollTop) {
+      lastScrollTop = scroller.scrollTop
+      fireEvent.scroll(scroller)
+      changed = true
+    }
+    if (!changed && pass >= 2) {
+      return
+    }
+  }
+  throw new Error('the transcript never settled: resize and scroll kept moving it')
+}
+
+function distanceFromBottom(container: HTMLElement): number {
+  const scroller = scrollRoot(container)
+  return scroller.scrollHeight - scroller.clientHeight - scroller.scrollTop
+}
+
+const transcript = Array.from({ length: TRANSCRIPT_LENGTH }, (_, index) => marker(index))
+
+function userMessage(index: number, text: string): NativeChatMessage {
+  return {
+    id: `message-${index}`,
+    role: 'user',
+    blocks: [{ type: 'text', text }],
+    timestamp: index + 1,
+    source: 'transcript'
+  }
+}
+
+function toolMessage(index: number): NativeChatMessage {
+  return {
+    id: `message-${index}`,
+    role: 'assistant',
+    blocks: [
+      { type: 'tool-call', name: 'shell', input: { command: 'pwd' }, state: 'completed' },
+      { type: 'tool-result', output: '/repo' }
+    ],
+    timestamp: index + 1,
+    source: 'transcript'
+  }
+}
+
+function liveList(messages: NativeChatMessage[]): React.JSX.Element {
+  return <NativeChatMessageList session={session(messages)} isWorking expandSignal={false} />
+}
+
+/** The last `count` closed tool runs, with the row each sits in. */
+function closedRuns(count: number): { toggle: HTMLElement; rowIndex: number }[] {
+  return screen
+    .getAllByRole('button', { expanded: false })
+    .slice(-count)
+    .map((toggle) => {
+      const row = toggle.closest<HTMLElement>('[data-index]')
+      if (!row) {
+        throw new Error('the tool run has no mounted row')
+      }
+      return { toggle, rowIndex: Number(row.dataset.index) }
+    })
+}
+
+/** Click a run's toggle and let its row re-measure, as a painted frame would. */
+function toggleRun(container: HTMLElement, toggle: HTMLElement, openRows: readonly number[]): void {
+  fireEvent.click(toggle)
+  const heights = Array.from({ length: Math.max(-1, ...openRows) + 1 }, () => ROW_PX)
+  for (const rowIndex of openRows) {
+    heights[rowIndex] = ROW_PX * 6
+  }
+  layout.measuredRowHeights = heights
+  paint(container)
+}
+
+function offersJumpToLatest(): boolean {
+  return screen.queryByRole('button', { name: 'Jump to latest' }) !== null
+}
+
+describe('reader navigation', () => {
+  let restore: (() => void)[] = []
+  beforeEach(() => {
+    vi.useFakeTimers()
+    restore = [stubLayout({ scrollGeometry: true, offsetChain: true }), stubResizeObserver()]
+    layout.belowTranscriptPx = BELOW_TRANSCRIPT_PX
+    layout.aboveTranscriptPx = 0
+  })
+  afterEach(() => {
+    for (const undo of restore.toReversed()) {
+      undo()
+    }
+    layout.measuredRowHeights = []
+    vi.useRealTimers()
+  })
+
+  it('brings a reader who scrolled up to what they just sent, and follows its reply', () => {
+    const handle = createRef<NativeChatMessageListHandle>()
+    const view = (messages: NativeChatMessage[], isWorking: boolean) => (
+      <NativeChatMessageList
+        ref={handle}
+        session={session(messages)}
+        isWorking={isWorking}
+        expandSignal={false}
+      />
+    )
+    const { container, rerender } = render(view(transcript, false))
+    paint(container)
+    scrollTranscript(container, 1000)
+    paint(container)
+    // Anti-vacuous: the reader is parked well above the end.
+    expect(distanceFromBottom(container)).toBeGreaterThan(1000)
+
+    act(() => handle.current?.revealLatest())
+    const sent = [...transcript, userMessage(TRANSCRIPT_LENGTH, 'follow-up question')]
+    rerender(view(sent, true))
+    paint(container)
+    rerender(view([...sent, marker(TRANSCRIPT_LENGTH + 1)], true))
+    paint(container)
+
+    expect(distanceFromBottom(container)).toBe(0)
+    expect(screen.getByText('follow-up question')).toBeInTheDocument()
+    expect(screen.queryByRole('button', { name: 'Jump to latest' })).toBeNull()
+  })
+
+  it('stops following when the reader pages up from the focused transcript', () => {
+    const { container, rerender } = render(liveList(transcript))
+    paint(container)
+    const scroller = scrollRoot(container)
+    scroller.focus()
+    fireEvent.keyDown(scroller, { key: 'PageUp' })
+    // The browser pages the focused scroller; the key is all that says a reader moved it.
+    scroller.scrollTop -= scroller.clientHeight
+    fireEvent.scroll(scroller)
+    const pagedTo = scroller.scrollTop
+    rerender(liveList([...transcript, marker(TRANSCRIPT_LENGTH)]))
+    paint(container)
+
+    expect(scroller.scrollTop).toBe(pagedTo)
+    expect(offersJumpToLatest()).toBe(true)
+  })
+
+  it('leaves a reader who scrolled up in place when a message arrives from another device', () => {
+    const { container, rerender } = render(liveList(transcript))
+    paint(container)
+    scrollTranscript(container, 1000)
+    paint(container)
+    const readingAt = scrollRoot(container).scrollTop
+
+    const delivered = [...transcript, userMessage(TRANSCRIPT_LENGTH, 'sent from the phone')]
+    rerender(liveList(delivered))
+    paint(container)
+    rerender(liveList([...delivered, marker(TRANSCRIPT_LENGTH + 1)]))
+    paint(container)
+
+    expect(scrollRoot(container).scrollTop).toBe(readingAt)
+    expect(offersJumpToLatest()).toBe(true)
+  })
+
+  it('keeps following when the reader opens a tool run at the live end', () => {
+    const toolIndex = TRANSCRIPT_LENGTH
+    const withTool = [...transcript, toolMessage(toolIndex)]
+    const { container, rerender } = render(liveList(withTool))
+    paint(container)
+    // Anti-vacuous: following the end, so the run sits at the bottom of the view.
+    expect(distanceFromBottom(container)).toBe(0)
+    const scrollTopBeforeOpen = scrollRoot(container).scrollTop
+
+    const [run] = closedRuns(1)
+    toggleRun(container, run.toggle, [run.rowIndex])
+    expect(run.toggle).toHaveAttribute('aria-expanded', 'true')
+    rerender(liveList([...withTool, marker(toolIndex + 1), marker(toolIndex + 2)]))
+    paint(container)
+
+    // The opened output and the streamed rows both pushed the end down, and the view went with it.
+    expect(scrollRoot(container).scrollTop).toBeGreaterThan(scrollTopBeforeOpen)
+    expect(distanceFromBottom(container)).toBe(0)
+    expect(offersJumpToLatest()).toBe(false)
+  })
+
+  describe('closing what the reader opened', () => {
+    const toolIndex = TRANSCRIPT_LENGTH
+    const withTool = [...transcript, toolMessage(toolIndex)]
+    const streamedOn = [...withTool, marker(toolIndex + 1), marker(toolIndex + 2)]
+
+    it('stays where the reader scrolled to while it was open', () => {
+      const { container, rerender } = render(liveList(withTool))
+      paint(container)
+      const [run] = closedRuns(1)
+      toggleRun(container, run.toggle, [run.rowIndex])
+      const scrolledTo = scrollRoot(container).scrollTop - 100
+      scrollTranscript(container, scrolledTo)
+      paint(container)
+
+      toggleRun(container, run.toggle, [])
+      rerender(liveList(streamedOn))
+      paint(container)
+
+      expect(scrollRoot(container).scrollTop).toBe(scrolledTo)
+      expect(offersJumpToLatest()).toBe(true)
+    })
+
+    it('leaves a reader who had already scrolled away where they are', () => {
+      const { container, rerender } = render(liveList(withTool))
+      paint(container)
+      const scrolledTo = scrollRoot(container).scrollTop - 100
+      scrollTranscript(container, scrolledTo)
+      paint(container)
+      const [run] = closedRuns(1)
+
+      toggleRun(container, run.toggle, [run.rowIndex])
+      toggleRun(container, run.toggle, [])
+      rerender(liveList(streamedOn))
+      paint(container)
+
+      expect(scrollRoot(container).scrollTop).toBe(scrolledTo)
+      expect(offersJumpToLatest()).toBe(true)
+    })
+  })
+
+  it('keeps following when an earlier turn expands under a pending tail pin', () => {
+    const messages = [
+      userMessage(0, 'Earlier turn'),
+      ...Array.from({ length: 8 }, (_, i) => toolMessage(i + 1)),
+      marker(9),
+      userMessage(10, 'Current turn'),
+      marker(11)
+    ]
+    const { container } = render(
+      <NativeChatMessageList
+        session={session(messages)}
+        isWorking
+        expandSignal={false}
+        settledTurns={new Map([['message-0', { startedAt: 1, workedSeconds: 1 }]])}
+      />
+    )
+    const lastRow = screen.getByText('marker-11').closest<HTMLElement>('[data-index]')
+    if (!lastRow) {
+      throw new Error('The current answer is not mounted')
+    }
+    layout.measuredRowHeights = Array.from(
+      { length: Number(lastRow.dataset.index) + 1 },
+      (_, index) => (index === Number(lastRow.dataset.index) ? ROW_PX * 20 : ROW_PX)
+    )
+    paint(container)
+    const scroller = scrollRoot(container)
+    const window = container.querySelector<HTMLElement>('[data-native-chat-window]')
+    const beforeSlots = window?.querySelectorAll('[data-index]').length ?? 0
+    // A pin created outside the painted frames is still waiting to reconcile by numeric index.
+    layout.belowTranscriptPx += 20
+    deliverResizes()
+    expect(scroller.scrollTop).toBeGreaterThan(0)
+    fireEvent.click(screen.getByRole('button', { name: 'Toggle turn details' }))
+    // Anti-vacuous: the expansion inserted rows before the tail the pin named.
+    expect(window?.querySelectorAll('[data-index]').length ?? 0).toBeGreaterThan(beforeSlots)
+    paint(container)
+    act(() => vi.advanceTimersByTime(160))
+    paint(container)
+
+    expect(distanceFromBottom(container)).toBe(0)
+    expect(screen.getByText('marker-11')).toBeInTheDocument()
+  })
+
+  it.each([false, true])(
+    'keeps Space scrolling in the focused transcript (shift=%s)',
+    (shiftKey) => {
+      const insertTypedText = vi.fn(() => true)
+      const focus = vi.fn(() => true)
+      const composer = {
+        focus,
+        insertTypedText,
+        handlePasteEvent: vi.fn(),
+        pasteFromClipboard: vi.fn(),
+        contains: () => false
+      }
+      const { container } = render(
+        <div onKeyDownCapture={(event) => routeNativeChatRootKeyToInput(event, composer, null)}>
+          {list(transcript)}
+        </div>
+      )
+      const root = scrollRoot(container)
+      root.focus()
+      fireEvent.keyDown(root, { key: ' ', shiftKey })
+      expect(document.activeElement).toBe(root)
+      expect(insertTypedText).not.toHaveBeenCalled()
+      expect(focus).not.toHaveBeenCalled()
+      fireEvent.keyDown(root, { key: 'a' })
+      expect(insertTypedText).toHaveBeenCalledWith('a')
+    }
+  )
+
+  it('offers the way to the top only once the start of a loaded transcript is out of view', () => {
+    const { container } = render(list(transcript))
+    paint(container)
+    scrollTranscript(container, VIEWPORT_PX / 2)
+    paint(container)
+    // Anti-vacuous: the reader has left the end, so the way back down is offered.
+    expect(offersJumpToLatest()).toBe(true)
+    // The first message is still on screen: there is nowhere further up to go.
+    expect(screen.queryByRole('button', { name: 'Jump to top' })).toBeNull()
+
+    scrollTranscript(container, VIEWPORT_PX * 2)
+    paint(container)
+
+    expect(screen.getByRole('button', { name: 'Jump to top' })).not.toHaveAttribute('inert')
+  })
+
+  it('makes the transcript a keyboard stop, so the scroll keys can reach it', () => {
+    const { container } = render(list(transcript))
+
+    expect(scrollRoot(container)).toHaveAttribute('tabindex', '0')
+  })
+
+  it('names the transcript as a region, so a focused scroll stop is announced', () => {
+    const { container } = render(list(transcript))
+
+    expect(screen.getByRole('region', { name: 'Conversation' })).toBe(scrollRoot(container))
+  })
+})
+
+describe('disclosure following across retained pane visibility', () => {
+  let visible = true
+  let restore: (() => void)[] = []
+  beforeEach(() => {
+    visible = true
+    vi.useFakeTimers()
+    layout.belowTranscriptPx = BELOW_TRANSCRIPT_PX
+    layout.aboveTranscriptPx = 0
+    layout.measuredRowHeights = []
+    restore = [
+      stubLayout({ scrollGeometry: true, offsetChain: true, isVisible: () => visible }),
+      stubResizeObserver()
+    ]
+  })
+  afterEach(() => {
+    for (const undo of restore.toReversed()) {
+      undo()
+    }
+    layout.measuredRowHeights = []
+    vi.useRealTimers()
+  })
+
+  function view(messages: NativeChatMessage[]): React.JSX.Element {
+    return (
+      <NativeChatMessageList
+        session={session(messages)}
+        isVisible={visible}
+        isWorking
+        expandSignal={false}
+      />
+    )
+  }
+
+  it.each([false, true])(
+    'follows passive growth after underflow disclosure (hide before settlement=%s)',
+    (hideBeforeSettlement) => {
+      const initial = [marker(0), toolMessage(1)]
+      const rendered = render(view(initial))
+      paint(rendered.container)
+      const scroller = scrollRoot(rendered.container)
+      expect(scroller.scrollHeight).toBeLessThan(scroller.clientHeight)
+      fireEvent.click(screen.getByRole('button', { expanded: false }))
+      if (hideBeforeSettlement) {
+        visible = false
+        rendered.rerender(view(initial))
+        act(() => vi.advanceTimersByTime(300))
+        visible = true
+        rendered.rerender(view(initial))
+      }
+      paint(rendered.container)
+      expect(scroller.scrollHeight).toBeLessThan(scroller.clientHeight)
+      expect(scroller.scrollTop).toBe(0)
+      const grown = [...initial, ...Array.from({ length: 200 }, (_, i) => marker(i + 10))]
+      rendered.rerender(view(grown))
+      paint(rendered.container)
+      expect(scroller.scrollHeight).toBeGreaterThan(scroller.clientHeight + 1000)
+      expect(distanceFromBottom(rendered.container)).toBe(0)
+      expect(screen.getByText('marker-209')).toBeInTheDocument()
+    }
+  )
+
+  it.each([false, true])(
+    'restores distant history after interrupted disclosure (growth while hidden=%s)',
+    (growWhileHidden) => {
+      const initial = transcript.with(20, toolMessage(20))
+      const grown = [...initial, ...Array.from({ length: 200 }, (_, i) => marker(i + 1000))]
+      const rendered = render(view(initial))
+      paint(rendered.container)
+      scrollTranscript(rendered.container, 900)
+      paint(rendered.container)
+      const scroller = scrollRoot(rendered.container)
+      expect(distanceFromBottom(rendered.container)).toBeGreaterThan(1000)
+      const readingAt = scroller.scrollTop
+      fireEvent.click(screen.getByRole('button', { expanded: false }))
+      visible = false
+      rendered.rerender(view(growWhileHidden ? grown : initial))
+      paint(rendered.container)
+      act(() => vi.advanceTimersByTime(300))
+      visible = true
+      rendered.rerender(view(growWhileHidden ? grown : initial))
+      paint(rendered.container)
+      expect(scroller.scrollTop).toBe(readingAt)
+      expect(distanceFromBottom(rendered.container)).toBeGreaterThan(1000)
+      expect(offersJumpToLatest()).toBe(true)
+      rendered.rerender(view([...grown, marker(1200)]))
+      paint(rendered.container)
+      expect(scroller.scrollTop).toBe(readingAt)
+      expect(distanceFromBottom(rendered.container)).toBeGreaterThan(1000)
+    }
+  )
+})
diff --git a/src/renderer/src/components/native-chat/NativeChatMessageList.stopping-turn-bar.test.tsx b/src/renderer/src/components/native-chat/NativeChatMessageList.stopping-turn-bar.test.tsx
index 65e7f5303965..dfc96c5f518f 100644
--- a/src/renderer/src/components/native-chat/NativeChatMessageList.stopping-turn-bar.test.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatMessageList.stopping-turn-bar.test.tsx
@@ -2,7 +2,8 @@
 
 import '@testing-library/jest-dom/vitest'
 
-import { cleanup, render, screen } from '@testing-library/react'
+import { cleanup, screen } from '@testing-library/react'
+import { render } from './native-chat-app-root-test-render'
 import { afterAll, afterEach, beforeAll, describe, expect, it, vi } from 'vitest'
 import type { NativeChatLiveSession } from './use-native-chat-live-session'
 import { NativeChatMessageList } from './NativeChatMessageList'
diff --git a/src/renderer/src/components/native-chat/NativeChatMessageList.stream-render.perf.test.tsx b/src/renderer/src/components/native-chat/NativeChatMessageList.stream-render.perf.test.tsx
index 9e5a5cac000f..5f281f8d2163 100644
--- a/src/renderer/src/components/native-chat/NativeChatMessageList.stream-render.perf.test.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatMessageList.stream-render.perf.test.tsx
@@ -2,7 +2,8 @@
 
 import '@testing-library/jest-dom/vitest'
 
-import { cleanup, fireEvent, render, screen } from '@testing-library/react'
+import { cleanup, fireEvent, screen } from '@testing-library/react'
+import { render } from './native-chat-app-root-test-render'
 import { afterAll, afterEach, beforeAll, describe, expect, it, vi } from 'vitest'
 import type * as NativeChatProseModule from '../../../../shared/native-chat-prose'
 import type { NativeChatMessage } from '../../../../shared/native-chat-types'
diff --git a/src/renderer/src/components/native-chat/NativeChatMessageList.subagent-sections.test.tsx b/src/renderer/src/components/native-chat/NativeChatMessageList.subagent-sections.test.tsx
index 17f4231417b5..c0ca7325f205 100644
--- a/src/renderer/src/components/native-chat/NativeChatMessageList.subagent-sections.test.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatMessageList.subagent-sections.test.tsx
@@ -2,7 +2,8 @@
 
 import '@testing-library/jest-dom/vitest'
 
-import { cleanup, fireEvent, render, screen, within } from '@testing-library/react'
+import { cleanup, fireEvent, screen, within } from '@testing-library/react'
+import { render } from './native-chat-app-root-test-render'
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 import type {
   AgentJournalItemBody,
diff --git a/src/renderer/src/components/native-chat/NativeChatMessageList.task-list-frames.test.tsx b/src/renderer/src/components/native-chat/NativeChatMessageList.task-list-frames.test.tsx
index 2682515ff603..71fef3debd42 100644
--- a/src/renderer/src/components/native-chat/NativeChatMessageList.task-list-frames.test.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatMessageList.task-list-frames.test.tsx
@@ -2,7 +2,8 @@
 
 import '@testing-library/jest-dom/vitest'
 
-import { cleanup, fireEvent, render, screen, within } from '@testing-library/react'
+import { cleanup, fireEvent, screen, within } from '@testing-library/react'
+import { render } from './native-chat-app-root-test-render'
 import { afterAll, afterEach, beforeAll, describe, expect, it, vi } from 'vitest'
 import type { AgentJournalStatusItem } from '../../../../shared/agent-session-journal-types'
 import { projectStructuredItemToNativeChat } from '../../../../shared/structured-agent-session-projection'
diff --git a/src/renderer/src/components/native-chat/NativeChatMessageList.test.tsx b/src/renderer/src/components/native-chat/NativeChatMessageList.test.tsx
index 0394d024804f..7bc7ddd3795a 100644
--- a/src/renderer/src/components/native-chat/NativeChatMessageList.test.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatMessageList.test.tsx
@@ -2,7 +2,8 @@
 
 import '@testing-library/jest-dom/vitest'
 
-import { cleanup, fireEvent, render, screen } from '@testing-library/react'
+import { cleanup, fireEvent, screen } from '@testing-library/react'
+import { render } from './native-chat-app-root-test-render'
 import { afterAll, afterEach, beforeAll, describe, expect, it, vi } from 'vitest'
 import { subagentGroupFallbackText } from '../../../../shared/native-chat-subagent-summary'
 import type {
diff --git a/src/renderer/src/components/native-chat/NativeChatMessageList.tool-stream-cost.test.tsx b/src/renderer/src/components/native-chat/NativeChatMessageList.tool-stream-cost.test.tsx
index bff8c8b623c9..6646315a2740 100644
--- a/src/renderer/src/components/native-chat/NativeChatMessageList.tool-stream-cost.test.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatMessageList.tool-stream-cost.test.tsx
@@ -1,5 +1,6 @@
 // @vitest-environment happy-dom
-import { cleanup, render, screen } from '@testing-library/react'
+import { cleanup, screen } from '@testing-library/react'
+import { render } from './native-chat-app-root-test-render'
 import { afterAll, afterEach, beforeAll, expect, it, vi } from 'vitest'
 import type { AgentJournalRenderItem } from '../../../../shared/agent-session-journal-types'
 import type * as EditNormalization from '../../../../shared/native-chat-edit-normalize'
diff --git a/src/renderer/src/components/native-chat/NativeChatMessageList.tsx b/src/renderer/src/components/native-chat/NativeChatMessageList.tsx
index 594c289882f6..50ad2e110ed9 100644
--- a/src/renderer/src/components/native-chat/NativeChatMessageList.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatMessageList.tsx
@@ -3,9 +3,11 @@ import {
   NATIVE_CHAT_TRANSCRIPT_COLUMN_CLASS
 } from './native-chat-appearance-style'
 import { NativeChatJumpToLatest } from './NativeChatJumpToLatest'
+import { NativeChatJumpToTop } from './NativeChatJumpToTop'
 import { useNativeChatRowTypography } from './use-native-chat-row-typography'
 import { useCallback, useLayoutEffect, useMemo, useRef, useState } from 'react'
 import type { CommentMarkdownLinkClickHandler } from '@/components/sidebar/CommentMarkdown'
+import { translate } from '@/i18n/i18n'
 import type { NativeChatLiveSession } from './use-native-chat-live-session'
 import { useNativeChatTranscriptProjection } from './use-native-chat-transcript-projection'
 import { structuredQuestionTranscript } from './structured-agent-question-projection'
@@ -46,7 +48,8 @@ import type {
   NativeChatRailOutlineEntry
 } from './native-chat-message-rail-items'
 import { useNativeChatRailHistoryJump } from './use-native-chat-rail-history-jump'
-import { nativeChatReaderScrollInputHandlers } from './native-chat-reader-scroll-input'
+import { useNativeChatReaderScrollInput } from './native-chat-reader-scroll-input'
+import { useNativeChatMessageListHandle } from './use-native-chat-reveal-latest'
 
 import type {
   AgentJournalRenderItem,
@@ -67,6 +70,7 @@ type NativeChatNavigationRequest =
   | { kind: 'rail'; messageId: string; requestId: number }
 
 export function NativeChatMessageList({
+  ref,
   session,
   journalItems,
   journalSubmissions,
@@ -86,6 +90,7 @@ export function NativeChatMessageList({
   stopping = false,
   runtimeContext
 }: {
+  ref?: Parameters<typeof useNativeChatMessageListHandle>[0]
   session: NativeChatLiveSession
   journalItems?: readonly AgentJournalRenderItem[]
   /** With the items, what places each row in its turn (structured lane). */
@@ -222,7 +227,7 @@ export function NativeChatMessageList({
     // mutually exclusive things to be doing.
     revealIndex: nativeChatSlotIndexOf(slots, railJump?.messageId ?? revealedDiff?.messageId)
   })
-  const { showJump, onScroll, scrollToBottom, scrollMessageToTop } = useNativeChatTranscriptScroll({
+  const transcriptScroll = useNativeChatTranscriptScroll({
     scrollRef,
     contentRef,
     itemCount: slots.length,
@@ -235,6 +240,10 @@ export function NativeChatMessageList({
     consumeProgrammaticScroll: transcriptWindow.consumeProgrammaticScroll,
     reconcileReaderScroll: transcriptWindow.reconcileReaderScroll
   })
+  const { showJump, onScroll, scrollToBottom, scrollMessageToTop, readerLeavesEnd } =
+    transcriptScroll
+  // Offered only beside the way back down, so a reader following the end sees neither.
+  const showJumpToTop = showJump && (showOlderHistory || transcriptScroll.awayFromTop)
   const olderHistory = useNativeChatOlderHistoryAutoload({
     scrollRef,
     historyKey: `${session.agent}:${session.sessionId ?? ''}:${session.olderHistoryGeneration}`,
@@ -261,26 +270,30 @@ export function NativeChatMessageList({
   const railHistoryJump = useNativeChatRailHistoryJump({
     items: rail.items,
     sessionKey: `${session.agent}:${session.sessionId}`,
+    isVisible,
     loadEarlier,
-    jumpToLoaded: requestRailJump
+    jumpToLoaded: requestRailJump,
+    jumpToStart: transcriptScroll.scrollToTop
   })
   const { start: startHistoryJump, abort: beginNavigation } = railHistoryJump
   // Every navigation begins by aborting a history jump still paging, which would
   // otherwise land later and pull the reader away from where they just went.
   const selectRailItem = useCallback(
     (item: NativeChatRailItem) => {
+      beginNavigation()
+      readerLeavesEnd()
       if (item.slotIndex === null) {
         startHistoryJump(item)
         return
       }
-      beginNavigation()
       requestRailJump(item)
     },
-    [beginNavigation, requestRailJump, startHistoryJump]
+    [beginNavigation, readerLeavesEnd, requestRailJump, startHistoryJump]
   )
   const revealDiff = useCallback(
     (target: NativeChatDiffTarget) => {
       beginNavigation()
+      readerLeavesEnd()
       // A subagent's edit is revealed inside its section.
       if (target.subagentSections) {
         openSubagentSections(target.subagentSections)
@@ -291,16 +304,17 @@ export function NativeChatMessageList({
         target: { ...target, requestId: navigationSequence.current }
       })
     },
-    [beginNavigation, openSubagentSections]
+    [beginNavigation, readerLeavesEnd, openSubagentSections]
   )
   const jumpToLatest = useCallback(() => {
     beginNavigation()
     scrollToBottom()
   }, [beginNavigation, scrollToBottom])
-  const readerScrollInput = useMemo(
-    () => nativeChatReaderScrollInputHandlers(beginNavigation),
-    [beginNavigation]
-  )
+  useNativeChatMessageListHandle(ref, jumpToLatest)
+  const readerScrollInput = useNativeChatReaderScrollInput(scrollRef, {
+    onReaderScroll: beginNavigation,
+    onLeaveEnd: readerLeavesEnd
+  })
   // Pinning the target mounts it in the same commit, so the row exists by the time
   // layout runs. Routed through `scrollMessageToTop` rather than the virtualizer
   // because that is what releases the bottom pin — without it the next streamed
@@ -361,12 +375,13 @@ export function NativeChatMessageList({
           <div
             ref={scrollRef}
             onScroll={onScroll}
-            {...readerScrollInput}
+            {...readerScrollInput.scrollerProps}
             // Named so measurement can find the scroll root without depending on
             // which utility class happens to make it scroll.
             data-native-chat-scroll
+            aria-label={translate('components.native-chat.transcriptLabel', 'Conversation')}
             // Browser anchoring would add unattributed movement beside the virtualizer's anchor.
-            className="scrollbar-sleek relative h-full overflow-y-auto [overflow-anchor:none] [scrollbar-gutter:stable_both-edges]"
+            className="scrollbar-sleek relative h-full overflow-y-auto [overflow-anchor:none] [scrollbar-gutter:stable_both-edges] focus-visible:outline-none focus-visible:ring-1 focus-visible:ring-inset focus-visible:ring-ring"
           >
             {showOlderHistory ? (
               <NativeChatOlderHistoryRow
@@ -404,10 +419,14 @@ export function NativeChatMessageList({
             rail={rail}
             scrollRef={scrollRef}
             onSelect={selectRailItem}
-            onReaderScroll={beginNavigation}
+            onReaderScroll={readerScrollInput.railWheel}
             pendingId={railHistoryJump.pendingId}
           />
-          <NativeChatJumpToLatest visible={showJump} onJump={jumpToLatest} />
+          {/* The way up sits left of the way down, which stays centered. */}
+          <div className="pointer-events-none absolute inset-x-0 bottom-3 grid grid-cols-[1fr_auto_1fr] justify-items-end gap-2">
+            <NativeChatJumpToTop visible={showJumpToTop} historyJump={railHistoryJump} />
+            <NativeChatJumpToLatest visible={showJump} onJump={jumpToLatest} />
+          </div>
         </div>
         {taskListState.list && taskListState.list.tasks.length > 0 ? (
           <div className="shrink-0 px-3 pb-2 sm:px-4">
diff --git a/src/renderer/src/components/native-chat/NativeChatMessageList.turn-fold.test.tsx b/src/renderer/src/components/native-chat/NativeChatMessageList.turn-fold.test.tsx
index 93fd2ac6447c..374383e727b3 100644
--- a/src/renderer/src/components/native-chat/NativeChatMessageList.turn-fold.test.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatMessageList.turn-fold.test.tsx
@@ -2,7 +2,8 @@
 
 import '@testing-library/jest-dom/vitest'
 
-import { cleanup, fireEvent, render, screen } from '@testing-library/react'
+import { cleanup, fireEvent, screen } from '@testing-library/react'
+import { render } from './native-chat-app-root-test-render'
 import { afterAll, afterEach, beforeAll, describe, expect, it, vi } from 'vitest'
 import type {
   AgentJournalRenderItem,
diff --git a/src/renderer/src/components/native-chat/NativeChatMessageList.turn-history.test.tsx b/src/renderer/src/components/native-chat/NativeChatMessageList.turn-history.test.tsx
index 5192ece83ff2..638ce7cf7771 100644
--- a/src/renderer/src/components/native-chat/NativeChatMessageList.turn-history.test.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatMessageList.turn-history.test.tsx
@@ -1,6 +1,7 @@
 // @vitest-environment happy-dom
 import '@testing-library/jest-dom/vitest'
-import { cleanup, fireEvent, render, screen } from '@testing-library/react'
+import { cleanup, fireEvent, screen } from '@testing-library/react'
+import { render } from './native-chat-app-root-test-render'
 import { afterAll, afterEach, beforeAll, describe, expect, it, vi } from 'vitest'
 import type {
   AgentJournalItemBody,
diff --git a/src/renderer/src/components/native-chat/NativeChatMessageList.turn-indicator.test.tsx b/src/renderer/src/components/native-chat/NativeChatMessageList.turn-indicator.test.tsx
index d04332411607..66f9b0ad0c5f 100644
--- a/src/renderer/src/components/native-chat/NativeChatMessageList.turn-indicator.test.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatMessageList.turn-indicator.test.tsx
@@ -2,7 +2,8 @@
 
 import '@testing-library/jest-dom/vitest'
 
-import { cleanup, fireEvent, render, screen } from '@testing-library/react'
+import { cleanup, fireEvent, screen } from '@testing-library/react'
+import { render } from './native-chat-app-root-test-render'
 import { afterAll, afterEach, beforeAll, describe, expect, it, vi } from 'vitest'
 import type { NativeChatLiveSession } from './use-native-chat-live-session'
 import { NativeChatMessageList } from './NativeChatMessageList'
diff --git a/src/renderer/src/components/native-chat/NativeChatMessageList.turn-membership.test.tsx b/src/renderer/src/components/native-chat/NativeChatMessageList.turn-membership.test.tsx
index 55321468e223..7436bc0fe797 100644
--- a/src/renderer/src/components/native-chat/NativeChatMessageList.turn-membership.test.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatMessageList.turn-membership.test.tsx
@@ -2,7 +2,8 @@
 
 import '@testing-library/jest-dom/vitest'
 
-import { cleanup, render, screen } from '@testing-library/react'
+import { cleanup, screen } from '@testing-library/react'
+import { render } from './native-chat-app-root-test-render'
 import { afterAll, afterEach, beforeAll, describe, expect, it, vi } from 'vitest'
 import {
   agentJournalItemKey,
diff --git a/src/renderer/src/components/native-chat/NativeChatMessageList.turn-timing.test.tsx b/src/renderer/src/components/native-chat/NativeChatMessageList.turn-timing.test.tsx
index 5caedaded515..774e2ef3399c 100644
--- a/src/renderer/src/components/native-chat/NativeChatMessageList.turn-timing.test.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatMessageList.turn-timing.test.tsx
@@ -2,7 +2,8 @@
 
 import '@testing-library/jest-dom/vitest'
 
-import { cleanup, render, screen } from '@testing-library/react'
+import { cleanup, screen } from '@testing-library/react'
+import { render } from './native-chat-app-root-test-render'
 import { afterAll, afterEach, beforeAll, describe, expect, it, vi } from 'vitest'
 import type { NativeChatLiveSession } from './use-native-chat-live-session'
 import { NativeChatMessageList } from './NativeChatMessageList'
diff --git a/src/renderer/src/components/native-chat/NativeChatMessageList.unloaded-live-turn.test.tsx b/src/renderer/src/components/native-chat/NativeChatMessageList.unloaded-live-turn.test.tsx
index 641916ee314a..2cf099f8a79e 100644
--- a/src/renderer/src/components/native-chat/NativeChatMessageList.unloaded-live-turn.test.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatMessageList.unloaded-live-turn.test.tsx
@@ -5,7 +5,8 @@
 
 import '@testing-library/jest-dom/vitest'
 
-import { cleanup, render, screen } from '@testing-library/react'
+import { cleanup, screen } from '@testing-library/react'
+import { render } from './native-chat-app-root-test-render'
 import { afterAll, afterEach, beforeAll, describe, expect, it, vi } from 'vitest'
 import type {
   AgentJournalRenderItem,
diff --git a/src/renderer/src/components/native-chat/NativeChatMessageList.unsent-message.test.tsx b/src/renderer/src/components/native-chat/NativeChatMessageList.unsent-message.test.tsx
index 28affc5512d5..3c71947c786a 100644
--- a/src/renderer/src/components/native-chat/NativeChatMessageList.unsent-message.test.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatMessageList.unsent-message.test.tsx
@@ -6,7 +6,8 @@
 
 import '@testing-library/jest-dom/vitest'
 
-import { cleanup, render } from '@testing-library/react'
+import { cleanup } from '@testing-library/react'
+import { render } from './native-chat-app-root-test-render'
 import { afterAll, afterEach, beforeAll, describe, expect, it, vi } from 'vitest'
 import type {
   AgentJournalItemBody,
diff --git a/src/renderer/src/components/native-chat/NativeChatMessageList.windowing.test.tsx b/src/renderer/src/components/native-chat/NativeChatMessageList.windowing.test.tsx
index 489bd992d1c2..61768441bda5 100644
--- a/src/renderer/src/components/native-chat/NativeChatMessageList.windowing.test.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatMessageList.windowing.test.tsx
@@ -2,7 +2,8 @@
 
 import '@testing-library/jest-dom/vitest'
 
-import { act, cleanup, fireEvent, render, screen } from '@testing-library/react'
+import { act, cleanup, fireEvent, screen } from '@testing-library/react'
+import { render } from './native-chat-app-root-test-render'
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 import type {
   AgentJournalItemBody,
diff --git a/src/renderer/src/components/native-chat/NativeChatMessageRail.tsx b/src/renderer/src/components/native-chat/NativeChatMessageRail.tsx
index f6429c969a91..945610e4c932 100644
--- a/src/renderer/src/components/native-chat/NativeChatMessageRail.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatMessageRail.tsx
@@ -111,7 +111,7 @@ export const NativeChatMessageRail = memo(function NativeChatMessageRail({
   scrollRef: React.RefObject<HTMLDivElement | null>
   onSelect: (item: NativeChatRailItem) => void
   /** The reader scrolled the transcript through the rail. */
-  onReaderScroll?: () => void
+  onReaderScroll?: (deltaY: number) => void
   /** A tick whose older history is still paging in. */
   pendingId?: string | null
 }): React.JSX.Element | null {
@@ -200,8 +200,11 @@ export const NativeChatMessageRail = memo(function NativeChatMessageRail({
                 : event.deltaMode === WHEEL_DELTA_PAGE
                   ? element.clientHeight
                   : 1
+            if (event.ctrlKey) {
+              return
+            }
+            onReaderScroll?.(event.deltaY * scale)
             element.scrollTop += event.deltaY * scale
-            onReaderScroll?.()
           }}
           className="group/rail absolute inset-y-0 right-[14px] z-10 flex w-4 cursor-default flex-col items-center justify-center gap-2 focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring"
         >
diff --git a/src/renderer/src/components/native-chat/NativeChatQueuedMessageList.test.tsx b/src/renderer/src/components/native-chat/NativeChatQueuedMessageList.test.tsx
index e9b60f0da27a..973fc1c7866c 100644
--- a/src/renderer/src/components/native-chat/NativeChatQueuedMessageList.test.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatQueuedMessageList.test.tsx
@@ -58,7 +58,7 @@ function controller(
     cards,
     queueCapable,
     pause,
-    resume: vi.fn(async () => {}),
+    resume: vi.fn(async () => false),
     resuming: false,
     steer: vi.fn(async () => {}),
     remove: vi.fn(async () => {}),
diff --git a/src/renderer/src/components/native-chat/NativeChatQueuedMessageList.tsx b/src/renderer/src/components/native-chat/NativeChatQueuedMessageList.tsx
index 4c236d87284e..2007bb1900e7 100644
--- a/src/renderer/src/components/native-chat/NativeChatQueuedMessageList.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatQueuedMessageList.tsx
@@ -35,7 +35,7 @@ export function NativeChatQueuedMessageList({
   const pause = cards.some((card) => card.hold === 'queue-paused') ? controller.pause : null
   // Only when focus was on the queue (a card, or Resume) — never pull it from wherever the user
   // moved on to.
-  const refocusAfter = (action: Promise<void>): void => {
+  const refocusAfter = (action: Promise<unknown>): void => {
     void action.then(() => {
       const active = document.activeElement
       if (!active || active === document.body || queueRef.current?.contains(active)) {
diff --git a/src/renderer/src/components/native-chat/NativeChatResolvedView.reveal-latest.test.tsx b/src/renderer/src/components/native-chat/NativeChatResolvedView.reveal-latest.test.tsx
new file mode 100644
index 000000000000..e1e708a6beb2
--- /dev/null
+++ b/src/renderer/src/components/native-chat/NativeChatResolvedView.reveal-latest.test.tsx
@@ -0,0 +1,142 @@
+// @vitest-environment happy-dom
+
+import { afterEach, describe, expect, it, vi } from 'vitest'
+import { cleanup, render } from '@testing-library/react'
+import { useImperativeHandle } from 'react'
+import type { NativeChatLiveSession } from './use-native-chat-live-session'
+import type { AskPrompt } from './native-chat-interactive-prompt'
+import type { NativeChatInteractiveSend } from './use-native-chat-interactive-send'
+import type { NativeChatMessageListHandle } from './use-native-chat-reveal-latest'
+
+// The transcript and composer are stubbed: the wire under test is which of this
+// pane's sends tell the transcript to bring the latest into view.
+type ComposerStubProps = { onSubmitted?: () => void }
+const stubs = vi.hoisted(
+  (): {
+    session: NativeChatLiveSession | null
+    revealLatest: () => void
+    composer: ComposerStubProps | null
+    cardSend: NativeChatInteractiveSend | null
+  } => ({ session: null, revealLatest: vi.fn(), composer: null, cardSend: null })
+)
+vi.mock('./use-native-chat-retained-session', () => ({
+  useNativeChatRetainedSession: () => stubs.session
+}))
+vi.mock('./NativeChatMessageList', () => ({
+  NativeChatMessageList: (props: { ref?: React.Ref<NativeChatMessageListHandle> }) => {
+    useImperativeHandle(props.ref, () => ({ revealLatest: stubs.revealLatest }))
+    return null
+  }
+}))
+vi.mock('./use-native-chat-interactive-send', () => ({
+  useNativeChatInteractiveSend: (): NativeChatInteractiveSend => ({
+    sendAnswer: () => ({ settleAfterMs: 0, waitsForVerifiedDelivery: false }),
+    sendRaw: () => {},
+    sendRawVerified: async () => true,
+    cancelPending: () => {},
+    cancelAsk: async () => true,
+    cancel: () => {}
+  })
+}))
+// A pending question, so the pane mounts its card with the send it hands it.
+vi.mock('./use-native-chat-interactive-prompt-card', () => ({
+  useNativeChatInteractivePromptCard: () => ({ kind: 'question', prompt })
+}))
+vi.mock('./NativeChatInteractiveCard', () => ({
+  NativeChatInteractiveCard: (props: { send: NativeChatInteractiveSend }) => {
+    stubs.cardSend = props.send
+    return null
+  }
+}))
+vi.mock('./NativeChatComposer', () => ({
+  NativeChatComposer: (props: ComposerStubProps) => {
+    stubs.composer = props
+    return null
+  }
+}))
+
+const prompt: AskPrompt = {
+  questions: [{ question: 'Indent with?', multiSelect: false, options: [{ label: 'Tabs' }] }]
+}
+
+const { NativeChatResolvedView } = await import('./NativeChatResolvedView')
+
+afterEach(() => {
+  cleanup()
+  vi.mocked(stubs.revealLatest).mockReset()
+  stubs.composer = null
+  stubs.cardSend = null
+})
+
+describe('NativeChatResolvedView sends', () => {
+  it('brings the latest into view for a composer send and a prompt answer, not a Stop', () => {
+    stubs.session = {
+      messages: [
+        {
+          id: 'user-1',
+          role: 'user',
+          blocks: [{ type: 'text', text: 'Rename the module' }],
+          timestamp: 1,
+          source: 'transcript'
+        }
+      ],
+      status: 'ready',
+      sessionId: 'session-reveal',
+      agent: 'claude',
+      hasMore: false,
+      loadingEarlier: false,
+      olderHistoryGeneration: 0,
+      loadEarlier: vi.fn(),
+      readPhase: 'ready'
+    }
+    render(
+      <NativeChatResolvedView
+        paneKey="tab-reveal:leaf-reveal"
+        agent="claude"
+        sessionId="session-reveal"
+        transcriptPath={null}
+        isVisible
+        isFocusedGroup={false}
+        targetPtyId="pty-reveal"
+        terminalTabId="tab-reveal"
+        ownsTabWideLaunchDraft={false}
+      />
+    )
+    // Anti-vacuous: opening the pane reveals nothing by itself.
+    expect(stubs.revealLatest).not.toHaveBeenCalled()
+
+    stubs.composer?.onSubmitted?.()
+    expect(stubs.revealLatest).toHaveBeenCalledOnce()
+    // A question answer and an approval option, then Stop and a dismissal: only the answers are sends.
+    stubs.cardSend?.sendAnswer(prompt, [{ indices: [0] }])
+    expect(stubs.revealLatest).toHaveBeenCalledTimes(2)
+    // An empty answer writes nothing, so it moves nobody.
+    stubs.cardSend?.sendAnswer(prompt, [{ indices: [] }])
+    expect(stubs.revealLatest).toHaveBeenCalledTimes(2)
+    void stubs.cardSend?.sendRawVerified('1')
+    expect(stubs.revealLatest).toHaveBeenCalledTimes(3)
+    stubs.cardSend?.cancel()
+    void stubs.cardSend?.cancelAsk()
+    expect(stubs.revealLatest).toHaveBeenCalledTimes(3)
+  })
+
+  it('leaves the reader where they are when the terminal is gone and nothing is written', () => {
+    render(
+      <NativeChatResolvedView
+        paneKey="tab-reveal:leaf-reveal"
+        agent="claude"
+        sessionId="session-reveal"
+        transcriptPath={null}
+        isVisible
+        isFocusedGroup={false}
+        targetPtyId={null}
+        terminalTabId="tab-reveal"
+        ownsTabWideLaunchDraft={false}
+      />
+    )
+    stubs.cardSend?.sendAnswer(prompt, [{ indices: [0] }])
+    void stubs.cardSend?.sendRawVerified('1')
+    expect(stubs.cardSend).not.toBeNull()
+    expect(stubs.revealLatest).not.toHaveBeenCalled()
+  })
+})
diff --git a/src/renderer/src/components/native-chat/NativeChatResolvedView.tsx b/src/renderer/src/components/native-chat/NativeChatResolvedView.tsx
index f6eb4a555166..dc98e60d11b2 100644
--- a/src/renderer/src/components/native-chat/NativeChatResolvedView.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatResolvedView.tsx
@@ -9,6 +9,10 @@ import { useNativeChatRetainedSession } from './use-native-chat-retained-session
 import { isNativeChatTranscriptUnsettled } from './native-chat-live-session-contract'
 import { selectNativeChatViewState } from './native-chat-view-state'
 import { NativeChatMessageList } from './NativeChatMessageList'
+import {
+  useNativeChatInteractiveSendReveal,
+  useNativeChatRevealLatest
+} from './use-native-chat-reveal-latest'
 import { useNativeChatLaunchPromptDeliveryNotice } from './use-native-chat-launch-prompt-delivery-notice'
 import { NativeChatComposer, type NativeChatComposerHandle } from './NativeChatComposer'
 import { useNativeChatFontSize } from './use-native-chat-font-size'
@@ -116,7 +120,10 @@ export function NativeChatResolvedView({
   const canSend = useNativeChatCanSend(targetPtyId)
   // Reuse the verified composer send path for interactive cards and composer
   // stop (Stop sends ESC, the agent-TUI interrupt key).
-  const interactiveSend = useNativeChatInteractiveSend(terminalTabId, paneKey, targetPtyId, agent)
+  const send = useNativeChatInteractiveSend(terminalTabId, paneKey, targetPtyId, agent)
+  // Every send this pane makes brings the latest into view, wherever the reader had scrolled.
+  const { messageListRef, revealLatest } = useNativeChatRevealLatest()
+  const interactiveSend = useNativeChatInteractiveSendReveal(send, targetPtyId, revealLatest)
   const [workingInterrupted, setWorkingInterrupted] = useState(false)
   const previousWorkingEpochRef = useRef<number | null>(null)
   const rootRef = useRef<HTMLDivElement>(null)
@@ -379,6 +386,7 @@ export function NativeChatResolvedView({
           <NativeChatEmptyState kind="empty" agent={agent} />
         ) : (
           <NativeChatMessageList
+            ref={messageListRef}
             session={sessionWithPending}
             isVisible={isVisible}
             isWorking={turnActive}
@@ -427,6 +435,7 @@ export function NativeChatResolvedView({
           onOptimisticSendCanceled={delivery.cancel}
           optimisticSendOutcome={delivery}
           onSlashCommand={onSlashCommand}
+          onSubmitted={revealLatest}
           answerCommandLocally={answerLocally}
           onSwitchToTerminal={onSwitchToTerminal}
           readTerminalScreen={readTerminalScreen}
diff --git a/src/renderer/src/components/native-chat/NativeChatStructuredSession.launch-lifecycle.test.tsx b/src/renderer/src/components/native-chat/NativeChatStructuredSession.launch-lifecycle.test.tsx
index c1369c966cd1..554560d81510 100644
--- a/src/renderer/src/components/native-chat/NativeChatStructuredSession.launch-lifecycle.test.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatStructuredSession.launch-lifecycle.test.tsx
@@ -253,6 +253,20 @@ describe('NativeChatStructuredSession launch lifecycle', () => {
     await waitFor(() => expect(mocks.call).toHaveBeenCalledOnce())
   })
 
+  // The parked messages are the transcript here, and the reader may have scrolled up among them.
+  it('brings the latest into view when launch Retry relaunches behind a parked message', async () => {
+    mocks.mode = 'outbox'
+    mocks.launchLifecycle = 'failed'
+    render(sessionView())
+    expect(composerSend()('still there?', [])).toBe(true)
+    await screen.findByRole('button', { name: 'Retry' })
+    mocks.revealLatest.mockClear()
+
+    fireEvent.click(screen.getByRole('button', { name: 'Retry' }))
+
+    expect(mocks.revealLatest).toHaveBeenCalledOnce()
+  })
+
   it('leaves a send into an unconfirmed start parked without relaunching', () => {
     mocks.mode = 'outbox'
     mocks.launchLifecycle = 'visibility-unknown'
diff --git a/src/renderer/src/components/native-chat/NativeChatStructuredSession.stopping.test.tsx b/src/renderer/src/components/native-chat/NativeChatStructuredSession.stopping.test.tsx
index 7d5437b2e672..1299f43f2950 100644
--- a/src/renderer/src/components/native-chat/NativeChatStructuredSession.stopping.test.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatStructuredSession.stopping.test.tsx
@@ -137,7 +137,9 @@ describe("the chat pane while a person's Stop ends the turn", () => {
 
     expect(mocks.composerProps).toMatchObject({ isStopping: false })
     expect(mocks.composerProps?.afterStop).toBeUndefined()
-    expect(mocks.composerProps?.steerQueued).toBe(mocks.queuedSteerNewest)
+    // The pane wraps steering so it also brings the latest into view; it still steers through the queue.
+    mocks.composerProps?.steerQueued?.()
+    expect(mocks.queuedSteerNewest).toHaveBeenCalledOnce()
     mocks.composerProps?.onStop?.()
     expect(mocks.stop).toHaveBeenCalledOnce()
   })
diff --git a/src/renderer/src/components/native-chat/NativeChatStructuredSession.test-harness.tsx b/src/renderer/src/components/native-chat/NativeChatStructuredSession.test-harness.tsx
index 66127bd23478..50fb40590945 100644
--- a/src/renderer/src/components/native-chat/NativeChatStructuredSession.test-harness.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatStructuredSession.test-harness.tsx
@@ -10,6 +10,7 @@ import type { NativeChatApprovalCardProps } from './NativeChatApprovalCard'
 import type { NativeChatDeliveryNotice } from './NativeChatMessageRow'
 import type { NativeChatQuestionCardProps } from './NativeChatQuestionCard'
 import type { NativeChatLaunchSeed } from './native-chat-composer-types'
+import type { NativeChatMessageListHandle } from './use-native-chat-reveal-latest'
 import type { NativeChatFileLinkContext } from './native-chat-file-link'
 import type { NativeChatOlderPageResult } from './native-chat-pagination'
 import type { StructuredAgentSessionThreadGoal } from './use-structured-agent-session-thread-goal'
@@ -94,6 +95,7 @@ export function seedOutbox(sessionId: string, entries: unknown[]): void {
 }
 
 type StructuredSessionMessageListProps = {
+  ref?: React.Ref<NativeChatMessageListHandle>
   allowFileUriLinks?: boolean
   isVisible?: boolean
   onLinkClick?: (...args: unknown[]) => void
@@ -177,7 +179,8 @@ export function createStructuredSessionMocks() {
     queuedSteer: vi.fn<(messageId: string) => Promise<void>>(async () => {}),
     queuedRemove: vi.fn<(messageId: string) => Promise<void>>(async () => {}),
     queuedEdit: vi.fn<(messageId: string) => Promise<void>>(async () => {}),
-    queuedSteerNewest: vi.fn<() => boolean>(() => false)
+    queuedSteerNewest: vi.fn<() => boolean>(() => false),
+    revealLatest: vi.fn<() => void>()
   }
 
   const moduleFactories = {
@@ -326,6 +329,7 @@ export function createStructuredSessionMocks() {
     nativeChatMessageList: () => ({
       NativeChatMessageList: (props: typeof mocks.messageListProps) => {
         mocks.messageListProps = props
+        useImperativeHandle(props?.ref, () => ({ revealLatest: mocks.revealLatest }))
         return <DeliveryNoticesMock notices={props?.deliveryNotices} />
       }
     }),
@@ -405,6 +409,9 @@ export function createStructuredSessionMocks() {
     mocks.loadingOlder = false
     mocks.olderHistoryGeneration = 0
     mocks.loadOlder.mockReset()
+    mocks.revealLatest.mockReset()
+    mocks.queuedSteerNewest.mockReset()
+    mocks.queuedSteerNewest.mockReturnValue(false)
   }
 
   return { mocks, moduleFactories, resetStructuredSessionMocks }
diff --git a/src/renderer/src/components/native-chat/NativeChatStructuredSession.test.tsx b/src/renderer/src/components/native-chat/NativeChatStructuredSession.test.tsx
index a8761e9e9730..564e5555d1ed 100644
--- a/src/renderer/src/components/native-chat/NativeChatStructuredSession.test.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatStructuredSession.test.tsx
@@ -6,6 +6,7 @@ import { act, cleanup, fireEvent, render, screen, waitFor } from '@testing-libra
 import { afterEach, describe, expect, it, vi } from 'vitest'
 import type { AgentJournalRenderItem } from '../../../../shared/agent-session-journal-types'
 import { useAppStore } from '@/store'
+import { TooltipProvider } from '@/components/ui/tooltip'
 import {
   claudeGroupedQuestionPromptItems,
   legacySingleQuestionPromptItems
@@ -31,6 +32,7 @@ vi.mock('./NativeChatQuestionCard', () => moduleFactories.nativeChatQuestionCard
 
 import { NativeChatStructuredSession } from './NativeChatStructuredSession'
 import { structuredAgentSessionPaneKey } from '../../../../shared/structured-agent-session-projection'
+import { seededEntry, seedOutbox } from './NativeChatStructuredSession.test-harness'
 import { structuredAgentSessionDraftScopeKey } from './native-chat-composer-draft-store'
 
 describe('NativeChatStructuredSession', () => {
@@ -370,7 +372,7 @@ describe('NativeChatStructuredSession', () => {
     expect(mocks.composerProps?.isWorking).toBe(true)
   })
 
-  it('suppresses live turn activity for a pending approval but keeps background work visible', () => {
+  it('suppresses live turn activity for a pending approval but keeps background work visible', async () => {
     const approvalItems: AgentJournalRenderItem[] = [
       {
         itemId: 'approval-item',
@@ -423,6 +425,7 @@ describe('NativeChatStructuredSession', () => {
       kind: 'option',
       optionId: 'allow'
     })
+    await waitFor(() => expect(mocks.revealLatest).toHaveBeenCalledOnce())
     expect(mocks.messageListProps?.awaitingInput).toBe('shown')
 
     act(() => mocks.approvalCardProps?.onCancel?.())
@@ -719,4 +722,102 @@ describe('NativeChatStructuredSession', () => {
       answers: [{ questionId: 'q1', optionIds: [], other: 'Svelte' }]
     })
   })
+
+  // The reader may have scrolled far up; what they just did has to come into view.
+  it('brings the latest into view at the press for the submits this pane makes', async () => {
+    mocks.promptItems = legacySingleQuestionPromptItems
+    const { rerender } = render(
+      <NativeChatStructuredSession
+        isVisible
+        isFocusedGroup
+        tabId="structured-tab-reveal"
+        sessionId="session-reveal"
+        target={{ kind: 'local' }}
+        agent="claude"
+      />
+    )
+    // An answer reveals as it is pressed, before the host decides on it.
+    mocks.respond.mockReturnValueOnce(new Promise(() => {}))
+    mocks.questionCardProps?.onAnswer([{ indices: [1], other: '' }])
+    expect(mocks.respond).toHaveBeenCalledOnce()
+    expect(mocks.revealLatest).toHaveBeenCalledOnce()
+
+    mocks.promptItems = []
+    rerender(
+      <NativeChatStructuredSession
+        isVisible
+        isFocusedGroup
+        tabId="structured-tab-reveal"
+        sessionId="session-reveal"
+        target={{ kind: 'local' }}
+        agent="claude"
+      />
+    )
+    const steerQueued = mocks.composerProps?.steerQueued
+    const onSubmitted = mocks.composerProps?.structuredTransport?.onSubmitted
+    if (!steerQueued || typeof onSubmitted !== 'function') {
+      throw new Error('Structured composer was not wired')
+    }
+    mocks.revealLatest.mockClear()
+
+    // Refused: nothing was steered, so nothing moves.
+    expect(steerQueued()).toBe(false)
+    expect(mocks.revealLatest).not.toHaveBeenCalled()
+
+    // The composer's sends reveal through its transport.
+    onSubmitted()
+    expect(mocks.revealLatest).toHaveBeenCalledOnce()
+    mocks.queuedSteerNewest.mockReturnValue(true)
+    expect(steerQueued()).toBe(true)
+    expect(mocks.revealLatest).toHaveBeenCalledTimes(2)
+  })
+
+  it('reveals the latest when a delivery notice retries its message', async () => {
+    mocks.mode = 'outbox'
+    mocks.call.mockResolvedValue({
+      ok: true,
+      value: { submission: { clientMessageId: 'op-head', dispatchState: 'accepted' } }
+    })
+    seedOutbox('session-retry-reveal', [
+      seededEntry('session-retry-reveal', 'op-head', 'first', 'unconfirmed')
+    ])
+    render(
+      <NativeChatStructuredSession
+        isVisible
+        isFocusedGroup
+        tabId="structured-tab-retry-reveal"
+        sessionId="session-retry-reveal"
+        target={{ kind: 'local' }}
+        agent="codex"
+      />
+    )
+
+    fireEvent.click(await screen.findByRole('button', { name: /Retry/ }))
+
+    expect(mocks.revealLatest).toHaveBeenCalledOnce()
+    await waitFor(() => expect(mocks.call).toHaveBeenCalledOnce())
+  })
+
+  it("brings the latest into view when a queued card's Steer sends it now", () => {
+    mocks.queuedCards = [
+      { messageId: 'draft-1', position: 1, text: 'Also check SSH', state: 'waiting', hold: 'turn' }
+    ]
+    render(
+      <TooltipProvider>
+        <NativeChatStructuredSession
+          isVisible
+          isFocusedGroup
+          tabId="structured-tab-queue"
+          sessionId="session-queue"
+          target={{ kind: 'local' }}
+          agent="claude"
+        />
+      </TooltipProvider>
+    )
+
+    fireEvent.click(screen.getByRole('button', { name: /Steer/ }))
+
+    expect(mocks.queuedSteer).toHaveBeenCalledWith('draft-1')
+    expect(mocks.revealLatest).toHaveBeenCalledOnce()
+  })
 })
diff --git a/src/renderer/src/components/native-chat/NativeChatStructuredSession.tsx b/src/renderer/src/components/native-chat/NativeChatStructuredSession.tsx
index dae1e61a27fb..2b8c7bce72b9 100644
--- a/src/renderer/src/components/native-chat/NativeChatStructuredSession.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatStructuredSession.tsx
@@ -12,6 +12,7 @@ import { structuredAgentSessionDraftScopeKey } from './native-chat-composer-draf
 import { NativeChatEmptyState } from './NativeChatEmptyState'
 import { NativeChatLoadingCue } from './NativeChatLoadingCue'
 import { NativeChatMessageList } from './NativeChatMessageList'
+import { useStructuredNativeChatSubmitReveal } from './use-structured-native-chat-submit-reveal'
 import { NativeChatQuestionCard } from './NativeChatQuestionCard'
 import { selectNativeChatViewState, structuredChatHistoryPhase } from './native-chat-view-state'
 import { useNativeChatComposerRevealFocus } from './use-native-chat-composer-reveal-focus'
@@ -124,13 +125,15 @@ export function NativeChatStructuredSession(
     }),
     [controller, historyPhase, props.agent, props.sessionId]
   )
+  const submits = useStructuredNativeChatSubmitReveal(controller, provisionalLaunch.retry)
+  const { retryDelivery, revealLatest } = submits
   const agentLabel = structuredAgentLabel(props.agent)
   const deliveryNotices = useStructuredAgentSessionDeliveryNotices({
     outbox: controller.outbox,
     submissions: controller.submissions,
     journalItems: controller.journalItems,
     failedHere: controller.failedHere,
-    retry: controller.retry,
+    retry: retryDelivery,
     agentName: agentLabel
   })
   // Nothing reads an unread history, so its pane stays blank beside the Retry line.
@@ -183,16 +186,23 @@ export function NativeChatStructuredSession(
       ? (objective: string) => threadGoal.change({ kind: 'set', objective })
       : null
     return {
-      send: (text: string, attachments: readonly { id: string; path: string }[]): boolean =>
-        sendThroughRelaunch(() =>
-          controller.send(
+      send: (
+        text: string,
+        attachments: readonly { id: string; path: string }[]
+      ): boolean | 'queued' => {
+        let admission: boolean | 'queued' = false
+        const accepted = sendThroughRelaunch(() => {
+          admission = controller.send(
             text,
             attachments.map((attachment) => ({
               path: attachment.path,
               previewUri: attachment.path
             }))
           )
-        ),
+          return admission !== false
+        })
+        return accepted ? admission : false
+      },
       dispatchCommand: (text: string) =>
         dispatchStructuredAgentSessionComposerCommand(text, {
           agent: props.agent,
@@ -215,6 +225,7 @@ export function NativeChatStructuredSession(
       contextUsage: controller.contextUsage,
       worktreeId: ownerWorktreeId ?? undefined,
       onError: setComposerError,
+      onSubmitted: revealLatest,
       runtime: (props.target.kind === 'local' ? 'local' : 'remote') as 'local' | 'remote',
       sessionId: props.sessionId,
       runtimeEnvironmentId:
@@ -227,6 +238,7 @@ export function NativeChatStructuredSession(
     props.agent,
     props.sessionId,
     props.target,
+    revealLatest,
     sendThroughRelaunch
   ])
 
@@ -268,6 +280,7 @@ export function NativeChatStructuredSession(
             <NativeChatMessageList
               // A rewind replaces the conversation; nothing the old transcript held carries over.
               key={controller.epoch ?? undefined}
+              ref={submits.messageListRef}
               session={session}
               journalItems={controller.journalItems}
               journalSubmissions={controller.submissions}
@@ -296,11 +309,11 @@ export function NativeChatStructuredSession(
             lifecycle={provisionalLaunch.lifecycle}
             failure={provisionalLaunch.failure}
             agentLabel={agentLabel}
-            onRetry={provisionalLaunch.retry}
+            onRetry={submits.retryLaunch}
           />
           {/* Host-held drafts, never transcript rows. Above the status area, so running shells and agents sit next to the composer. */}
           <NativeChatQueuedMessageList
-            controller={controller.queuedMessages}
+            controller={submits.queuedMessages}
             steerHeld={stopControls.stopping}
             focusComposer={focusComposer}
           />
@@ -339,7 +352,7 @@ export function NativeChatStructuredSession(
             <NativeChatApprovalCard
               key={`${prompt.itemId}:${prompt.revision}`}
               approval={approval}
-              onChoose={(optionId) => void controller.respond(prompt, { kind: 'option', optionId })}
+              onChoose={(optionId) => void submits.respond(prompt, { kind: 'option', optionId })}
               onCancel={cancelPrompt}
               shouldFocus={!promptsUnanswerable && props.isVisible && props.isFocusedGroup}
               onLinkClick={onLinkClick}
@@ -372,7 +385,7 @@ export function NativeChatStructuredSession(
                   return { questionId: question.id, optionIds, ...(other ? { other } : {}) }
                 })
                 if (chosen.every((answer) => answer.optionIds.length > 0 || answer.other)) {
-                  void controller.respond(prompt, { kind: 'answers', answers: chosen })
+                  void submits.respond(prompt, { kind: 'answers', answers: chosen })
                 }
               }}
               onCancel={cancelPrompt}
@@ -388,6 +401,7 @@ export function NativeChatStructuredSession(
               agent={props.agent}
               isWorking={controller.canStop}
               {...stopControls.composer}
+              steerQueued={stopControls.stopping ? undefined : submits.queuedMessages.steerNewest}
               structuredTransport={structuredTransport}
               launchSeed={{ ...launchDraftSignal, ownsTabWideLaunchDraft: true }}
             />
diff --git a/src/renderer/src/components/native-chat/native-chat-app-root-test-render.tsx b/src/renderer/src/components/native-chat/native-chat-app-root-test-render.tsx
new file mode 100644
index 000000000000..e7cab5387f92
--- /dev/null
+++ b/src/renderer/src/components/native-chat/native-chat-app-root-test-render.tsx
@@ -0,0 +1,12 @@
+// Renders a chat surface the way the app root does: under the one TooltipProvider
+// its tooltips rely on, which a bare test render does not supply.
+
+import { render as renderBare, type RenderOptions, type RenderResult } from '@testing-library/react'
+import { TooltipProvider } from '@/components/ui/tooltip'
+
+export function render(
+  ui: React.ReactNode,
+  options?: Omit<RenderOptions, 'wrapper' | 'queries'>
+): RenderResult {
+  return renderBare(ui, { ...options, wrapper: TooltipProvider })
+}
diff --git a/src/renderer/src/components/native-chat/native-chat-autoscroll.test.ts b/src/renderer/src/components/native-chat/native-chat-autoscroll.test.ts
index e782812e7dd3..6741369acfde 100644
--- a/src/renderer/src/components/native-chat/native-chat-autoscroll.test.ts
+++ b/src/renderer/src/components/native-chat/native-chat-autoscroll.test.ts
@@ -5,7 +5,8 @@ import {
   nextFollowingEnd,
   shouldShowJumpToLatest,
   NATIVE_CHAT_BOTTOM_THRESHOLD_PX,
-  NATIVE_CHAT_FOLLOW_REARM_PX
+  NATIVE_CHAT_FOLLOW_REARM_PX,
+  readerGestureLeavesEnd
 } from './native-chat-autoscroll'
 
 const atBottom = { scrollTop: 952, scrollHeight: 1000, clientHeight: 48 }
@@ -76,8 +77,8 @@ describe('nextFollowingEnd', () => {
     expect(nextFollowingEnd({ ...following, programmatic: true, geometry: wellAway })).toBe(true)
   })
 
-  it('treats an unmarked offset away from the end as the reader leaving', () => {
-    expect(nextFollowingEnd({ ...following, geometry: wellAway })).toBe(false)
+  it('keeps following through unmarked passive layout offsets', () => {
+    expect(nextFollowingEnd({ ...following, geometry: wellAway })).toBe(true)
   })
 
   it.each([0, NATIVE_CHAT_FOLLOW_REARM_PX, 400])(
@@ -98,7 +99,7 @@ describe('nextFollowingEnd', () => {
   it('lets the reader park just inside the near-bottom band', () => {
     expect(NATIVE_CHAT_FOLLOW_REARM_PX).toBeLessThan(NATIVE_CHAT_BOTTOM_THRESHOLD_PX)
     const parked = parkedAbove(NATIVE_CHAT_BOTTOM_THRESHOLD_PX - 1)
-    expect(nextFollowingEnd({ ...following, geometry: parked })).toBe(false)
+    expect(nextFollowingEnd({ ...following, following: false, geometry: parked })).toBe(false)
     expect(isNearBottom(parked)).toBe(true)
     expect(shouldShowJumpToLatest(false, parked)).toBe(false)
   })
@@ -142,3 +143,17 @@ describe('nextFollowingEnd', () => {
     expect(nextFollowingEnd({ ...following, geometry: parkedAbove(1.5) })).toBe(true)
   })
 })
+
+it('only detaches for gestures that can move away from the tail', () => {
+  expect(readerGestureLeavesEnd({ kind: 'wheel', deltaY: -10, zoom: false }, atBottom)).toBe(true)
+  expect(readerGestureLeavesEnd({ kind: 'wheel', deltaY: 10, zoom: false }, atBottom)).toBe(false)
+  expect(readerGestureLeavesEnd({ kind: 'wheel', deltaY: -10, zoom: true }, atBottom)).toBe(false)
+  expect(readerGestureLeavesEnd({ kind: 'key', key: 'Home' }, atBottom)).toBe(true)
+  expect(readerGestureLeavesEnd({ kind: 'key', key: 'End' }, atBottom)).toBe(false)
+  expect(readerGestureLeavesEnd({ kind: 'scrollbar-press' }, atBottom)).toBe(true)
+  expect(readerGestureLeavesEnd({ kind: 'touch-drag' }, parkedAbove(60))).toBe(true)
+  expect(readerGestureLeavesEnd({ kind: 'touch-drag' }, atBottom)).toBe(false)
+  expect(readerGestureLeavesEnd({ kind: 'wheel', deltaY: -10, zoom: false }, noOverflow)).toBe(
+    false
+  )
+})
diff --git a/src/renderer/src/components/native-chat/native-chat-autoscroll.ts b/src/renderer/src/components/native-chat/native-chat-autoscroll.ts
index 137d0ead61c7..ab07cc590a7f 100644
--- a/src/renderer/src/components/native-chat/native-chat-autoscroll.ts
+++ b/src/renderer/src/components/native-chat/native-chat-autoscroll.ts
@@ -52,21 +52,58 @@ export type FollowIntent = {
   previousDistanceFromEnd: number
 }
 
-/** Whether the transcript should still follow the end after this offset.
- *
- *  Application writes preserve intent even when their delayed events arrive
- *  after the end moved. Reader events detach away from the end and reattach on
- *  arriving at it — against the re-arm band, never the wider near-bottom one.
- *  Arriving takes closing on the end: a smooth scroll leaving the end marks only
- *  its landing, and its first unmarked frames still sit inside the band. Measured
- *  against the end, not the offset, so content shrinking under a detached reader
- *  and clamping them onto the end still reattaches. */
+/** Passive offsets preserve following; detached views rearm only while closing on the actual tail. */
 export function nextFollowingEnd(intent: FollowIntent): boolean {
-  if (intent.programmatic) {
+  if (intent.following || intent.programmatic) {
     return intent.following
   }
-  if (!intent.following && distanceFromBottom(intent.geometry) > intent.previousDistanceFromEnd) {
+  if (distanceFromBottom(intent.geometry) > intent.previousDistanceFromEnd) {
     return false
   }
   return isNearBottom(intent.geometry, NATIVE_CHAT_FOLLOW_REARM_PX)
 }
+
+/** A reader input that can move the transcript, reduced to what decides following. */
+export type ReaderGesture =
+  | { kind: 'wheel'; deltaY: number; zoom: boolean }
+  | { kind: 'touch-drag' }
+  | { kind: 'scrollbar-press' }
+  | { kind: 'content-press' }
+  | { kind: 'key'; key: string; shift?: boolean }
+
+const KEYS_AWAY_FROM_END = new Set(['PageUp', 'Home', 'ArrowUp'])
+const KEYS_TOWARD_END = new Set(['PageDown', 'End', 'ArrowDown'])
+
+/** The direction a gesture scrolls: -1 up, 1 down, 0 when it does not scroll. */
+export function readerGestureDirection(gesture: ReaderGesture): -1 | 0 | 1 {
+  if (gesture.kind === 'wheel') {
+    return gesture.zoom || gesture.deltaY === 0 ? 0 : gesture.deltaY < 0 ? -1 : 1
+  }
+  if (gesture.kind === 'key') {
+    if (gesture.key === ' ') {
+      return gesture.shift ? -1 : 1
+    }
+    return KEYS_AWAY_FROM_END.has(gesture.key) ? -1 : KEYS_TOWARD_END.has(gesture.key) ? 1 : 0
+  }
+  return 0
+}
+
+/** Gestures that cannot leave the tail must not strand a following view without a scroll event. */
+export function readerGestureLeavesEnd(gesture: ReaderGesture, geometry: ScrollGeometry): boolean {
+  const contentAbove = geometry.scrollTop > 0
+  const awayFromEnd = !isNearBottom(geometry, NATIVE_CHAT_FOLLOW_REARM_PX)
+  switch (gesture.kind) {
+    case 'wheel':
+      return readerGestureDirection(gesture) < 0 && contentAbove
+    case 'scrollbar-press':
+      return contentAbove
+    // A touch's direction is not observable; it leaves once its drag has carried the view away.
+    case 'touch-drag':
+    case 'content-press':
+      return awayFromEnd
+    case 'key': {
+      const direction = readerGestureDirection(gesture)
+      return direction < 0 ? contentAbove : direction > 0 && awayFromEnd
+    }
+  }
+}
diff --git a/src/renderer/src/components/native-chat/native-chat-composer-types.ts b/src/renderer/src/components/native-chat/native-chat-composer-types.ts
index caaed6916370..b06dd3a98428 100644
--- a/src/renderer/src/components/native-chat/native-chat-composer-types.ts
+++ b/src/renderer/src/components/native-chat/native-chat-composer-types.ts
@@ -19,7 +19,10 @@ export type NativeChatOptionPickerRequest = {
 
 export type NativeChatStructuredComposerTransport = {
   conversationCommands?: readonly AgentSessionConversationCommand[]
-  send: (text: string, attachments: readonly NativeChatComposerImageAttachment[]) => boolean
+  send: (
+    text: string,
+    attachments: readonly NativeChatComposerImageAttachment[]
+  ) => boolean | 'queued'
   dispatchCommand: (text: string) => Promise<StructuredAgentSessionCommandOutcome>
   optionsSurface: SessionOptionsSurface
   optionSnapshot: SessionOptionDescriptor[]
@@ -33,6 +36,8 @@ export type NativeChatStructuredComposerTransport = {
   /** Present only where the host can set this session's goal. */
   threadGoal?: { setObjective: (objective: string) => Promise<boolean> }
   onError: (message: string | null) => void
+  /** A local send: brings the latest into view at the press, not when the host answers. */
+  onSubmitted?: () => void
   runtime: 'local' | 'remote'
   /** The session behind this composer; a real user send relinquishes orchestration ownership. */
   sessionId: string
@@ -82,6 +87,8 @@ export type NativeChatComposerProps = {
   onSlashCommand?: (command: string, output?: string) => void
   /** The host's own answer to a command the agent must not see, or null to send it. */
   answerCommandLocally?: NativeChatLocalCommandAnswer
+  /** Anything sent to the terminal: a message, a command or a session option. */
+  onSubmitted?: () => void
   /** Picker-only agent commands continue in the hosted TUI after dispatch. */
   onSwitchToTerminal?: () => void
   /** Reads the hosted TUI's current rendered screen when chat is entered. */
diff --git a/src/renderer/src/components/native-chat/native-chat-reader-scroll-input.test.tsx b/src/renderer/src/components/native-chat/native-chat-reader-scroll-input.test.tsx
new file mode 100644
index 000000000000..66ec19bad30d
--- /dev/null
+++ b/src/renderer/src/components/native-chat/native-chat-reader-scroll-input.test.tsx
@@ -0,0 +1,87 @@
+// @vitest-environment happy-dom
+import { fireEvent, render, cleanup } from '@testing-library/react'
+import { afterEach, expect, it, vi } from 'vitest'
+import { useRef } from 'react'
+import { useNativeChatReaderScrollInput } from './native-chat-reader-scroll-input'
+
+afterEach(cleanup)
+function harness() {
+  const onReaderScroll = vi.fn()
+  const onLeaveEnd = vi.fn()
+  let railWheel: (deltaY: number) => void = () => {}
+  const view = render(<Harness />)
+  function Harness() {
+    const ref = useRef<HTMLDivElement>(null)
+    const input = useNativeChatReaderScrollInput(ref, { onReaderScroll, onLeaveEnd })
+    railWheel = input.railWheel
+    return (
+      <div ref={ref} data-testid="root" {...input.scrollerProps}>
+        <div data-testid="nested" style={{ overflowY: 'auto' }}>
+          <span data-testid="text">output</span>
+        </div>
+        <textarea data-testid="input" />
+      </div>
+    )
+  }
+  const root = view.getByTestId('root')
+  const nested = view.getByTestId('nested')
+  Object.defineProperties(root, { scrollHeight: { value: 2000 }, clientHeight: { value: 500 } })
+  root.scrollTop = 1500
+  Object.defineProperties(nested, { scrollHeight: { value: 1000 }, clientHeight: { value: 100 } })
+  return { ...view, root, nested, onReaderScroll, onLeaveEnd, railWheel }
+}
+it('leaves transcript following with the nested scroller until it chains upward', () => {
+  const h = harness()
+  h.nested.scrollTop = 50
+  fireEvent.wheel(h.getByTestId('text'), { deltaY: -10 })
+  expect(h.onLeaveEnd).not.toHaveBeenCalled()
+  h.nested.scrollTop = 0
+  fireEvent.wheel(h.getByTestId('text'), { deltaY: -10 })
+  expect(h.onLeaveEnd).toHaveBeenCalledOnce()
+  h.onLeaveEnd.mockClear()
+  h.nested.style.overscrollBehaviorY = 'contain'
+  fireEvent.wheel(h.getByTestId('text'), { deltaY: -10 })
+  expect(h.onLeaveEnd).not.toHaveBeenCalled()
+})
+it('hands the transcript to upward keyboard, scrollbar and rail gestures', () => {
+  const h = harness()
+  fireEvent.keyDown(h.root, { key: 'PageUp' })
+  fireEvent.keyDown(h.root, { key: ' ', shiftKey: true })
+  fireEvent.pointerDown(h.root)
+  h.railWheel(-20)
+  expect(h.onLeaveEnd).toHaveBeenCalledTimes(4)
+})
+it('hands the transcript to a touch drag only once it has carried the view off the end', () => {
+  const h = harness()
+  fireEvent.touchMove(h.root)
+  expect(h.onLeaveEnd, 'still at the end').not.toHaveBeenCalled()
+  h.root.scrollTop = 1400
+  fireEvent.touchMove(h.root)
+  expect(h.onLeaveEnd).toHaveBeenCalledOnce()
+})
+it('lets a nested scrollbar cancel a pending reveal while retaining transcript following', () => {
+  const h = harness()
+  h.nested.scrollTop = 50
+  fireEvent.pointerDown(h.nested)
+  expect(h.onReaderScroll).toHaveBeenCalledOnce()
+  expect(h.onLeaveEnd).not.toHaveBeenCalled()
+})
+it('keeps following on downward gestures at the tail, zoom and editing keys', () => {
+  const h = harness()
+  fireEvent.wheel(h.root, { deltaY: 10 })
+  expect(h.onLeaveEnd, 'down wheel').not.toHaveBeenCalled()
+  fireEvent.keyDown(h.root, { key: 'End' })
+  expect(h.onLeaveEnd, 'end key').not.toHaveBeenCalled()
+  h.railWheel(20)
+  expect(h.onLeaveEnd, 'down rail').not.toHaveBeenCalled()
+  const zoom = new WheelEvent('wheel', { bubbles: true, deltaY: -10 })
+  Object.defineProperty(zoom, 'ctrlKey', { value: true })
+  fireEvent(h.root, zoom)
+  expect(h.onLeaveEnd, 'zoom').not.toHaveBeenCalled()
+  expect(h.getByTestId('input') instanceof HTMLElement).toBe(true)
+  expect(h.getByTestId('input').closest('input, textarea, select')).not.toBeNull()
+  fireEvent.keyDown(h.getByTestId('input'), { key: 'ArrowUp' })
+  expect(h.onLeaveEnd, 'editable key').not.toHaveBeenCalled()
+  expect(h.onLeaveEnd).not.toHaveBeenCalled()
+  expect(h.onReaderScroll).toHaveBeenCalledTimes(3)
+})
diff --git a/src/renderer/src/components/native-chat/native-chat-reader-scroll-input.ts b/src/renderer/src/components/native-chat/native-chat-reader-scroll-input.ts
index fcee784849ef..a1f5fe3ee65b 100644
--- a/src/renderer/src/components/native-chat/native-chat-reader-scroll-input.ts
+++ b/src/renderer/src/components/native-chat/native-chat-reader-scroll-input.ts
@@ -1,7 +1,11 @@
-// Reader-initiated scrolling, told apart by its input rather than by scroll events:
-// a smooth programmatic scroll's own frames arrive as unmarked scroll events too.
+// Input owns departure from following; layout and application writes also produce scroll events.
 
-import type React from 'react'
+import { useCallback, useMemo } from 'react'
+import {
+  readerGestureDirection,
+  readerGestureLeavesEnd,
+  type ReaderGesture
+} from './native-chat-autoscroll'
 
 const READER_SCROLL_KEYS = new Set([
   'ArrowUp',
@@ -20,29 +24,136 @@ function isEditableTarget(target: EventTarget): boolean {
   )
 }
 
+/** Nested scroll areas own gestures until they can chain into the transcript. */
+function gestureReachesTranscript(
+  target: EventTarget,
+  transcript: HTMLElement,
+  direction: -1 | 0 | 1
+): boolean {
+  if (!(target instanceof Element) || !transcript.contains(target)) {
+    return false
+  }
+  for (
+    let element: Element | null = target;
+    element && element !== transcript;
+    element = element.parentElement
+  ) {
+    const style = getComputedStyle(element)
+    if (style.overflowY !== 'auto' && style.overflowY !== 'scroll') {
+      continue
+    }
+    const canMove =
+      direction < 0
+        ? element.scrollTop > 0
+        : element.scrollTop < element.scrollHeight - element.clientHeight
+    if (
+      canMove ||
+      style.overscrollBehaviorY === 'contain' ||
+      style.overscrollBehaviorY === 'none'
+    ) {
+      return false
+    }
+  }
+  return true
+}
+
+function gestureLeavesEnd(gesture: ReaderGesture, transcript: HTMLElement): boolean {
+  return readerGestureLeavesEnd(gesture, {
+    scrollTop: transcript.scrollTop,
+    scrollHeight: transcript.scrollHeight,
+    clientHeight: transcript.clientHeight
+  })
+}
+
+type ReaderScrollCallbacks = {
+  onReaderScroll: () => void
+  onLeaveEnd: () => void
+}
+
 export type NativeChatReaderScrollInputHandlers = Pick<
   React.HTMLAttributes<HTMLDivElement>,
-  'onWheel' | 'onTouchMove' | 'onKeyDown' | 'onPointerDown'
+  'onWheel' | 'onTouchMove' | 'onKeyDown' | 'onPointerDown' | 'tabIndex' | 'role'
 >
 
-/** Scroller props that call `onReaderScroll` on a wheel, touch drag, scroll key or
- *  scrollbar grab. */
-export function nativeChatReaderScrollInputHandlers(
-  onReaderScroll: () => void
-): NativeChatReaderScrollInputHandlers {
+/** Invalidate pending navigation on input, and detach only when the transcript can move away. */
+export function nativeChatReaderScrollInputHandlers({
+  onReaderScroll,
+  onLeaveEnd
+}: ReaderScrollCallbacks): NativeChatReaderScrollInputHandlers {
+  const report = (gesture: ReaderGesture, event: React.SyntheticEvent<HTMLDivElement>): void => {
+    const transcript = event.currentTarget
+    if (
+      gestureLeavesEnd(gesture, transcript) &&
+      gestureReachesTranscript(event.target, transcript, readerGestureDirection(gesture))
+    ) {
+      onLeaveEnd()
+    }
+  }
   return {
-    onWheel: onReaderScroll,
-    onTouchMove: onReaderScroll,
+    tabIndex: 0,
+    role: 'region',
+    onWheel: (event) => {
+      if (event.ctrlKey || event.deltaY === 0) {
+        return
+      }
+      onReaderScroll()
+      report({ kind: 'wheel', deltaY: event.deltaY, zoom: event.ctrlKey }, event)
+    },
+    onTouchMove: (event) => {
+      onReaderScroll()
+      report({ kind: 'touch-drag' }, event)
+    },
     onKeyDown: (event) => {
-      if (READER_SCROLL_KEYS.has(event.key) && !isEditableTarget(event.target)) {
+      if (!READER_SCROLL_KEYS.has(event.key) || isEditableTarget(event.target)) {
+        return
+      }
+      const modified =
+        event.altKey || event.ctrlKey || event.metaKey || (event.shiftKey && event.key !== ' ')
+      if (!modified && !event.defaultPrevented && !event.nativeEvent.isComposing) {
         onReaderScroll()
+        report({ kind: 'key', key: event.key, shift: event.shiftKey }, event)
       }
     },
     // The scrollbar belongs to the scroller itself; a press on its content does not scroll.
     onPointerDown: (event) => {
       if (event.target === event.currentTarget) {
         onReaderScroll()
+        report({ kind: 'scrollbar-press' }, event)
+        return
+      }
+      if (event.target instanceof HTMLElement) {
+        const { overflowY } = getComputedStyle(event.target)
+        if (overflowY === 'auto' || overflowY === 'scroll') {
+          onReaderScroll()
+        }
       }
+      report({ kind: 'content-press' }, event)
     }
   }
 }
+
+/** The transcript scroller's input props, and the wheel the rail overlaying it forwards. */
+export function useNativeChatReaderScrollInput(
+  scrollRef: React.RefObject<HTMLElement | null>,
+  { onReaderScroll, onLeaveEnd }: ReaderScrollCallbacks
+): { scrollerProps: NativeChatReaderScrollInputHandlers; railWheel: (deltaY: number) => void } {
+  const scrollerProps = useMemo(
+    () => nativeChatReaderScrollInputHandlers({ onReaderScroll, onLeaveEnd }),
+    [onLeaveEnd, onReaderScroll]
+  )
+  // Reported before the rail moves the transcript, so the gesture reads where it started.
+  const railWheel = useCallback(
+    (deltaY: number) => {
+      if (deltaY === 0) {
+        return
+      }
+      onReaderScroll()
+      const transcript = scrollRef.current
+      if (transcript && gestureLeavesEnd({ kind: 'wheel', deltaY, zoom: false }, transcript)) {
+        onLeaveEnd()
+      }
+    },
+    [onLeaveEnd, onReaderScroll, scrollRef]
+  )
+  return { scrollerProps, railWheel }
+}
diff --git a/src/renderer/src/components/native-chat/native-chat-root-key-routing.ts b/src/renderer/src/components/native-chat/native-chat-root-key-routing.ts
index 8b4ba6e99254..532d08ab5767 100644
--- a/src/renderer/src/components/native-chat/native-chat-root-key-routing.ts
+++ b/src/renderer/src/components/native-chat/native-chat-root-key-routing.ts
@@ -18,6 +18,15 @@ export function routeNativeChatRootKeyToInput(
   composer: NativeChatComposerHandle | null,
   questionAnswerInput: HTMLInputElement | null
 ): void {
+  // The focused transcript owns Space paging; typing elsewhere still reaches the composer.
+  if (
+    event.key === ' ' &&
+    event.target instanceof HTMLElement &&
+    event.target.matches('[data-native-chat-scroll]') &&
+    event.target.ownerDocument.activeElement === event.target
+  ) {
+    return
+  }
   // Backspace/Delete outside an input focuses the composer (like typing)
   // but inserts nothing — let the now-focused field handle the keystroke.
   if (shouldFocusNativeChatComposerFromEditingKey(event)) {
diff --git a/src/renderer/src/components/native-chat/native-chat-structured-composer-dispatch.ts b/src/renderer/src/components/native-chat/native-chat-structured-composer-dispatch.ts
index a620bf710380..7a201ec4e10d 100644
--- a/src/renderer/src/components/native-chat/native-chat-structured-composer-dispatch.ts
+++ b/src/renderer/src/components/native-chat/native-chat-structured-composer-dispatch.ts
@@ -5,10 +5,12 @@ export async function dispatchNativeChatStructuredComposerText(
   transport: NativeChatStructuredComposerTransport,
   text: string,
   attachments: readonly NativeChatComposerImageAttachment[] = []
-): Promise<{ accepted: boolean; error: string | null }> {
+): Promise<{ accepted: boolean; error: string | null; revealsTranscript: boolean }> {
   const command = await transport.dispatchCommand(text)
+  // A command's reveal, if any, came at the press; a message reveals unless it waits as a queued card.
   if (command.handled) {
-    return { accepted: command.accepted, error: command.error }
+    return { accepted: command.accepted, error: command.error, revealsTranscript: false }
   }
-  return { accepted: transport.send(text, attachments), error: null }
+  const admission = transport.send(text, attachments)
+  return { accepted: admission !== false, error: null, revealsTranscript: admission === true }
 }
diff --git a/src/renderer/src/components/native-chat/native-chat-submission-navigation.test.tsx b/src/renderer/src/components/native-chat/native-chat-submission-navigation.test.tsx
new file mode 100644
index 000000000000..1596863f2a39
--- /dev/null
+++ b/src/renderer/src/components/native-chat/native-chat-submission-navigation.test.tsx
@@ -0,0 +1,458 @@
+// @vitest-environment happy-dom
+import { act, cleanup, fireEvent, render, renderHook } from '@testing-library/react'
+import { afterEach, expect, it, vi } from 'vitest'
+import { useRef } from 'react'
+import type { NativeChatStructuredComposerTransport } from './native-chat-composer-types'
+import type { SessionOptionDescriptor } from '../../../../shared/native-chat-session-options'
+import { dispatchStructuredAgentSessionComposerCommand } from '../../../../shared/structured-agent-session-composer'
+import { useNativeChatStructuredComposerSend } from './use-native-chat-structured-composer-send'
+import { useNativeChatComposerSubmit } from './use-native-chat-composer-submit'
+import { useNativeChatPtyComposerSend } from './use-native-chat-pty-composer-send'
+import { useNativeChatPickerCommandDispatch } from './use-native-chat-picker-command-dispatch'
+import { useNativeChatSessionOptionCommand } from './use-native-chat-session-option-command'
+import {
+  useNativeChatRevealLatest,
+  useNativeChatMessageListHandle
+} from './use-native-chat-reveal-latest'
+import { useNativeChatTranscriptScroll } from './use-native-chat-transcript-scroll'
+import { useStructuredNativeChatSubmitReveal } from './use-structured-native-chat-submit-reveal'
+import type { StructuredPromptItem } from './use-structured-agent-session'
+import {
+  clearNativeChatDraftCacheForTests,
+  writeNativeChatDraftCache
+} from './native-chat-draft-cache'
+
+const runtime = vi.hoisted(() => ({
+  verified: vi.fn<() => Promise<boolean>>(async () => true),
+  message: vi.fn(() => ({ cancel: () => {}, settleAfterMs: 0 }))
+}))
+vi.mock('./native-chat-runtime-send', () => ({
+  sendNativeChatMessageVerified: runtime.verified,
+  typeNativeChatCommand: runtime.verified,
+  sendNativeChatMessage: runtime.message,
+  sendNativeChatTypedCommand: runtime.message,
+  submitNativeChatPrompt: vi.fn()
+}))
+vi.mock('./native-chat-runtime-image-send', () => ({
+  sendNativeChatMessageWithImageAttachments: runtime.message
+}))
+vi.mock('./native-chat-pty-send-queue', () => ({
+  cancelNativeChatPtySends: vi.fn(),
+  waitForNativeChatPtyIdle: vi.fn(async () => {})
+}))
+vi.mock('../../store', () => ({
+  useAppStore: { getState: () => ({ clearNativeChatLaunchDraft: vi.fn() }) }
+}))
+vi.mock('@/lib/native-chat-telemetry', () => ({
+  emitNativeChatMessageSent: vi.fn(),
+  emitNativeChatPickerItemAccepted: vi.fn(),
+  emitNativeChatSendClassified: vi.fn()
+}))
+vi.mock('@/lib/worker-terminal-takeover-report', () => ({
+  reportStructuredSessionUserInput: vi.fn()
+}))
+
+afterEach(() => {
+  cleanup()
+  clearNativeChatDraftCacheForTests()
+  vi.clearAllMocks()
+})
+
+function deferred<T>() {
+  let settle: (value: T) => void = () => {
+    throw new Error('Promise not initialized')
+  }
+  const promise = new Promise<T>((resolve) => {
+    settle = resolve
+  })
+  return { promise, settle: (value: T) => settle(value) }
+}
+
+const options: SessionOptionDescriptor[] = ['model', 'effort'].map((id) => ({
+  id,
+  label: id,
+  kind: { type: 'select', currentValue: 'old', choices: [{ value: 'next', label: 'Next' }] },
+  valueSource: 'reported',
+  transport: 'agent-session',
+  settable: true
+}))
+
+function transport(
+  onSubmitted: () => void,
+  setOption: () => Promise<boolean>
+): NativeChatStructuredComposerTransport {
+  return {
+    send: vi.fn(() => true),
+    dispatchCommand: (text) =>
+      dispatchStructuredAgentSessionComposerCommand(text, {
+        agent: 'codex',
+        snapshot: options,
+        invokeAction: async () => true,
+        setOption,
+        conversationCommands: ['compact'],
+        runConversationCommand: async () => ({ accepted: await setOption(), error: null })
+      }),
+    optionsSurface: {
+      getSnapshot: () => options,
+      setOption: async () => ({ snapshot: options }),
+      invokeAction: async () => ({ snapshot: options }),
+      subscribe: () => () => {}
+    },
+    optionSnapshot: options,
+    onError: vi.fn(),
+    onSubmitted,
+    runtime: 'remote',
+    sessionId: 'session-a',
+    runtimeEnvironmentId: 'review-environment'
+  }
+}
+
+function useReviewTranscript() {
+  const scrollRef = useRef(document.createElement('div'))
+  Object.defineProperties(scrollRef.current, {
+    clientHeight: { configurable: true, value: 500 },
+    scrollHeight: { configurable: true, value: 2000 }
+  })
+  const contentRef = useRef<HTMLDivElement | null>(null)
+  const scrollToEnd = useRef(vi.fn()).current
+  const scroll = useNativeChatTranscriptScroll({
+    scrollRef,
+    contentRef,
+    itemCount: 10,
+    isWorking: true,
+    showsTailRow: true,
+    isVisible: true,
+    alignToViewportTop: vi.fn(),
+    scrollToEnd,
+    restoreScrollOffset: vi.fn(),
+    consumeProgrammaticScroll: () => false,
+    reconcileReaderScroll: vi.fn()
+  })
+  const reveal = useNativeChatRevealLatest()
+  useNativeChatMessageListHandle(reveal.messageListRef, scroll.scrollToBottom)
+  return { ...reveal, scroll, scrollToEnd, element: scrollRef.current }
+}
+
+function readerScrollAway(transcript: ReturnType<typeof useReviewTranscript>) {
+  act(() => transcript.scroll.readerLeavesEnd())
+  transcript.element.scrollTop = 500
+  const surface = render(
+    <div data-testid="reader-scroll-surface" onScroll={transcript.scroll.onScroll} />
+  )
+  fireEvent.scroll(surface.getByTestId('reader-scroll-surface'))
+  surface.unmount()
+}
+
+it('reveals a structured command at the press, before the host answers it', async () => {
+  const host = deferred<boolean>()
+  const hook = renderHook(() => {
+    const transcript = useReviewTranscript()
+    const t = transport(transcript.revealLatest, () => host.promise)
+    const send = useNativeChatStructuredComposerSend({
+      agent: 'codex',
+      draftScopeKey: 'send-r1-delay',
+      imageAttachments: [],
+      structuredTransport: t,
+      isComposing: () => false,
+      clearSkillOrigin: vi.fn(),
+      setHistory: vi.fn(),
+      setDraft: vi.fn(),
+      setCaret: vi.fn()
+    })
+    return { ...transcript, send }
+  })
+  readerScrollAway(hook.result.current)
+  hook.result.current.scrollToEnd.mockClear()
+  act(() => hook.result.current.send('/compact'))
+  expect(hook.result.current.scrollToEnd).toHaveBeenCalled()
+  // The answer arriving later leaves a reader who has since scrolled away.
+  readerScrollAway(hook.result.current)
+  expect(hook.result.current.scroll.showJump).toBe(true)
+  hook.result.current.scrollToEnd.mockClear()
+  await act(async () => host.settle(true))
+  expect(hook.result.current.scrollToEnd).not.toHaveBeenCalled()
+})
+
+it('reveals a goal at the press, before the host sets it', async () => {
+  const host = deferred<boolean>()
+  const scope = 'send-r1-goal'
+  writeNativeChatDraftCache(scope, '/goal')
+  const hook = renderHook(
+    ({ draft }: { draft: string }) => {
+      const transcript = useReviewTranscript()
+      const t = {
+        ...transport(transcript.revealLatest, async () => true),
+        threadGoal: { setObjective: () => host.promise }
+      }
+      const submit = useNativeChatComposerSubmit({
+        structuredTransport: t,
+        draftScopeKey: scope,
+        draft,
+        caret: draft.length,
+        imageAttachments: [],
+        disabled: false,
+        sendPty: vi.fn(),
+        sendStructured: vi.fn(),
+        setHistory: vi.fn(),
+        setDraft: vi.fn(),
+        setCaret: vi.fn()
+      })
+      return { ...transcript, submit }
+    },
+    { initialProps: { draft: '/goal' } }
+  )
+  hook.result.current.scrollToEnd.mockClear()
+  act(() => hook.result.current.submit.send())
+  writeNativeChatDraftCache(scope, 'Ship the parser')
+  hook.rerender({ draft: 'Ship the parser' })
+  readerScrollAway(hook.result.current)
+  hook.result.current.scrollToEnd.mockClear()
+  act(() => hook.result.current.submit.send())
+  expect(hook.result.current.scrollToEnd).toHaveBeenCalled()
+  readerScrollAway(hook.result.current)
+  expect(hook.result.current.scroll.showJump).toBe(true)
+  hook.result.current.scrollToEnd.mockClear()
+  await act(async () => host.settle(true))
+  expect(hook.result.current.scrollToEnd).not.toHaveBeenCalled()
+})
+
+it.each(['/model', '/effort'])(
+  'does not reveal history when %s only opens its picker',
+  async (text) => {
+    const onSubmitted = vi.fn()
+    const t = transport(onSubmitted, async () => true)
+    const hook = renderHook(() =>
+      useNativeChatStructuredComposerSend({
+        agent: 'codex',
+        draftScopeKey: 'send-r1-picker',
+        imageAttachments: [],
+        structuredTransport: t,
+        isComposing: () => false,
+        clearSkillOrigin: vi.fn(),
+        setHistory: vi.fn(),
+        setDraft: vi.fn(),
+        setCaret: vi.fn()
+      })
+    )
+    await act(async () => hook.result.current(text))
+    expect(t.send).not.toHaveBeenCalled()
+    expect(onSubmitted).not.toHaveBeenCalled()
+  }
+)
+
+function localAnswerArgs() {
+  return {
+    agent: 'omp' as const,
+    disabled: false,
+    isDispatchingSessionOption: false,
+    resolveTarget: () => ({ ptyId: 'pty-a', settings: null }),
+    onSlashCommand: vi.fn(),
+    onSubmitted: vi.fn(),
+    answerCommandLocally: () => 'Context: 20k / 272k tokens',
+    sessionOptionsSurface: null,
+    trackPendingSend: vi.fn(),
+    setHistory: vi.fn(),
+    setDraft: vi.fn(),
+    setCaret: vi.fn(),
+    clearSkillOrigin: vi.fn(),
+    clearImageAttachments: vi.fn(),
+    setNotice: vi.fn()
+  }
+}
+
+it('reveals the new transcript answer for a typed locally answered /context', () => {
+  const args = {
+    ...localAnswerArgs(),
+    draft: '/context',
+    imageAttachments: [],
+    launchDraftResolved: true,
+    classifySend: () => 'command' as const,
+    terminalTabId: 'tab-a'
+  }
+  const hook = renderHook(() => useNativeChatPtyComposerSend(args))
+  act(() => hook.result.current())
+  expect(args.onSlashCommand).toHaveBeenCalledWith('/context', 'Context: 20k / 272k tokens')
+  expect(runtime.message).not.toHaveBeenCalled()
+  expect(args.onSubmitted).toHaveBeenCalledOnce()
+})
+
+it('reveals the new transcript answer for a picked locally answered /context', () => {
+  const args = { ...localAnswerArgs(), setActiveSuggestion: vi.fn() }
+  const hook = renderHook(() => useNativeChatPickerCommandDispatch(args))
+  act(() =>
+    hook.result.current({
+      kind: 'command',
+      id: 'context',
+      name: 'context',
+      token: '/context',
+      skillCollision: false
+    })
+  )
+  expect(args.onSlashCommand).toHaveBeenCalledWith('/context', 'Context: 20k / 272k tokens')
+  expect(runtime.message).not.toHaveBeenCalled()
+  expect(args.onSubmitted).toHaveBeenCalledOnce()
+})
+
+it('reveals only the pane whose option send it was, at the press', async () => {
+  const host = deferred<boolean>()
+  runtime.verified.mockImplementationOnce(() => host.promise)
+  const revealA = vi.fn()
+  const revealB = vi.fn()
+  const hook = renderHook(
+    ({ ptyId }: { ptyId: string }) => {
+      const reveal = useNativeChatRevealLatest()
+      useNativeChatMessageListHandle(reveal.messageListRef, ptyId === 'pty-a' ? revealA : revealB)
+      return useNativeChatSessionOptionCommand({
+        agent: 'codex',
+        disabled: false,
+        resolveTarget: () => ({ ptyId, settings: null }),
+        onSubmitted: reveal.revealLatest,
+        setHistory: vi.fn()
+      })
+    },
+    { initialProps: { ptyId: 'pty-a' } }
+  )
+  let sending: Promise<unknown> = Promise.resolve()
+  await act(async () => {
+    sending = Promise.resolve(hook.result.current.dispatch('/model next'))
+  })
+  expect(runtime.verified).toHaveBeenCalledOnce()
+  expect(revealA).toHaveBeenCalledOnce()
+  hook.rerender({ ptyId: 'pty-b' })
+  await act(async () => {
+    host.settle(true)
+    await sending
+  })
+  expect(revealA).toHaveBeenCalledOnce()
+  expect(revealB).not.toHaveBeenCalled()
+})
+
+it('reveals a PTY option send at the press, before the terminal confirms it', async () => {
+  const host = deferred<boolean>()
+  runtime.verified.mockImplementationOnce(() => host.promise)
+  const hook = renderHook(() => {
+    const transcript = useReviewTranscript()
+    const command = useNativeChatSessionOptionCommand({
+      agent: 'codex',
+      disabled: false,
+      resolveTarget: () => ({ ptyId: 'pty-a', settings: null }),
+      onSubmitted: transcript.revealLatest,
+      setHistory: vi.fn()
+    })
+    return { ...transcript, command }
+  })
+  readerScrollAway(hook.result.current)
+  hook.result.current.scrollToEnd.mockClear()
+  let sending: Promise<unknown> = Promise.resolve()
+  await act(async () => {
+    sending = Promise.resolve(hook.result.current.command.dispatch('/model next'))
+  })
+  expect(hook.result.current.scrollToEnd).toHaveBeenCalled()
+  readerScrollAway(hook.result.current)
+  expect(hook.result.current.scroll.showJump).toBe(true)
+  hook.result.current.scrollToEnd.mockClear()
+  await act(async () => {
+    host.settle(true)
+    await sending
+  })
+  expect(hook.result.current.scrollToEnd).not.toHaveBeenCalled()
+})
+
+it('control: a refused structured message does not reveal', async () => {
+  const onSubmitted = vi.fn()
+  const t = transport(onSubmitted, async () => true)
+  vi.mocked(t.send).mockReturnValue(false)
+  const hook = renderHook(() =>
+    useNativeChatStructuredComposerSend({
+      agent: 'codex',
+      draftScopeKey: 'send-r1-refused',
+      imageAttachments: [],
+      structuredTransport: t,
+      isComposing: () => false,
+      clearSkillOrigin: vi.fn(),
+      setHistory: vi.fn(),
+      setDraft: vi.fn(),
+      setCaret: vi.fn()
+    })
+  )
+  await act(async () => hook.result.current('hello'))
+  expect(t.send).toHaveBeenCalledWith('hello', [])
+  expect(onSubmitted).not.toHaveBeenCalled()
+})
+
+const approval: StructuredPromptItem = {
+  itemId: 'approval-1',
+  revision: 3,
+  sequence: 3,
+  observedAt: 3,
+  body: {
+    kind: 'approval',
+    title: 'Allow Bash?',
+    detail: null,
+    options: [{ id: 'allow', label: 'Allow' }],
+    resolution: { state: 'pending', selectedOptionId: null, resolvedBy: null, resolvedAt: null }
+  }
+}
+
+it('reveals a structured prompt answer at the press, before the host accepts it', async () => {
+  const host = deferred<null>()
+  const hook = renderHook(() => {
+    const transcript = useReviewTranscript()
+    const submits = useStructuredNativeChatSubmitReveal(
+      {
+        respond: async () => host.promise,
+        retry: vi.fn(),
+        queuedMessages: {
+          queueCapable: true,
+          cards: [],
+          pause: null,
+          resuming: false,
+          resume: async () => false,
+          steer: async () => {},
+          remove: async () => {},
+          edit: async () => {},
+          steerNewest: () => false
+        }
+      },
+      vi.fn()
+    )
+    useNativeChatMessageListHandle(submits.messageListRef, transcript.scroll.scrollToBottom)
+    return { ...transcript, submits }
+  })
+  readerScrollAway(hook.result.current)
+  hook.result.current.scrollToEnd.mockClear()
+  let answering: Promise<unknown> = Promise.resolve()
+  act(() => {
+    answering = hook.result.current.submits.respond(approval, { kind: 'option', optionId: 'allow' })
+  })
+  expect(hook.result.current.scrollToEnd).toHaveBeenCalled()
+  readerScrollAway(hook.result.current)
+  hook.result.current.scrollToEnd.mockClear()
+  await act(async () => {
+    host.settle(null)
+    await answering
+  })
+  expect(hook.result.current.scrollToEnd).not.toHaveBeenCalled()
+})
+
+it('keeps an accepted queued draft out of transcript navigation', async () => {
+  const onSubmitted = vi.fn()
+  const t = transport(onSubmitted, async () => true)
+  t.send = vi.fn(() => 'queued' as const)
+  const hook = renderHook(() =>
+    useNativeChatStructuredComposerSend({
+      agent: 'codex',
+      draftScopeKey: 'queue-navigation',
+      imageAttachments: [],
+      structuredTransport: t,
+      isComposing: () => false,
+      clearSkillOrigin: vi.fn(),
+      setHistory: vi.fn(),
+      setDraft: vi.fn(),
+      setCaret: vi.fn()
+    })
+  )
+  await act(async () => hook.result.current('Next task'))
+  expect(t.send).toHaveBeenCalledWith('Next task', [])
+  expect(onSubmitted).not.toHaveBeenCalled()
+})
diff --git a/src/renderer/src/components/native-chat/native-chat-windowing-test-harness.tsx b/src/renderer/src/components/native-chat/native-chat-windowing-test-harness.tsx
index 05b2de7dc273..a560786524a4 100644
--- a/src/renderer/src/components/native-chat/native-chat-windowing-test-harness.tsx
+++ b/src/renderer/src/components/native-chat/native-chat-windowing-test-harness.tsx
@@ -324,6 +324,7 @@ export function scrollTranscript(container: HTMLElement, top: number): void {
   if (!scroller) {
     throw new Error('no transcript scroll root')
   }
+  fireEvent.wheel(scroller, { deltaY: top - scroller.scrollTop })
   scroller.scrollTop = top
   fireEvent.scroll(scroller)
 }
diff --git a/src/renderer/src/components/native-chat/use-native-chat-composer-submit.test.tsx b/src/renderer/src/components/native-chat/use-native-chat-composer-submit.test.tsx
index 7ec967b6f0e9..29d5dfad7641 100644
--- a/src/renderer/src/components/native-chat/use-native-chat-composer-submit.test.tsx
+++ b/src/renderer/src/components/native-chat/use-native-chat-composer-submit.test.tsx
@@ -40,9 +40,11 @@ function harness(options: {
   lane?: 'pty'
 }) {
   const onError = vi.fn()
-  // oxlint-disable-next-line typescript/consistent-type-assertions -- SAFETY: submit reads only threadGoal and onError.
+  const onSubmitted = vi.fn()
+  // oxlint-disable-next-line typescript/consistent-type-assertions -- SAFETY: submit reads only threadGoal, onError and onSubmitted.
   const structuredTransport = {
     onError,
+    onSubmitted,
     ...(options.threadGoal ? { threadGoal: options.threadGoal } : {})
   } as unknown as NativeChatStructuredComposerTransport
   const calls = {
@@ -71,7 +73,7 @@ function harness(options: {
     writeNativeChatDraftCache(SCOPE, draft)
     hook.rerender({ draft, caret })
   }
-  return { hook, calls, onError, type }
+  return { hook, calls, onError, onSubmitted, type }
 }
 
 describe('composer goal mode', () => {
@@ -104,13 +106,18 @@ describe('composer goal mode', () => {
 
   it('sets the draft as the goal instead of sending it, then leaves goal mode', async () => {
     const setObjective = vi.fn(async () => true)
-    const { hook, calls, type } = harness({ draft: '/go', threadGoal: { setObjective } })
+    const { hook, calls, onSubmitted, type } = harness({
+      draft: '/go',
+      threadGoal: { setObjective }
+    })
     act(() => hook.result.current.goalMode.interceptPick(vi.fn())(GOAL_ITEM))
     type('  Ship the parser  ', 0)
 
     await act(async () => hook.result.current.send())
 
     expect(setObjective).toHaveBeenCalledWith('Ship the parser')
+    // The pane brings the latest into view for a goal it set, as for a sent message.
+    expect(onSubmitted).toHaveBeenCalledOnce()
     expect(calls.sendStructured).not.toHaveBeenCalled()
     expect(readNativeChatDraftCache(SCOPE)).toBe('')
     expect(hook.result.current.goalMode.active).toBe(false)
@@ -118,7 +125,10 @@ describe('composer goal mode', () => {
 
   it('keeps the draft and goal mode when the goal is refused', async () => {
     const setObjective = vi.fn(async () => false)
-    const { hook, calls, type } = harness({ draft: '/go', threadGoal: { setObjective } })
+    const { hook, calls, onSubmitted, type } = harness({
+      draft: '/go',
+      threadGoal: { setObjective }
+    })
     act(() => hook.result.current.goalMode.interceptPick(vi.fn())(GOAL_ITEM))
     calls.setDraft.mockClear()
     type('Ship the parser', 0)
@@ -126,6 +136,8 @@ describe('composer goal mode', () => {
     await act(async () => hook.result.current.send())
 
     expect(setObjective).toHaveBeenCalledOnce()
+    // Revealed at the press, before the host answered.
+    expect(onSubmitted).toHaveBeenCalledOnce()
     expect(calls.setDraft).not.toHaveBeenCalled()
     expect(hook.result.current.goalMode.active).toBe(true)
   })
diff --git a/src/renderer/src/components/native-chat/use-native-chat-composer-submit.ts b/src/renderer/src/components/native-chat/use-native-chat-composer-submit.ts
index 65d7c515a4b9..6a5fd5460fcd 100644
--- a/src/renderer/src/components/native-chat/use-native-chat-composer-submit.ts
+++ b/src/renderer/src/components/native-chat/use-native-chat-composer-submit.ts
@@ -85,6 +85,7 @@ export function useNativeChatComposerSubmit(args: {
       )
       return
     }
+    structuredTransport.onSubmitted?.()
     const submitted = readNativeChatComposerDraft(draftScopeKey)
     void threadGoal.setObjective(objective).then((accepted) => {
       if (!accepted) {
diff --git a/src/renderer/src/components/native-chat/use-native-chat-local-command-answer.ts b/src/renderer/src/components/native-chat/use-native-chat-local-command-answer.ts
index 0a330c1fd393..6e4a2117d11e 100644
--- a/src/renderer/src/components/native-chat/use-native-chat-local-command-answer.ts
+++ b/src/renderer/src/components/native-chat/use-native-chat-local-command-answer.ts
@@ -79,6 +79,7 @@ export function answerNativeChatCommandInComposer(args: {
   answerCommandLocally?: NativeChatLocalCommandAnswer
   sessionOptionsSurface: NativeChatPtySessionOptionsSurface | null
   onSlashCommand?: (command: string, output?: string) => void
+  onSubmitted?: () => void
   setHistory: Dispatch<SetStateAction<HistoryState>>
   setDraft: (value: string) => void
   setCaret: Dispatch<SetStateAction<number>>
@@ -95,6 +96,7 @@ export function answerNativeChatCommandInComposer(args: {
     return false
   }
   args.onSlashCommand?.(command, answer)
+  args.onSubmitted?.()
   args.setHistory((previous) => pushHistory(previous, args.draft))
   args.setDraft('')
   args.setCaret(0)
diff --git a/src/renderer/src/components/native-chat/use-native-chat-picker-command-dispatch.test.tsx b/src/renderer/src/components/native-chat/use-native-chat-picker-command-dispatch.test.tsx
index 7584dcc15a4b..05a65b7c0778 100644
--- a/src/renderer/src/components/native-chat/use-native-chat-picker-command-dispatch.test.tsx
+++ b/src/renderer/src/components/native-chat/use-native-chat-picker-command-dispatch.test.tsx
@@ -28,10 +28,11 @@ const COMMAND = {
   skillCollision: false
 }
 
-function renderDispatch(agent: 'codex' | 'claude' | 'openclaude') {
+function renderDispatch(agent: 'codex' | 'claude' | 'openclaude', onSubmitted = vi.fn()) {
   return renderHook(() =>
     useNativeChatPickerCommandDispatch({
       agent,
+      onSubmitted,
       disabled: false,
       isDispatchingSessionOption: false,
       resolveTarget: () => ({ settings: {}, ptyId: 'pty-1' }),
@@ -57,11 +58,13 @@ describe('useNativeChatPickerCommandDispatch', () => {
   })
 
   it('types Codex autocomplete commands', () => {
-    const hook = renderDispatch('codex')
+    const onSubmitted = vi.fn()
+    const hook = renderDispatch('codex', onSubmitted)
     act(() => hook.result.current(COMMAND))
 
     expect(sendNativeChatTypedCommand).toHaveBeenCalledWith({}, 'pty-1', '/status')
     expect(sendNativeChatMessage).not.toHaveBeenCalled()
+    expect(onSubmitted).toHaveBeenCalledOnce()
   })
 
   it.each(['claude', 'openclaude'] as const)('keeps %s autocomplete commands pasted', (agent) => {
diff --git a/src/renderer/src/components/native-chat/use-native-chat-picker-command-dispatch.ts b/src/renderer/src/components/native-chat/use-native-chat-picker-command-dispatch.ts
index 1c983733dd98..7f15227577db 100644
--- a/src/renderer/src/components/native-chat/use-native-chat-picker-command-dispatch.ts
+++ b/src/renderer/src/components/native-chat/use-native-chat-picker-command-dispatch.ts
@@ -29,6 +29,7 @@ export function useNativeChatPickerCommandDispatch(args: {
   resolveTarget: () => NativeChatResolvedTarget | null
   onSlashCommand?: (command: string, output?: string) => void
   answerCommandLocally?: NativeChatLocalCommandAnswer
+  onSubmitted?: () => void
   sessionOptionsSurface: NativeChatPtySessionOptionsSurface | null
   trackPendingSend: NativeChatSendLifecycle['trackPendingSend']
   setHistory: Dispatch<SetStateAction<HistoryState>>
@@ -46,6 +47,7 @@ export function useNativeChatPickerCommandDispatch(args: {
     resolveTarget,
     onSlashCommand,
     answerCommandLocally,
+    onSubmitted,
     sessionOptionsSurface,
     trackPendingSend,
     setHistory,
@@ -69,6 +71,7 @@ export function useNativeChatPickerCommandDispatch(args: {
           answerCommandLocally,
           sessionOptionsSurface,
           onSlashCommand,
+          onSubmitted,
           setHistory,
           setDraft,
           setCaret,
@@ -97,6 +100,7 @@ export function useNativeChatPickerCommandDispatch(args: {
         agent,
         runtime: nativeChatComposerTargetIsRemote(target.ptyId) ? 'remote' : 'local'
       })
+      onSubmitted?.()
       setHistory((previous) => pushHistory(previous, text))
       setDraft('')
       setCaret(0)
@@ -113,6 +117,7 @@ export function useNativeChatPickerCommandDispatch(args: {
       disabled,
       isDispatchingSessionOption,
       onSlashCommand,
+      onSubmitted,
       resolveTarget,
       sessionOptionsSurface,
       setActiveSuggestion,
diff --git a/src/renderer/src/components/native-chat/use-native-chat-pty-composer-send.test.tsx b/src/renderer/src/components/native-chat/use-native-chat-pty-composer-send.test.tsx
index b480c065e91e..1751d59c7853 100644
--- a/src/renderer/src/components/native-chat/use-native-chat-pty-composer-send.test.tsx
+++ b/src/renderer/src/components/native-chat/use-native-chat-pty-composer-send.test.tsx
@@ -27,7 +27,7 @@ function send(
   draft: string,
   imagePaths: string[] = []
 ) {
-  const callbacks = { rejected: vi.fn(), unconfirmed: vi.fn() }
+  const callbacks = { rejected: vi.fn(), unconfirmed: vi.fn(), submitted: vi.fn() }
   const { result } = renderHook(() =>
     useNativeChatPtyComposerSend({
       agent,
@@ -40,6 +40,7 @@ function send(
       classifySend: () => classification,
       onOptimisticSend: () => 'pending-1',
       optimisticSendOutcome: { reject: callbacks.rejected, holdUnconfirmed: callbacks.unconfirmed },
+      onSubmitted: callbacks.submitted,
       sessionOptionsSurface: null,
       terminalTabId: 'tab',
       trackPendingSend: vi.fn(),
@@ -82,3 +83,16 @@ it.each([
   send(agent, classification, draft)
   expect(vi.mocked(sendNativeChatMessage).mock.calls[0]?.[3]?.onWriteRejected).toBeUndefined()
 })
+
+// The pane brings the latest into view on this, whatever the send was classified as.
+it.each([
+  ['chat', 'hello'],
+  ['command', '/compact'],
+  ['unknown-token', '$my-skill do the thing']
+] as const)('reports a %s send as submitted', (classification, draft) => {
+  expect(send('codex', classification, draft).submitted).toHaveBeenCalledOnce()
+})
+
+it('reports nothing for a blank draft', () => {
+  expect(send('codex', 'chat', '   ').submitted).not.toHaveBeenCalled()
+})
diff --git a/src/renderer/src/components/native-chat/use-native-chat-pty-composer-send.ts b/src/renderer/src/components/native-chat/use-native-chat-pty-composer-send.ts
index e38e0282f4d5..ba8e36b05f1c 100644
--- a/src/renderer/src/components/native-chat/use-native-chat-pty-composer-send.ts
+++ b/src/renderer/src/components/native-chat/use-native-chat-pty-composer-send.ts
@@ -39,6 +39,7 @@ export function useNativeChatPtyComposerSend(args: {
   optimisticSendOutcome?: NativeChatOptimisticSendOutcome
   onSlashCommand?: (command: string, output?: string) => void
   answerCommandLocally?: NativeChatLocalCommandAnswer
+  onSubmitted?: () => void
   sessionOptionsSurface: NativeChatPtySessionOptionsSurface | null
   terminalTabId: string
   trackPendingSend: NativeChatSendLifecycle['trackPendingSend']
@@ -129,6 +130,7 @@ export function useNativeChatPtyComposerSend(args: {
       agent: args.agent,
       runtime: nativeChatComposerTargetIsRemote(target.ptyId) ? 'remote' : 'local'
     })
+    args.onSubmitted?.()
     args.setHistory((previous) => pushHistory(previous, text))
     args.setDraft('')
     args.setCaret(0)
diff --git a/src/renderer/src/components/native-chat/use-native-chat-rail-history-jump.test.ts b/src/renderer/src/components/native-chat/use-native-chat-rail-history-jump.test.ts
index f4cbafe9cd82..562f37ec3c55 100644
--- a/src/renderer/src/components/native-chat/use-native-chat-rail-history-jump.test.ts
+++ b/src/renderer/src/components/native-chat/use-native-chat-rail-history-jump.test.ts
@@ -88,7 +88,9 @@ function createLane({
   }
   const useLaneRailJump = (
     jumpToLoaded: (item: NativeChatRailItem) => void,
-    sessionKey = 'session-1'
+    sessionKey = 'session-1',
+    isVisible = true,
+    jumpToStart: () => void = () => {}
   ) => {
     const current = useSyncExternalStore(lane.subscribe, lane.getSnapshot)
     const items = useMemo<NativeChatRailItem[]>(() => {
@@ -103,8 +105,10 @@ function createLane({
     return useNativeChatRailHistoryJump({
       items,
       sessionKey,
+      isVisible,
       loadEarlier: lane.loadEarlier,
-      jumpToLoaded
+      jumpToLoaded,
+      jumpToStart
     })
   }
   return { lane, useLaneRailJump }
@@ -292,6 +296,27 @@ describe('rail jump through unloaded history', () => {
     expect(jumpToLoaded).not.toHaveBeenCalled()
   })
 
+  // A hidden terminal-backed pane stops reading its transcript, so the page would never land.
+  it('abandons the jump when the pane hides mid-page', async () => {
+    const { lane, useLaneRailJump } = createLane({ total: 40, pageSize: 10, initiallyLoaded: 10 })
+    lane.holdPages()
+    const jumpToLoaded = vi.fn()
+    const { result, rerender } = renderHook(
+      ({ isVisible }: { isVisible: boolean }) =>
+        useLaneRailJump(jumpToLoaded, 'session-1', isVisible),
+      { initialProps: { isVisible: true } }
+    )
+
+    act(() => result.current.start(outlineItem('m25')))
+    await waitFor(() => expect(lane.reads.count).toBe(1))
+    rerender({ isVisible: false })
+    expect(result.current.pendingId).toBeNull()
+    await releasePage(lane)
+
+    expect(lane.reads.count).toBe(1)
+    expect(jumpToLoaded).not.toHaveBeenCalled()
+  })
+
   it('abandons the jump when the list unmounts mid-page', async () => {
     const { lane, useLaneRailJump } = createLane({ total: 40, pageSize: 10, initiallyLoaded: 10 })
     lane.holdPages()
@@ -306,3 +331,73 @@ describe('rail jump through unloaded history', () => {
     expect(jumpToLoaded).not.toHaveBeenCalled()
   })
 })
+
+describe('jumping to the start of the conversation', () => {
+  it('pages until no older history is left, then jumps to the start', async () => {
+    const { lane, useLaneRailJump } = createLane({ total: 100, pageSize: 10, initiallyLoaded: 10 })
+    const jumpToStart = vi.fn()
+    const { result } = renderHook(() => useLaneRailJump(vi.fn(), 'session-1', true, jumpToStart))
+
+    act(() => result.current.startFromBeginning())
+    expect(result.current.startPending).toBe(true)
+    expect(result.current.pendingId).toBeNull()
+
+    await waitFor(() => expect(jumpToStart).toHaveBeenCalledTimes(1))
+    expect(lane.getSnapshot().loaded).toBe(100)
+    // Nine pages load the rest; the tenth answers that nothing older is left.
+    expect(lane.reads.count).toBe(9)
+    expect(lane.loadEarlier).toHaveBeenCalledTimes(10)
+    expect(result.current.startPending).toBe(false)
+  })
+
+  it('lands on the top of what loaded when an older page cannot be read', async () => {
+    const { lane, useLaneRailJump } = createLane({
+      total: 40,
+      pageSize: 10,
+      initiallyLoaded: 10,
+      pageResult: 'failed'
+    })
+    const jumpToStart = vi.fn()
+    const { result } = renderHook(() => useLaneRailJump(vi.fn(), 'session-1', true, jumpToStart))
+
+    act(() => result.current.startFromBeginning())
+    await waitFor(() => expect(jumpToStart).toHaveBeenCalledTimes(1))
+    expect(lane.getSnapshot().loaded).toBe(10)
+  })
+
+  it('does not jump once aborted mid-page', async () => {
+    const { lane, useLaneRailJump } = createLane({ total: 40, pageSize: 10, initiallyLoaded: 10 })
+    lane.holdPages()
+    const jumpToStart = vi.fn()
+    const { result } = renderHook(() => useLaneRailJump(vi.fn(), 'session-1', true, jumpToStart))
+
+    act(() => result.current.startFromBeginning())
+    await waitFor(() => expect(lane.reads.count).toBe(1))
+    act(() => result.current.abort())
+    expect(result.current.startPending).toBe(false)
+    await releasePage(lane)
+
+    expect(lane.reads.count).toBe(1)
+    expect(jumpToStart).not.toHaveBeenCalled()
+  })
+
+  it('abandons the jump when the pane hides mid-page', async () => {
+    const { lane, useLaneRailJump } = createLane({ total: 40, pageSize: 10, initiallyLoaded: 10 })
+    lane.holdPages()
+    const jumpToStart = vi.fn()
+    const { result, rerender } = renderHook(
+      ({ isVisible }: { isVisible: boolean }) =>
+        useLaneRailJump(vi.fn(), 'session-1', isVisible, jumpToStart),
+      { initialProps: { isVisible: true } }
+    )
+
+    act(() => result.current.startFromBeginning())
+    await waitFor(() => expect(lane.reads.count).toBe(1))
+    rerender({ isVisible: false })
+    expect(result.current.startPending).toBe(false)
+    await releasePage(lane)
+
+    expect(lane.reads.count).toBe(1)
+    expect(jumpToStart).not.toHaveBeenCalled()
+  })
+})
diff --git a/src/renderer/src/components/native-chat/use-native-chat-rail-history-jump.ts b/src/renderer/src/components/native-chat/use-native-chat-rail-history-jump.ts
index 88fe490ab303..1d92581a4314 100644
--- a/src/renderer/src/components/native-chat/use-native-chat-rail-history-jump.ts
+++ b/src/renderer/src/components/native-chat/use-native-chat-rail-history-jump.ts
@@ -1,5 +1,6 @@
 // Jumping to a rail tick whose message is not loaded yet: page older history in
-// until the message has a slot, then hand it to the ordinary rail jump.
+// until the message has a slot, then hand it to the ordinary rail jump. Jumping
+// to the start of the conversation is the same walk, with no older page as its target.
 //
 // One awaited loop per jump, owning its own lifecycle. Each step reads the rail
 // from a commit made after the last page landed, so "has a slot yet?" is always
@@ -16,6 +17,9 @@ import type { NativeChatOlderPageResult } from './native-chat-pagination'
  *  runaway loop reaches it. */
 export const NATIVE_CHAT_RAIL_JUMP_MAX_PAGES = 1000
 
+const HISTORY_START = Symbol('history-start')
+type HistoryJumpTarget = string | typeof HISTORY_START
+
 function railItemById(
   items: readonly NativeChatRailItem[],
   id: string
@@ -26,28 +30,36 @@ function railItemById(
 export function useNativeChatRailHistoryJump({
   items,
   sessionKey,
+  isVisible,
   loadEarlier,
-  jumpToLoaded
+  jumpToLoaded,
+  jumpToStart
 }: {
   items: readonly NativeChatRailItem[]
   /** A change abandons the jump: its target belongs to the previous session. */
   sessionKey: string
+  /** Hiding the pane abandons the jump too: a hidden lane stops reading, so a page never lands. */
+  isVisible: boolean
   loadEarlier: () => Promise<NativeChatOlderPageResult>
   jumpToLoaded: (item: NativeChatRailItem) => void
+  /** Called once no older page is left, or none can be read: the top of what loaded. */
+  jumpToStart: () => void
 }): {
   pendingId: string | null
+  startPending: boolean
   start: (item: NativeChatRailItem) => void
+  startFromBeginning: () => void
   abort: () => void
 } {
-  const [pendingId, setPendingId] = useState<string | null>(null)
+  const [pending, setPending] = useState<HistoryJumpTarget | null>(null)
   const [, requestCommit] = useReducer((count: number) => count + 1, 0)
   const controllerRef = useRef<AbortController | null>(null)
-  const committedRef = useRef({ items, loadEarlier, jumpToLoaded })
+  const committedRef = useRef({ items, loadEarlier, jumpToLoaded, jumpToStart })
   const commitWaitersRef = useRef(new Set<() => void>())
 
   // Every commit: the loop reads what the list last rendered, never a render in progress.
   useLayoutEffect(() => {
-    committedRef.current = { items, loadEarlier, jumpToLoaded }
+    committedRef.current = { items, loadEarlier, jumpToLoaded, jumpToStart }
     const waiters = [...commitWaitersRef.current]
     commitWaitersRef.current.clear()
     for (const resolve of waiters) {
@@ -71,22 +83,32 @@ export function useNativeChatRailHistoryJump({
   }, [])
 
   const run = useCallback(
-    async (id: string, signal: AbortSignal): Promise<void> => {
+    async (target: HistoryJumpTarget, signal: AbortSignal): Promise<void> => {
       for (let pages = 0; ; pages += 1) {
-        // Each pass reads a newer commit's rail, so there is no list to index up front.
-        const target = railItemById(committedRef.current.items, id)
-        if (!target) {
+        if (target !== HISTORY_START) {
+          // Each pass reads a newer commit's rail, so there is no list to index up front.
+          const item = railItemById(committedRef.current.items, target)
+          if (!item) {
+            return
+          }
+          if (item.slotIndex !== null) {
+            committedRef.current.jumpToLoaded(item)
+            return
+          }
+        }
+        if (pages >= NATIVE_CHAT_RAIL_JUMP_MAX_PAGES) {
           return
         }
-        if (target.slotIndex !== null) {
-          committedRef.current.jumpToLoaded(target)
+        const result = await committedRef.current.loadEarlier()
+        if (signal.aborted) {
           return
         }
-        if (pages >= NATIVE_CHAT_RAIL_JUMP_MAX_PAGES) {
+        // A page that cannot be read still leaves the reader asking for the top of what loaded.
+        if (target === HISTORY_START && result !== 'applied' && result !== 'superseded') {
+          committedRef.current.jumpToStart()
           return
         }
-        const result = await committedRef.current.loadEarlier()
-        if (signal.aborted || result !== 'applied') {
+        if (result !== 'applied') {
           return
         }
         await nextCommit(signal)
@@ -105,29 +127,37 @@ export function useNativeChatRailHistoryJump({
     }
     controllerRef.current = null
     controller.abort()
-    setPendingId(null)
+    setPending(null)
   }, [])
 
   // The latest pick wins; a page the previous jump started is joined, not repeated.
-  const start = useCallback(
-    (item: NativeChatRailItem) => {
+  const begin = useCallback(
+    (target: HistoryJumpTarget) => {
       controllerRef.current?.abort()
       const controller = new AbortController()
       controllerRef.current = controller
-      setPendingId(item.id)
-      void run(item.id, controller.signal)
+      setPending(target)
+      void run(target, controller.signal)
         .catch(() => undefined)
         .finally(() => {
           if (controllerRef.current === controller) {
             controllerRef.current = null
-            setPendingId(null)
+            setPending(null)
           }
         })
     },
     [run]
   )
+  const start = useCallback((item: NativeChatRailItem) => begin(item.id), [begin])
+  const startFromBeginning = useCallback(() => begin(HISTORY_START), [begin])
 
-  useEffect(() => abort, [abort, sessionKey])
+  useEffect(() => abort, [abort, sessionKey, isVisible])
 
-  return { pendingId, start, abort }
+  return {
+    pendingId: typeof pending === 'string' ? pending : null,
+    startPending: pending === HISTORY_START,
+    start,
+    startFromBeginning,
+    abort
+  }
 }
diff --git a/src/renderer/src/components/native-chat/use-native-chat-reveal-latest.ts b/src/renderer/src/components/native-chat/use-native-chat-reveal-latest.ts
new file mode 100644
index 000000000000..974391df225a
--- /dev/null
+++ b/src/renderer/src/components/native-chat/use-native-chat-reveal-latest.ts
@@ -0,0 +1,81 @@
+// How a chat pane tells its transcript that the reader just sent something.
+
+import { useCallback, useImperativeHandle, useMemo, useRef } from 'react'
+import { hasAskAnswer } from './native-chat-interactive-prompt'
+import type { NativeChatInteractiveSend } from './use-native-chat-interactive-send'
+
+/** Answers and approval choices reveal at the press; Stop and dismissing a prompt do not. */
+export function useNativeChatInteractiveSendReveal(
+  {
+    sendAnswer,
+    sendRaw,
+    sendRawVerified,
+    cancelPending,
+    cancelAsk,
+    cancel
+  }: NativeChatInteractiveSend,
+  targetPtyId: string | null,
+  revealLatest: () => void
+): NativeChatInteractiveSend {
+  return useMemo<NativeChatInteractiveSend>(
+    () => ({
+      // Only what is written moves the reader: no terminal, or an empty answer, writes nothing.
+      sendAnswer: (prompt, selections, onDeliverySettled) => {
+        if (targetPtyId && hasAskAnswer(prompt, selections)) {
+          revealLatest()
+        }
+        return sendAnswer(prompt, selections, onDeliverySettled)
+      },
+      sendRaw,
+      sendRawVerified: (raw) => {
+        if (targetPtyId) {
+          revealLatest()
+        }
+        return sendRawVerified(raw)
+      },
+      cancelPending,
+      cancelAsk,
+      cancel
+    }),
+    [
+      cancel,
+      cancelAsk,
+      cancelPending,
+      revealLatest,
+      sendAnswer,
+      sendRaw,
+      sendRawVerified,
+      targetPtyId
+    ]
+  )
+}
+
+export type NativeChatMessageListHandle = {
+  /** Bring the latest into view and follow it, wherever the reader had scrolled. */
+  revealLatest: () => void
+}
+
+/** This pane's own transcript; an unmounted pane's reveal reaches nothing. */
+export function useNativeChatRevealLatest(): {
+  messageListRef: React.RefObject<NativeChatMessageListHandle | null>
+  revealLatest: () => void
+} {
+  const messageListRef = useRef<NativeChatMessageListHandle>(null)
+  const revealLatest = useCallback(() => {
+    try {
+      messageListRef.current?.revealLatest()
+    } catch (error) {
+      // Navigation never stops the send that asked for it.
+      console.error('Could not reveal the submitted chat content', error)
+    }
+  }, [])
+  return { messageListRef, revealLatest }
+}
+
+/** The transcript's side: what a pane's reveal does to this list. */
+export function useNativeChatMessageListHandle(
+  ref: React.Ref<NativeChatMessageListHandle> | undefined,
+  revealLatest: () => void
+): void {
+  useImperativeHandle(ref, () => ({ revealLatest }), [revealLatest])
+}
diff --git a/src/renderer/src/components/native-chat/use-native-chat-session-option-command.test.tsx b/src/renderer/src/components/native-chat/use-native-chat-session-option-command.test.tsx
index 5a43cd9b4be6..92b32f93b978 100644
--- a/src/renderer/src/components/native-chat/use-native-chat-session-option-command.test.tsx
+++ b/src/renderer/src/components/native-chat/use-native-chat-session-option-command.test.tsx
@@ -18,10 +18,11 @@ vi.mock('@/lib/native-chat-telemetry', () => ({ emitNativeChatMessageSent: vi.fn
 
 import { useNativeChatSessionOptionCommand } from './use-native-chat-session-option-command'
 
-function renderDispatch(agent: 'codex' | 'claude' | 'openclaude') {
+function renderDispatch(agent: 'codex' | 'claude' | 'openclaude', onSubmitted = vi.fn()) {
   return renderHook(() =>
     useNativeChatSessionOptionCommand({
       agent,
+      onSubmitted,
       disabled: false,
       resolveTarget: () => ({ settings: {}, ptyId: 'pty-1' }),
       setHistory: vi.fn()
@@ -37,8 +38,10 @@ describe('useNativeChatSessionOptionCommand', () => {
   })
 
   it('types Codex option commands even without caller delivery metadata', async () => {
-    const hook = renderDispatch('codex')
+    const onSubmitted = vi.fn()
+    const hook = renderDispatch('codex', onSubmitted)
     await act(() => hook.result.current.dispatch('/model'))
+    expect(onSubmitted).toHaveBeenCalledOnce()
 
     expect(typeNativeChatCommand).toHaveBeenCalledWith(
       {},
diff --git a/src/renderer/src/components/native-chat/use-native-chat-session-option-command.ts b/src/renderer/src/components/native-chat/use-native-chat-session-option-command.ts
index b5c6e5da9fc6..e5dae9f1c511 100644
--- a/src/renderer/src/components/native-chat/use-native-chat-session-option-command.ts
+++ b/src/renderer/src/components/native-chat/use-native-chat-session-option-command.ts
@@ -18,10 +18,11 @@ export function useNativeChatSessionOptionCommand(args: {
   agent: AgentType
   disabled: boolean
   onSlashCommand?: (command: string) => void
+  onSubmitted?: () => void
   resolveTarget: () => NativeChatResolvedTarget | null
   setHistory: Dispatch<SetStateAction<HistoryState>>
 }): { dispatch: NativeChatSessionOptionDispatchCommand; isDispatching: boolean } {
-  const { agent, disabled, onSlashCommand, resolveTarget, setHistory } = args
+  const { agent, disabled, onSlashCommand, onSubmitted, resolveTarget, setHistory } = args
   const mountedRef = useRef(true)
   const activeObserversRef = useRef(new Set<ClaudeModelSwitchConfirmationObserver>())
   const activeSendsRef = useRef(new Set<AbortController>())
@@ -54,6 +55,7 @@ export function useNativeChatSessionOptionCommand(args: {
       if (!target || disabled) {
         throw new Error('No live terminal is available.')
       }
+      onSubmitted?.()
       const sendController = new AbortController()
       activeSendsRef.current.add(sendController)
       // Why: block composer chat sends for the whole drain+observe+verify window.
@@ -124,7 +126,7 @@ export function useNativeChatSessionOptionCommand(args: {
         }
       }
     },
-    [agent, disabled, onSlashCommand, resolveTarget, setHistory]
+    [agent, disabled, onSlashCommand, onSubmitted, resolveTarget, setHistory]
   )
 
   return { dispatch, isDispatching }
diff --git a/src/renderer/src/components/native-chat/use-native-chat-structured-composer-send.test.tsx b/src/renderer/src/components/native-chat/use-native-chat-structured-composer-send.test.tsx
index ccd7b3785850..d67f9236136f 100644
--- a/src/renderer/src/components/native-chat/use-native-chat-structured-composer-send.test.tsx
+++ b/src/renderer/src/components/native-chat/use-native-chat-structured-composer-send.test.tsx
@@ -16,7 +16,8 @@ const ATTACHMENT = { id: 'a1', path: '/tmp/shot.png' } as NativeChatComposerImag
 
 function harness(
   agent: AgentType,
-  threadGoal?: NativeChatStructuredComposerTransport['threadGoal']
+  threadGoal?: NativeChatStructuredComposerTransport['threadGoal'],
+  onSubmitted?: () => void
 ) {
   const structuredTransport = {
     send: vi.fn(() => true),
@@ -38,6 +39,7 @@ function harness(
   if (threadGoal) {
     structuredTransport.threadGoal = threadGoal
   }
+  structuredTransport.onSubmitted = onSubmitted
   const { result } = renderHook(() =>
     useNativeChatStructuredComposerSend({
       agent,
@@ -97,3 +99,32 @@ describe('attachment guard follows what the host claims', () => {
     expect(structuredTransport.send).not.toHaveBeenCalled()
   })
 })
+
+// The pane brings the latest into view on this: a conversation command at the press, a message
+// once admitted, and neither for a refusal or a command the chat does not run.
+describe('reports the sends that bring the latest into view', () => {
+  it('reports a conversation command at the press, then not a message the transport refused', async () => {
+    const onSubmitted = vi.fn()
+    const { send, structuredTransport } = harness('claude', undefined, onSubmitted)
+    send('/compact', [])
+    expect(onSubmitted).toHaveBeenCalledOnce()
+
+    vi.mocked(structuredTransport.send).mockReturnValue(false)
+    send('hello', [])
+    await vi.waitFor(() => expect(structuredTransport.onError).toHaveBeenCalledTimes(2))
+    expect(structuredTransport.send).toHaveBeenCalledWith('hello', [])
+    expect(onSubmitted).toHaveBeenCalledOnce()
+  })
+
+  it('reports nothing for a host command chat sessions do not run', async () => {
+    const onSubmitted = vi.fn()
+    const { send, structuredTransport } = harness('codex', undefined, onSubmitted)
+    send('/permissions', [])
+    await vi.waitFor(() =>
+      expect(structuredTransport.onError).toHaveBeenCalledWith(
+        expect.stringContaining('not available in chat sessions')
+      )
+    )
+    expect(onSubmitted).not.toHaveBeenCalled()
+  })
+})
diff --git a/src/renderer/src/components/native-chat/use-native-chat-structured-composer-send.ts b/src/renderer/src/components/native-chat/use-native-chat-structured-composer-send.ts
index 25a824b86268..385df5bc19c3 100644
--- a/src/renderer/src/components/native-chat/use-native-chat-structured-composer-send.ts
+++ b/src/renderer/src/components/native-chat/use-native-chat-structured-composer-send.ts
@@ -3,7 +3,8 @@ import { emitNativeChatMessageSent } from '@/lib/native-chat-telemetry'
 import { reportStructuredSessionUserInput } from '@/lib/worker-terminal-takeover-report'
 import {
   isStructuredAgentSessionComposerCommand,
-  isStructuredAgentSessionGoalCommand
+  isStructuredAgentSessionGoalCommand,
+  structuredAgentSessionCommandChangesConversation
 } from '../../../../shared/structured-agent-session-composer'
 import type { AgentType } from '../../../../shared/agent-status-types'
 import { dispatchNativeChatStructuredComposerText } from './native-chat-structured-composer-dispatch'
@@ -63,14 +64,21 @@ export function useNativeChatStructuredComposerSend({
         structuredTransport.onError('Remove attachments before using a chat-session command.')
         return
       }
+      // A conversation command reveals at the press, not after its round trip; options move nothing.
+      if (hostCommand && structuredAgentSessionCommandChangesConversation(text)) {
+        structuredTransport.onSubmitted?.()
+      }
       const submitted = readNativeChatComposerDraft(draftScopeKey)
       void dispatchNativeChatStructuredComposerText(structuredTransport, text, attachments)
-        .then(({ accepted, error }) => {
+        .then(({ accepted, error, revealsTranscript }) => {
           structuredTransport.onError(error)
           if (!accepted) {
             return
           }
           emitNativeChatMessageSent({ agent, runtime: structuredTransport.runtime })
+          if (revealsTranscript) {
+            structuredTransport.onSubmitted?.()
+          }
           // A real user send is a takeover, exactly as typing into a worker's pane is. Only past
           // `accepted`, and only from this hook: the outbox dispatcher retries and would re-fire,
           // and orchestration's own pointer nudges never reach the composer at all.
diff --git a/src/renderer/src/components/native-chat/use-native-chat-transcript-scroll.test.tsx b/src/renderer/src/components/native-chat/use-native-chat-transcript-scroll.test.tsx
index 948b83c5dbb8..389f9e9373d6 100644
--- a/src/renderer/src/components/native-chat/use-native-chat-transcript-scroll.test.tsx
+++ b/src/renderer/src/components/native-chat/use-native-chat-transcript-scroll.test.tsx
@@ -3,17 +3,20 @@
 import { useRef } from 'react'
 import { cleanup, fireEvent, render } from '@testing-library/react'
 import { afterEach, describe, expect, it, vi } from 'vitest'
+import { useNativeChatReaderScrollInput } from './native-chat-reader-scroll-input'
 import { useNativeChatTranscriptScroll } from './use-native-chat-transcript-scroll'
 
 function TranscriptHarness({
   isVisible,
   restoreScrollOffset,
   scrollToEnd,
+  reconcileReaderScroll = vi.fn(),
   itemCount = 100
 }: {
   isVisible: boolean
   restoreScrollOffset: (offset: number) => void
   scrollToEnd: () => void
+  reconcileReaderScroll?: (isTakingOver: boolean) => void
   itemCount?: number
 }): React.JSX.Element {
   const scrollRef = useRef<HTMLDivElement>(null)
@@ -29,16 +32,102 @@ function TranscriptHarness({
     scrollToEnd,
     restoreScrollOffset,
     consumeProgrammaticScroll: () => false,
-    reconcileReaderScroll: vi.fn()
+    reconcileReaderScroll
+  })
+  const input = useNativeChatReaderScrollInput(scrollRef, {
+    onReaderScroll: () => {},
+    onLeaveEnd: transcript.readerLeavesEnd
   })
   return (
-    <div ref={scrollRef} data-testid="scroll" onScroll={transcript.onScroll}>
+    <div
+      {...input.scrollerProps}
+      ref={scrollRef}
+      data-testid="scroll"
+      onScroll={transcript.onScroll}
+    >
       <div ref={contentRef} />
     </div>
   )
 }
 
-afterEach(cleanup)
+afterEach(() => {
+  cleanup()
+  vi.restoreAllMocks()
+})
+
+it.each([0, 250, 251])(
+  'rebases a pending reader target after %i ms until its frame ends',
+  (elapsed) => {
+    let clock = 1000
+    vi.spyOn(performance, 'now').mockImplementation(() => clock)
+    const frames = new Map<number, FrameRequestCallback>()
+    let nextFrame = 0
+    vi.spyOn(window, 'requestAnimationFrame').mockImplementation((callback) => {
+      const id = ++nextFrame
+      frames.set(id, callback)
+      return id
+    })
+    vi.spyOn(window, 'cancelAnimationFrame').mockImplementation((id) => frames.delete(id))
+    let element: HTMLElement | null = null
+    let pendingFrame: number | null = null
+    let retainedTarget = 8204
+    const rebase = vi.fn((offset: number) => {
+      retainedTarget = offset
+    })
+    // The window adapter replaces targets only on takeover or while its frame is pending.
+    const reconcileReaderScroll = vi.fn((isTakingOver: boolean) => {
+      if (!element || (!isTakingOver && pendingFrame === null)) {
+        return
+      }
+      rebase(element.scrollTop)
+      if (pendingFrame === null) {
+        pendingFrame = window.requestAnimationFrame(() => {
+          pendingFrame = null
+        })
+      }
+    })
+    const view = render(
+      <TranscriptHarness
+        isVisible
+        restoreScrollOffset={vi.fn()}
+        scrollToEnd={vi.fn()}
+        reconcileReaderScroll={reconcileReaderScroll}
+      />
+    )
+    element = view.getByTestId('scroll')
+    Object.defineProperties(element, {
+      clientHeight: { configurable: true, value: 600 },
+      scrollHeight: { configurable: true, value: 8804 }
+    })
+    element.scrollTop = 8204
+    fireEvent.scroll(element)
+    expect(rebase).not.toHaveBeenCalled()
+    expect(frames.size).toBe(0)
+
+    fireEvent.wheel(element, { deltaY: -100 })
+    expect(rebase.mock.calls).toEqual([[8204]])
+    expect(frames.size).toBe(1)
+    clock += elapsed
+    element.scrollTop = 2000
+    fireEvent.scroll(element)
+    expect(retainedTarget).toBe(2000)
+    expect(rebase.mock.calls).toEqual([[8204], [2000]])
+    expect(frames.size).toBe(1)
+
+    for (const [id, callback] of frames) {
+      frames.delete(id)
+      callback(clock)
+    }
+    expect(pendingFrame).toBeNull()
+    element.scrollTop = 1800
+    fireEvent.scroll(element)
+    fireEvent.scroll(element)
+    expect(reconcileReaderScroll).toHaveBeenLastCalledWith(false)
+    expect(retainedTarget).toBe(2000)
+    expect(rebase.mock.calls).toEqual([[8204], [2000]])
+    expect(frames.size).toBe(0)
+  }
+)
 
 describe('native chat transcript visibility', () => {
   it('restores the last detached offset when a retained tab is revealed', () => {
@@ -68,6 +157,7 @@ describe('native chat transcript visibility', () => {
       }
     })
 
+    fireEvent.wheel(scrollElement, { deltaY: -100 })
     scrollTop = 320
     fireEvent.scroll(scrollElement)
     view.rerender(
@@ -116,6 +206,7 @@ describe('native chat transcript follow', () => {
       }
     })
 
+    fireEvent.wheel(scrollElement, { deltaY: -50 })
     scrollTop = 850
     fireEvent.scroll(scrollElement)
     scrollToEnd.mockClear()
@@ -130,4 +221,28 @@ describe('native chat transcript follow', () => {
 
     expect(scrollToEnd).toHaveBeenCalled()
   })
+
+  // A shrink clamps the offset; its scroll event can land after more output has grown the end.
+  it('keeps following when content shrinks under a reader at the end', () => {
+    let scrollTop = 900
+    let scrollHeight = 1_000
+    const scrollToEnd = vi.fn()
+    const props = { isVisible: true, restoreScrollOffset: vi.fn(), scrollToEnd }
+    const view = render(<TranscriptHarness {...props} />)
+    const scrollElement = view.getByTestId('scroll')
+    Object.defineProperties(scrollElement, {
+      clientHeight: { configurable: true, get: () => 100 },
+      scrollHeight: { configurable: true, get: () => scrollHeight },
+      scrollTop: { configurable: true, get: () => scrollTop, set: (value) => (scrollTop = value) }
+    })
+
+    scrollHeight = 700
+    scrollTop = 600
+    scrollHeight = 900
+    fireEvent.scroll(scrollElement)
+    scrollToEnd.mockClear()
+    view.rerender(<TranscriptHarness {...props} itemCount={101} />)
+
+    expect(scrollToEnd).toHaveBeenCalled()
+  })
 })
diff --git a/src/renderer/src/components/native-chat/use-native-chat-transcript-scroll.ts b/src/renderer/src/components/native-chat/use-native-chat-transcript-scroll.ts
index 6df6d3eb562e..e11ce8b058cf 100644
--- a/src/renderer/src/components/native-chat/use-native-chat-transcript-scroll.ts
+++ b/src/renderer/src/components/native-chat/use-native-chat-transcript-scroll.ts
@@ -8,9 +8,9 @@
 // being the same event.
 //
 // The offset belongs to the virtualizer — every pin goes through it, so a scroll
-// it is still reconciling is replaced rather than raced. Its public write adapter
-// marks every application offset; follow intent changes only on an unmarked
-// reader event, never from delayed geometry alone.
+// it is still reconciling is replaced rather than raced. Following stops only on a
+// reader gesture or a row jump, never on layout or an application write, and
+// resumes when the reader returns to the end.
 
 import {
   useCallback,
@@ -22,6 +22,8 @@ import {
 } from 'react'
 import {
   distanceFromBottom,
+  isNearBottom,
+  NATIVE_CHAT_FOLLOW_REARM_PX,
   nextFollowingEnd,
   shouldShowJumpToLatest,
   type ScrollGeometry
@@ -41,10 +43,15 @@ function hasMeasurableViewport(element: HTMLElement | null): element is HTMLElem
 
 export type NativeChatTranscriptScroll = {
   showJump: boolean
+  /** More than a viewport below the top of what is loaded. */
+  awayFromTop: boolean
   onScroll: UIEventHandler<HTMLDivElement>
   scrollToBottom: () => void
+  scrollToTop: () => void
   /** Align an element inside the transcript with the top of the viewport. */
   scrollMessageToTop: (element: HTMLElement) => void
+  /** A reader gesture left the end: the only thing besides a row jump that stops following. */
+  readerLeavesEnd: () => void
 }
 
 export function useNativeChatTranscriptScroll({
@@ -74,62 +81,79 @@ export function useNativeChatTranscriptScroll({
   reconcileReaderScroll: (isTakingOver: boolean) => void
 }): NativeChatTranscriptScroll {
   const [showJump, setShowJump] = useState(false)
+  const [awayFromTop, setAwayFromTop] = useState(false)
   const followingRef = useRef(true)
   const detachedScrollTopRef = useRef<number | null>(null)
   const isVisibleRef = useRef(isVisible)
   const previousIsVisibleRef = useRef(isVisible)
   const previousDistanceFromEndRef = useRef(Number.POSITIVE_INFINITY)
 
-  const syncScrollState = useCallback(
-    (event?: Event): ScrollGeometry | null => {
-      const element = scrollRef.current
-      if (!isVisibleRef.current || !hasMeasurableViewport(element)) {
-        return null
-      }
-      const geometry = geometryOf(element)
-      if (event) {
-        const wasFollowing = followingRef.current
-        const programmatic = consumeProgrammaticScroll(event)
-        const following = nextFollowingEnd({
-          following: followingRef.current,
-          programmatic,
-          geometry,
-          previousDistanceFromEnd: previousDistanceFromEndRef.current
-        })
-        followingRef.current = following
-        if (!programmatic) {
-          reconcileReaderScroll(wasFollowing && !following)
-        }
-      }
-      detachedScrollTopRef.current = followingRef.current ? null : geometry.scrollTop
-      setShowJump(shouldShowJumpToLatest(followingRef.current, geometry))
-      return geometry
-    },
-    [consumeProgrammaticScroll, reconcileReaderScroll, scrollRef]
-  )
+  const syncScrollState = useCallback((): ScrollGeometry | null => {
+    const element = scrollRef.current
+    if (!isVisibleRef.current || !hasMeasurableViewport(element)) {
+      return null
+    }
+    const geometry = geometryOf(element)
+    detachedScrollTopRef.current = followingRef.current ? null : geometry.scrollTop
+    setShowJump(shouldShowJumpToLatest(followingRef.current, geometry))
+    setAwayFromTop(geometry.scrollTop > geometry.clientHeight)
+    return geometry
+  }, [scrollRef])
+
+  const readerLeavesEnd = useCallback(() => {
+    followingRef.current = false
+    const element = scrollRef.current
+    if (element) {
+      previousDistanceFromEndRef.current = distanceFromBottom(geometryOf(element))
+    }
+    // Replace a pending virtualizer target before the browser applies the gesture.
+    reconcileReaderScroll(true)
+    syncScrollState()
+  }, [reconcileReaderScroll, scrollRef, syncScrollState])
 
   const onScroll = useCallback<UIEventHandler<HTMLDivElement>>(
     (event) => {
-      const geometry = syncScrollState(event.nativeEvent)
-      if (geometry) {
-        previousDistanceFromEndRef.current = distanceFromBottom(geometry)
+      const element = scrollRef.current
+      if (!isVisibleRef.current || !hasMeasurableViewport(element)) {
+        return
       }
+      const geometry = geometryOf(element)
+      followingRef.current = nextFollowingEnd({
+        following: followingRef.current,
+        programmatic: consumeProgrammaticScroll(event.nativeEvent),
+        geometry,
+        previousDistanceFromEnd: previousDistanceFromEndRef.current
+      })
+      reconcileReaderScroll(false)
+      previousDistanceFromEndRef.current = distanceFromBottom(geometry)
+      syncScrollState()
     },
-    [syncScrollState]
+    [consumeProgrammaticScroll, reconcileReaderScroll, scrollRef, syncScrollState]
   )
 
   const scrollToEndWhenMeasurable = useCallback(() => {
-    if (hasMeasurableViewport(scrollRef.current)) {
+    if (isVisibleRef.current && hasMeasurableViewport(scrollRef.current)) {
       scrollToEnd()
     }
   }, [scrollRef, scrollToEnd])
 
   const scrollToBottom = useCallback(() => {
+    // A hidden pane is not where the reader is; it keeps its position for their return.
+    if (!isVisibleRef.current) {
+      return
+    }
     followingRef.current = true
     scrollToEndWhenMeasurable()
     setShowJump(false)
   }, [scrollToEndWhenMeasurable])
 
+  const scrollToTop = useCallback(() => {
+    followingRef.current = false
+    // Also where a hidden pane lands once revealed, since the write below waits for layout.
+    detachedScrollTopRef.current = 0
+    restoreScrollOffset(0)
+  }, [restoreScrollOffset])
+
   const scrollMessageToTop = useCallback(
     (element: HTMLElement) => {
       followingRef.current = false
@@ -146,9 +170,17 @@ export function useNativeChatTranscriptScroll({
       return
     }
     if (!followingRef.current) {
-      if (revealed && detachedScrollTopRef.current !== null) {
-        restoreScrollOffset(detachedScrollTopRef.current)
+      if (revealed) {
+        if (detachedScrollTopRef.current !== null) {
+          restoreScrollOffset(detachedScrollTopRef.current)
+        }
+        // What changed while hidden may have brought the end to the restored offset.
+        const element = scrollRef.current
+        if (hasMeasurableViewport(element)) {
+          followingRef.current = isNearBottom(geometryOf(element), NATIVE_CHAT_FOLLOW_REARM_PX)
+        }
       }
+      syncScrollState()
       return
     }
     scrollToEndWhenMeasurable()
@@ -157,8 +189,10 @@ export function useNativeChatTranscriptScroll({
     itemCount,
     isWorking,
     restoreScrollOffset,
+    scrollRef,
     showsTailRow,
-    scrollToEndWhenMeasurable
+    scrollToEndWhenMeasurable,
+    syncScrollState
   ])
 
   useEffect(() => {
@@ -167,11 +201,14 @@ export function useNativeChatTranscriptScroll({
       return
     }
     const observer = new ResizeObserver(() => {
+      if (!isVisibleRef.current) {
+        return
+      }
+      // Growth, an opened row included, keeps a following reader at the end.
       if (followingRef.current) {
         scrollToEndWhenMeasurable()
-      } else {
-        syncScrollState()
       }
+      syncScrollState()
     })
     // Observe the growing content, not just the fixed-height viewport, so an
     // in-place streaming growth is seen; also watch the viewport for reflows.
@@ -182,5 +219,13 @@ export function useNativeChatTranscriptScroll({
     return () => observer.disconnect()
   }, [contentRef, scrollRef, scrollToEndWhenMeasurable, syncScrollState])
 
-  return { showJump, onScroll, scrollToBottom, scrollMessageToTop }
+  return {
+    showJump,
+    awayFromTop,
+    onScroll,
+    scrollToBottom,
+    scrollToTop,
+    scrollMessageToTop,
+    readerLeavesEnd
+  }
 }
diff --git a/src/renderer/src/components/native-chat/use-native-chat-transcript-window.ts b/src/renderer/src/components/native-chat/use-native-chat-transcript-window.ts
index ced338db05d7..ea4cafa28e35 100644
--- a/src/renderer/src/components/native-chat/use-native-chat-transcript-window.ts
+++ b/src/renderer/src/components/native-chat/use-native-chat-transcript-window.ts
@@ -9,6 +9,7 @@
 import { useCallback, useEffect, useLayoutEffect, useMemo, useRef, useState } from 'react'
 import { elementScroll, useVirtualizer, type VirtualItem } from '@tanstack/react-virtual'
 import { createProgrammaticScrollMarks } from '@/hooks/programmatic-scroll-marks'
+import { usePrefersReducedMotion } from '@/hooks/usePrefersReducedMotion'
 import { NATIVE_CHAT_ROW_GAP_PX } from './native-chat-row-height-estimate'
 import { nativeChatPinnedRowIndexes, nativeChatTranscriptRange } from './native-chat-pinned-rows'
 import { nativeChatSlotKey, type NativeChatTranscriptSlot } from './native-chat-transcript-slots'
@@ -93,6 +94,7 @@ export function useNativeChatTranscriptWindow({
   const readerTakeoverFrameRef = useRef<number | null>(null)
   const previousMeasurementKeysRef = useRef<ReadonlySet<string> | null>(null)
   const retiredMeasurementCountRef = useRef(0)
+  const alignBehavior = usePrefersReducedMotion() ? 'auto' : 'smooth'
   const pinned = useMemo(
     () => nativeChatPinnedRowIndexes({ count: slots.length, revealIndex }),
     [slots.length, revealIndex]
@@ -256,17 +258,17 @@ export function useNativeChatTranscriptWindow({
       // Through the virtualizer so a scroll it is still reconciling — the jump
       // that mounted this row in the first place — is replaced rather than raced.
       if (virtualizer.scrollElement) {
-        virtualizer.scrollToOffset(top, { align: 'start', behavior: 'smooth' })
+        virtualizer.scrollToOffset(top, { align: 'start', behavior: alignBehavior })
       } else {
         const max = Math.max(0, container.scrollHeight - container.clientHeight)
         const landing = Math.max(0, Math.min(top, max))
         if (container.scrollTop !== landing) {
           programmaticScrollMarks.mark(landing)
         }
-        container.scrollTo({ top, behavior: 'smooth' })
+        container.scrollTo({ top, behavior: alignBehavior })
       }
     },
-    [finishReaderTakeover, programmaticScrollMarks, scrollRef, virtualizer]
+    [alignBehavior, finishReaderTakeover, programmaticScrollMarks, scrollRef, virtualizer]
   )
 
   const scrollToEnd = useCallback(() => {
diff --git a/src/renderer/src/components/native-chat/use-structured-agent-session-command-send-gate.test.tsx b/src/renderer/src/components/native-chat/use-structured-agent-session-command-send-gate.test.tsx
index 1c5044265a16..2a9998a7b9a6 100644
--- a/src/renderer/src/components/native-chat/use-structured-agent-session-command-send-gate.test.tsx
+++ b/src/renderer/src/components/native-chat/use-structured-agent-session-command-send-gate.test.tsx
@@ -59,7 +59,7 @@ beforeEach(() => {
 })
 
 /** Starts `/compact` and leaves its reply outstanding, then sends a message. */
-function sendDuringCommand(): boolean {
+function sendDuringCommand(): boolean | 'queued' {
   mocks.call.mockImplementation((_target: unknown, method: string) =>
     method === 'agentSession.conversationCommand' ? new Promise(() => {}) : Promise.resolve(null)
   )
diff --git a/src/renderer/src/components/native-chat/use-structured-agent-session-outbox.queue-delivery.test.tsx b/src/renderer/src/components/native-chat/use-structured-agent-session-outbox.queue-delivery.test.tsx
index 69f802b060de..5e4ea8d29e6f 100644
--- a/src/renderer/src/components/native-chat/use-structured-agent-session-outbox.queue-delivery.test.tsx
+++ b/src/renderer/src/components/native-chat/use-structured-agent-session-outbox.queue-delivery.test.tsx
@@ -473,3 +473,32 @@ async function attemptedQueueSend() {
   mocks.call.mockImplementation(() => new Promise(() => {}))
   return view
 }
+
+// The composer moves the reader only for a message the transcript draws as a bubble.
+it.each([
+  ['a text follow-up while the agent works', QUEUEING, true, [], 'queued'],
+  ['the same follow-up when the agent is idle', QUEUEING, false, [], true],
+  ['with the queue setting off', { capability: 'supported', enabled: false }, true, [], true],
+  ['an image, which never queues', QUEUEING, true, [{ path: '/a.png', previewUri: '/a.png' }], true]
+] as const)(
+  'answers whether %s waits as a queued card',
+  (_case, queueDelivery, isWorking, images, admission) => {
+    mocks.call.mockImplementation(() => new Promise(() => {}))
+    const { result } = renderHook(() =>
+      useStructuredAgentSessionOutbox({
+        journalItems: NO_JOURNAL_ITEMS,
+        sessionId: 'session-1',
+        target: LOCAL_TARGET,
+        fence: 1,
+        submissions: [],
+        queueDelivery,
+        isWorking
+      })
+    )
+    let sent: boolean | 'queued' = false
+    act(() => {
+      sent = result.current.send('follow up', images)
+    })
+    expect(sent).toBe(admission)
+  }
+)
diff --git a/src/renderer/src/components/native-chat/use-structured-agent-session-outbox.ts b/src/renderer/src/components/native-chat/use-structured-agent-session-outbox.ts
index 2a70730b3fce..188afe84590e 100644
--- a/src/renderer/src/components/native-chat/use-structured-agent-session-outbox.ts
+++ b/src/renderer/src/components/native-chat/use-structured-agent-session-outbox.ts
@@ -51,6 +51,7 @@ import {
 import { retryStructuredAgentSessionOutboxEntry } from './structured-agent-session-outbox-retry'
 import { useStructuredAgentSessionOutboxFailedHere } from './use-structured-agent-session-outbox-failed-here'
 import { agentSessionWriteNoticeText } from './agent-session-write-notice-text'
+import { outboxOutsideQueuedCards } from './structured-agent-session-queued-cards'
 
 const NO_QUEUE_DELIVERY: StructuredAgentSessionQueueDelivery = {
   capability: 'unsupported',
@@ -77,12 +78,15 @@ export function useStructuredAgentSessionOutbox(args: {
    *  its entry here under the draft's own id; once the host visibly holds the draft, the
    *  entry retires so the same text can never come back twice. */
   queuedMessageIds?: readonly string[]
+  /** With the queue delivery, whether a new send waits as a queued card. */
+  isWorking?: boolean
   /** The chat reads Stopping: a send made now is marked as made while stopping. */
   stopping?: boolean
 }) {
   const {
     composerScopeKey,
     fence,
+    isWorking = false,
     journalItems,
     queueDelivery = NO_QUEUE_DELIVERY,
     queuedMessageIds,
@@ -268,8 +272,12 @@ export function useStructuredAgentSessionOutbox(args: {
     owner
   })
 
+  /** Whether the message was admitted; 'queued' when it waits as a queued card, not a bubble. */
   const send = useCallback(
-    (text: string, attachments: readonly { path: string; previewUri: string }[] = []): boolean => {
+    (
+      text: string,
+      attachments: readonly { path: string; previewUri: string }[] = []
+    ): boolean | 'queued' => {
       if (!text.trim() && attachments.length === 0) {
         return false
       }
@@ -287,9 +295,18 @@ export function useStructuredAgentSessionOutbox(args: {
         return false
       }
       setError(null)
-      return true
+      // The same projection that draws the transcript decides it.
+      const current = getStructuredAgentSessionOutbox(sessionId)
+      const admitted = current.at(-1)
+      const shown = outboxOutsideQueuedCards(
+        current,
+        queuedMessageIds ?? [],
+        isWorking,
+        queueDelivery
+      )
+      return admitted && !shown.includes(admitted) ? 'queued' : true
     },
-    [sentWhileStopping, sessionId]
+    [isWorking, queueDelivery, queuedMessageIds, sentWhileStopping, sessionId]
   )
 
   const { withdrawUnsent } = useStructuredAgentSessionOutboxOwnership({
diff --git a/src/renderer/src/components/native-chat/use-structured-agent-session-queued-messages.resume.test.tsx b/src/renderer/src/components/native-chat/use-structured-agent-session-queued-messages.resume.test.tsx
index fa4ae91b1eae..6fb17f53122d 100644
--- a/src/renderer/src/components/native-chat/use-structured-agent-session-queued-messages.resume.test.tsx
+++ b/src/renderer/src/components/native-chat/use-structured-agent-session-queued-messages.resume.test.tsx
@@ -3,7 +3,8 @@
 // Resume lifts the queue's pause through its own RPC, over the same fenced write every card action
 // uses: a refusal or a failure is one toast, and the Resume button is the way to try again.
 
-import { act, renderHook } from '@testing-library/react'
+import { useCallback, useRef } from 'react'
+import { act, cleanup, renderHook } from '@testing-library/react'
 import { afterEach, describe, expect, it, vi } from 'vitest'
 
 type ResumeParams = { envelope: { clientOperationId: string } }
@@ -20,29 +21,44 @@ vi.mock('@/runtime/structured-agent-session-client', () => ({
 
 import { useStructuredAgentSessionMutate } from './use-structured-agent-session-mutate'
 import { useStructuredAgentSessionQueuedMessages } from './use-structured-agent-session-queued-messages'
+import { useStructuredNativeChatSubmitReveal } from './use-structured-native-chat-submit-reveal'
+import { useNativeChatMessageListHandle } from './use-native-chat-reveal-latest'
+import { useNativeChatTranscriptScroll } from './use-native-chat-transcript-scroll'
 
-function renderController() {
-  const stateRef = { current: { fence: 1 } }
-  return renderHook(() => {
-    const { mutate } = useStructuredAgentSessionMutate({
-      sessionId: 'session-1',
-      target: { kind: 'local' },
-      stateRef
-    })
-    return useStructuredAgentSessionQueuedMessages({
-      enabled: true,
-      queuedMessages: [],
-      queuePause: { reason: 'stopped' },
-      submissions: [],
-      hasPendingPrompt: false,
-      composerScopeKey: undefined,
-      mutate
-    })
+function resumedResult(resumed = true) {
+  return {
+    ok: true,
+    replayed: false,
+    fence: 1,
+    cursor: { epoch: 'epoch-1', sequence: 1 },
+    value: { resumed }
+  }
+}
+
+function useQueue(sessionId = 'session-1', fence: number | null = 1) {
+  const { mutate } = useStructuredAgentSessionMutate({
+    sessionId,
+    target: { kind: 'local' },
+    stateRef: { current: { fence } }
+  })
+  return useStructuredAgentSessionQueuedMessages({
+    enabled: true,
+    queuedMessages: [],
+    queuePause: { reason: 'stopped' },
+    submissions: [],
+    hasPendingPrompt: false,
+    composerScopeKey: undefined,
+    mutate
   })
 }
 
+function renderController() {
+  return renderHook(() => useQueue())
+}
+
 afterEach(() => {
-  vi.clearAllMocks()
+  cleanup()
+  vi.resetAllMocks()
 })
 
 describe('Resume on a paused queue', () => {
@@ -56,7 +72,7 @@ describe('Resume on a paused queue', () => {
     })
     const { result } = renderController()
     expect(result.current.pause).toEqual({ reason: 'stopped' })
-    await act(() => result.current.resume())
+    await act(async () => expect(await result.current.resume()).toBe(true))
     expect(mocks.call).toHaveBeenCalledTimes(1)
     const [, method, params] = mocks.call.mock.calls[0] ?? []
     expect(method).toBe('agentSession.queuedMessagesResume')
@@ -71,9 +87,9 @@ describe('Resume on a paused queue', () => {
     })
     mocks.call.mockRejectedValueOnce(new Error('socket closed'))
     const { result } = renderController()
-    await act(() => result.current.resume())
+    await act(async () => expect(await result.current.resume()).toBe(false))
     expect(mocks.toastError).toHaveBeenCalledTimes(1)
-    await act(() => result.current.resume())
+    await act(async () => expect(await result.current.resume()).toBe(false))
     expect(mocks.toastError).toHaveBeenCalledTimes(2)
   })
 
@@ -105,11 +121,13 @@ describe('Resume on a paused queue', () => {
     const answer = Promise.withResolvers<unknown>()
     mocks.call.mockReturnValueOnce(answer.promise)
     const { result } = renderController()
-    let pending: Promise<void> = Promise.resolve()
+    let pending = Promise.resolve(false)
     act(() => {
       pending = result.current.resume()
     })
     expect(result.current.resuming).toBe(true)
+    await act(async () => expect(await result.current.resume()).toBe(false))
+    expect(mocks.call).toHaveBeenCalledTimes(1)
     await act(async () => {
       answer.resolve({
         ok: true,
@@ -118,8 +136,132 @@ describe('Resume on a paused queue', () => {
         cursor: { epoch: 'epoch-1', sequence: 1 },
         value: { resumed: true }
       })
-      await pending
+      expect(await pending).toBe(true)
     })
     expect(result.current.resuming).toBe(false)
   })
 })
+
+function renderRevealingController(sessionId = 'session-1', fence: number | null = 1) {
+  return renderHook(
+    ({ isVisible }) => {
+      const queue = useQueue(sessionId, fence)
+      const submits = useStructuredNativeChatSubmitReveal(
+        { queuedMessages: queue, respond: async () => null, retry: vi.fn() },
+        vi.fn()
+      )
+      const scrollRef = useRef(document.createElement('div'))
+      Object.defineProperties(scrollRef.current, {
+        clientHeight: { configurable: true, value: 500 },
+        scrollHeight: { configurable: true, value: 2000 }
+      })
+      const contentRef = useRef<HTMLDivElement | null>(null)
+      const scrollToEnd = useRef(vi.fn()).current
+      const restoreScrollOffset = useCallback((offset: number) => {
+        scrollRef.current.scrollTop = offset
+      }, [])
+      const scroll = useNativeChatTranscriptScroll({
+        scrollRef,
+        contentRef,
+        itemCount: 10,
+        isWorking: false,
+        showsTailRow: false,
+        isVisible,
+        alignToViewportTop: vi.fn(),
+        scrollToEnd,
+        restoreScrollOffset,
+        consumeProgrammaticScroll: () => false,
+        reconcileReaderScroll: vi.fn()
+      })
+      useNativeChatMessageListHandle(submits.messageListRef, scroll.scrollToBottom)
+      return { submits, scroll, scrollToEnd }
+    },
+    { initialProps: { isVisible: true } }
+  )
+}
+
+function startResume(hook: ReturnType<typeof renderRevealingController>) {
+  act(() => hook.result.current.scroll.readerLeavesEnd())
+  hook.result.current.scrollToEnd.mockClear()
+  let pending = Promise.resolve(false)
+  act(() => {
+    pending = hook.result.current.submits.queuedMessages.resume()
+  })
+  expect(hook.result.current.scrollToEnd).not.toHaveBeenCalled()
+  return pending
+}
+
+describe('Resume transcript navigation through the real mutation and queue controllers', () => {
+  it.each(['refused', 'failed', 'noop', 'replayed', 'null'] as const)(
+    'does not reveal for a %s result',
+    async (outcome) => {
+      if (outcome === 'failed') {
+        mocks.call.mockRejectedValueOnce(new Error('socket closed'))
+      } else if (outcome === 'refused') {
+        mocks.call.mockResolvedValueOnce({
+          ok: false,
+          refusal: { code: 'agent_session_conflict', message: 'The session moved on.' }
+        })
+      } else {
+        mocks.call.mockResolvedValueOnce({
+          ...resumedResult(false),
+          replayed: outcome === 'replayed'
+        })
+      }
+      const hook = renderRevealingController('session-1', outcome === 'null' ? null : 1)
+      const pending = startResume(hook)
+      await act(async () => expect(await pending).toBe(false))
+      expect(hook.result.current.scrollToEnd).not.toHaveBeenCalled()
+      expect(hook.result.current.submits.queuedMessages.resuming).toBe(false)
+      expect(mocks.toastError).toHaveBeenCalledTimes(
+        outcome === 'failed' || outcome === 'refused' ? 1 : 0
+      )
+    }
+  )
+
+  it('reveals only the pane that pressed Resume, after success, and ignores a duplicate press', async () => {
+    const answer = Promise.withResolvers<unknown>()
+    mocks.call.mockReturnValueOnce(answer.promise)
+    const origin = renderRevealingController()
+    const other = renderRevealingController()
+    other.result.current.scrollToEnd.mockClear()
+    const pending = startResume(origin)
+    await act(async () => {
+      expect(await origin.result.current.submits.queuedMessages.resume()).toBe(false)
+    })
+    expect(origin.result.current.scrollToEnd).not.toHaveBeenCalled()
+    expect(mocks.call).toHaveBeenCalledTimes(1)
+    await act(async () => {
+      answer.resolve(resumedResult())
+      expect(await pending).toBe(true)
+    })
+    expect(origin.result.current.scrollToEnd).toHaveBeenCalledTimes(1)
+    expect(other.result.current.scrollToEnd).not.toHaveBeenCalled()
+  })
+
+  // Lifting the pause is slow and the reader can switch away meanwhile; that pane stays put.
+  it.each(['hide', 'unmount'] as const)(
+    'does not reveal a pane that is %s when Resume succeeds',
+    async (action) => {
+      const answer = Promise.withResolvers<unknown>()
+      mocks.call.mockReturnValueOnce(answer.promise)
+      const origin = renderRevealingController()
+      const scrollToEnd = origin.result.current.scrollToEnd
+      const pending = startResume(origin)
+      if (action === 'hide') {
+        origin.rerender({ isVisible: false })
+      } else {
+        origin.unmount()
+      }
+      await act(async () => {
+        answer.resolve(resumedResult())
+        await pending
+      })
+      if (action === 'hide') {
+        // Shown again, it is where the reader left it.
+        origin.rerender({ isVisible: true })
+      }
+      expect(scrollToEnd).not.toHaveBeenCalled()
+    }
+  )
+})
diff --git a/src/renderer/src/components/native-chat/use-structured-agent-session-queued-messages.ts b/src/renderer/src/components/native-chat/use-structured-agent-session-queued-messages.ts
index 748487986a3e..5b70e068fe05 100644
--- a/src/renderer/src/components/native-chat/use-structured-agent-session-queued-messages.ts
+++ b/src/renderer/src/components/native-chat/use-structured-agent-session-queued-messages.ts
@@ -32,8 +32,8 @@ export type StructuredAgentSessionQueuedMessagesController = {
   /** Why the whole queue sends nothing on its own; null when it drains. Shown only with cards.
    *  A string reason: a newer host may name one this build does not know. */
   pause: { reason: string } | null
-  /** Lift the queue's pause; a failure is a toast, and the Resume button is the retry. */
-  resume: () => Promise<void>
+  /** Whether the host lifted the pause; a failure is a toast, and Resume is the retry. */
+  resume: () => Promise<boolean>
   /** A Resume is in flight. */
   resuming: boolean
   /** Send-now into the running turn; the transcript shows it at delivery position. */
@@ -156,18 +156,19 @@ export function useStructuredAgentSessionQueuedMessages(args: {
 
   const resumingRef = useRef(false)
   const [resuming, setResuming] = useState(false)
-  const resume = useCallback(async (): Promise<void> => {
+  const resume = useCallback(async (): Promise<boolean> => {
     if (resumingRef.current) {
-      return
+      return false
     }
     resumingRef.current = true
     setResuming(true)
     try {
-      await mutate<AgentSessionQueuedMessagesResumeResult>(
+      const result = await mutate<AgentSessionQueuedMessagesResumeResult>(
         'agentSession.queuedMessagesResume',
         'agentSession.queuedMessagesResume',
         {}
       )
+      return result?.resumed === true
     } finally {
       resumingRef.current = false
       setResuming(false)
diff --git a/src/renderer/src/components/native-chat/use-structured-agent-session.ts b/src/renderer/src/components/native-chat/use-structured-agent-session.ts
index 6b9f13c61324..f685b5041e20 100644
--- a/src/renderer/src/components/native-chat/use-structured-agent-session.ts
+++ b/src/renderer/src/components/native-chat/use-structured-agent-session.ts
@@ -148,6 +148,7 @@ export function useStructuredAgentSession(args: {
     composerScopeKey,
     queueDelivery,
     queuedMessageIds,
+    isWorking: transportState.isWorking,
     stopping: stopControl.stopping
   })
 
diff --git a/src/renderer/src/components/native-chat/use-structured-native-chat-submit-reveal.test.ts b/src/renderer/src/components/native-chat/use-structured-native-chat-submit-reveal.test.ts
new file mode 100644
index 000000000000..fa169df9f85d
--- /dev/null
+++ b/src/renderer/src/components/native-chat/use-structured-native-chat-submit-reveal.test.ts
@@ -0,0 +1,36 @@
+// @vitest-environment happy-dom
+import { act, renderHook } from '@testing-library/react'
+import { expect, it, vi } from 'vitest'
+import { useStructuredNativeChatSubmitReveal } from './use-structured-native-chat-submit-reveal'
+
+it('reveals before Retry, but waits for a successful queue Resume', async () => {
+  const order: string[] = []
+  const controller = {
+    respond: vi.fn(async () => null),
+    retry: vi.fn(() => order.push('retry')),
+    queuedMessages: {
+      queueCapable: true,
+      cards: [],
+      pause: null,
+      resuming: false,
+      resume: vi.fn(async () => {
+        order.push('resume')
+        return true
+      }),
+      steer: vi.fn(async () => {}),
+      remove: vi.fn(async () => {}),
+      edit: vi.fn(async () => {}),
+      steerNewest: vi.fn(() => false)
+    }
+  }
+  const retryLaunch = (): number => order.push('launch')
+  const { result } = renderHook(() => useStructuredNativeChatSubmitReveal(controller, retryLaunch))
+  result.current.messageListRef.current = { revealLatest: () => order.push('reveal') }
+
+  act(() => result.current.retryDelivery('client-1'))
+  act(() => result.current.retryLaunch())
+  await act(() => result.current.queuedMessages.resume())
+
+  expect(controller.retry).toHaveBeenCalledWith('client-1')
+  expect(order).toEqual(['reveal', 'retry', 'reveal', 'launch', 'resume', 'reveal'])
+})
diff --git a/src/renderer/src/components/native-chat/use-structured-native-chat-submit-reveal.ts b/src/renderer/src/components/native-chat/use-structured-native-chat-submit-reveal.ts
new file mode 100644
index 000000000000..6b93ad94c51d
--- /dev/null
+++ b/src/renderer/src/components/native-chat/use-structured-native-chat-submit-reveal.ts
@@ -0,0 +1,85 @@
+// Local actions reveal this pane at the press. Resume reveals once the host lifts the pause;
+// host delivery, queued drafts and Stop never move the reader.
+
+import { useCallback, useEffect, useMemo, useRef } from 'react'
+import {
+  useNativeChatRevealLatest,
+  type NativeChatMessageListHandle
+} from './use-native-chat-reveal-latest'
+import type { useStructuredAgentSession } from './use-structured-agent-session'
+import type { StructuredAgentSessionQueuedMessagesController } from './use-structured-agent-session-queued-messages'
+
+type StructuredController = ReturnType<typeof useStructuredAgentSession>
+
+export function useStructuredNativeChatSubmitReveal(
+  controller: Pick<StructuredController, 'respond' | 'retry' | 'queuedMessages'>,
+  /** Relaunches a start that failed; the messages parked behind it go out on publish. */
+  retryLaunch: () => void
+): {
+  messageListRef: React.RefObject<NativeChatMessageListHandle | null>
+  /** For the composer, which reveals as it sends. */
+  revealLatest: () => void
+  retryDelivery: (clientMessageId: string) => void
+  retryLaunch: () => void
+  respond: StructuredController['respond']
+  queuedMessages: StructuredAgentSessionQueuedMessagesController
+} {
+  const { messageListRef, revealLatest } = useNativeChatRevealLatest()
+  const { respond, queuedMessages } = controller
+  // Read at click time, so the notices stay put while the outbox's Retry is rebuilt each render.
+  const retryRef = useRef(controller.retry)
+  useEffect(() => {
+    retryRef.current = controller.retry
+  })
+  const retryDelivery = useCallback(
+    (clientMessageId: string) => {
+      revealLatest()
+      retryRef.current(clientMessageId)
+    },
+    [revealLatest]
+  )
+  const revealingRetryLaunch = useCallback(() => {
+    revealLatest()
+    retryLaunch()
+  }, [retryLaunch, revealLatest])
+  const revealingRespond = useCallback<StructuredController['respond']>(
+    (...args) => {
+      revealLatest()
+      return respond(...args)
+    },
+    [respond, revealLatest]
+  )
+  const revealingQueue = useMemo<StructuredAgentSessionQueuedMessagesController>(
+    () => ({
+      ...queuedMessages,
+      steer: (messageId) => {
+        revealLatest()
+        return queuedMessages.steer(messageId)
+      },
+      // Resume can be refused or find nothing paused, so it reveals only once the host lifts it.
+      resume: async () => {
+        const resumed = await queuedMessages.resume()
+        if (resumed) {
+          revealLatest()
+        }
+        return resumed
+      },
+      steerNewest: () => {
+        const steered = queuedMessages.steerNewest()
+        if (steered) {
+          revealLatest()
+        }
+        return steered
+      }
+    }),
+    [queuedMessages, revealLatest]
+  )
+  return {
+    messageListRef,
+    revealLatest,
+    retryDelivery,
+    retryLaunch: revealingRetryLaunch,
+    respond: revealingRespond,
+    queuedMessages: revealingQueue
+  }
+}
diff --git a/src/renderer/src/i18n/locales/en.json b/src/renderer/src/i18n/locales/en.json
index 414d24797116..d6bb49d1fd7d 100644
--- a/src/renderer/src/i18n/locales/en.json
+++ b/src/renderer/src/i18n/locales/en.json
@@ -18151,6 +18151,8 @@
         "groupTasks": "Tasks"
       },
       "jumpToLatest": "Jump to latest",
+      "jumpToTop": "Jump to top",
+      "transcriptLabel": "Conversation",
       "toggle": {
         "showTerminal": "Show terminal",
         "showChat": "Show chat view"
diff --git a/src/renderer/src/i18n/locales/es.json b/src/renderer/src/i18n/locales/es.json
index 30ad9367ae69..455cb67e09b9 100644
--- a/src/renderer/src/i18n/locales/es.json
+++ b/src/renderer/src/i18n/locales/es.json
@@ -17842,6 +17842,8 @@
         "toggleDetails": "Alternar detalles del turno"
       },
       "jumpToLatest": "Saltar a lo último",
+      "jumpToTop": "Ir al principio",
+      "transcriptLabel": "Conversación",
       "toggle": {
         "showTerminal": "Mostrar terminal",
         "showChat": "Mostrar vista de chat"
diff --git a/src/renderer/src/i18n/locales/fr.json b/src/renderer/src/i18n/locales/fr.json
index 18780b14c81f..7988599b8afe 100644
--- a/src/renderer/src/i18n/locales/fr.json
+++ b/src/renderer/src/i18n/locales/fr.json
@@ -17941,6 +17941,8 @@
         "toggleDetails": "Basculer les détails du tour"
       },
       "jumpToLatest": "Aller au dernier message",
+      "jumpToTop": "Remonter en haut",
+      "transcriptLabel": "Conversation",
       "toggle": {
         "showTerminal": "Afficher le terminal",
         "showChat": "Afficher la vue chat"
diff --git a/src/renderer/src/i18n/locales/ja.json b/src/renderer/src/i18n/locales/ja.json
index 3ba56e7d2f1b..3ea2cb014889 100644
--- a/src/renderer/src/i18n/locales/ja.json
+++ b/src/renderer/src/i18n/locales/ja.json
@@ -17877,6 +17877,8 @@
         "toggleDetails": "ターンの詳細を切り替えます"
       },
       "jumpToLatest": "最新にジャンプ",
+      "jumpToTop": "先頭へジャンプ",
+      "transcriptLabel": "会話",
       "toggle": {
         "showTerminal": "ターミナルを表示",
         "showChat": "チャットビューを表示"
diff --git a/src/renderer/src/i18n/locales/ko.json b/src/renderer/src/i18n/locales/ko.json
index 6a7fdd244c7c..536d957376fa 100644
--- a/src/renderer/src/i18n/locales/ko.json
+++ b/src/renderer/src/i18n/locales/ko.json
@@ -17877,6 +17877,8 @@
         "toggleDetails": "턴 세부정보 전환"
       },
       "jumpToLatest": "최신으로 이동",
+      "jumpToTop": "맨 위로 이동",
+      "transcriptLabel": "대화",
       "toggle": {
         "showTerminal": "terminal 표시",
         "showChat": "채팅 보기 표시"
diff --git a/src/renderer/src/i18n/locales/zh.json b/src/renderer/src/i18n/locales/zh.json
index eeaf83edd004..b7f462842d10 100644
--- a/src/renderer/src/i18n/locales/zh.json
+++ b/src/renderer/src/i18n/locales/zh.json
@@ -17842,6 +17842,8 @@
         "toggleDetails": "切换回合详情"
       },
       "jumpToLatest": "跳到最新消息",
+      "jumpToTop": "跳转到顶部",
+      "transcriptLabel": "对话",
       "toggle": {
         "showTerminal": "显示终端",
         "showChat": "显示聊天视图"
diff --git a/src/shared/structured-agent-session-composer.ts b/src/shared/structured-agent-session-composer.ts
index 9b60920ac6bf..0673d62dd26b 100644
--- a/src/shared/structured-agent-session-composer.ts
+++ b/src/shared/structured-agent-session-composer.ts
@@ -110,6 +110,16 @@ export function isStructuredAgentSessionGoalCommand(text: string): boolean {
   return commandParts(text)?.name === 'goal'
 }
 
+/** `/clear`, `/compact` and `/goal …` change the conversation; option and picker commands do not. */
+export function structuredAgentSessionCommandChangesConversation(text: string): boolean {
+  const command = commandParts(text)
+  return (
+    command?.name === 'clear' ||
+    command?.name === 'compact' ||
+    (command?.name === 'goal' && command.argument !== '')
+  )
+}
+
 /** `/goal` with nothing after it: an entrance to goal mode, not an objective. */
 export function isBareStructuredAgentSessionGoalCommand(text: string): boolean {
   const command = commandParts(text)