From bc4291d670924bef36313614283523ee0fd25fb0 Mon Sep 17 00:00:00 2001
From: Kelvin Amoaba <97001695+AmoabaKelvin@users.noreply.github.com>
Date: Fri, 2 Oct 2026 04:09:34 +0000
Subject: [PATCH 01/14] fix(native-chat): sending brings the latest into view,
 with visible jumps to latest and top

Sending while scrolled up left the reader parked in old history, and the way back was a faint button. A send now resumes following, opening a row to read it stops following until it is closed, and Jump to latest and Jump to top sit above the composer. Refs #23797.
---
 .../native-chat/NativeChatComposer.tsx        |   4 +
 .../NativeChatJumpControls.test.tsx           |  67 +++
 .../native-chat/NativeChatJumpControls.tsx    |  99 ++++
 ...eChatMessageList.growth-windowing.test.tsx |   3 +-
 ...MessageList.interrupted-turn-fold.test.tsx |   3 +-
 ...essageList.message-rail-windowing.test.tsx |   3 +-
 ...tiveChatMessageList.older-history.test.tsx |   3 +-
 ...atMessageList.provider-retry-runs.test.tsx |   3 +-
 ...ChatMessageList.queued-turn-order.test.tsx |   3 +-
 ...ChatMessageList.rail-history-jump.test.tsx |  76 ++-
 ...ChatMessageList.reader-navigation.test.tsx | 447 ++++++++++++++++++
 ...hatMessageList.stream-render.perf.test.tsx |   3 +-
 ...ChatMessageList.subagent-sections.test.tsx |   3 +-
 ...eChatMessageList.task-list-frames.test.tsx |   3 +-
 .../NativeChatMessageList.test.tsx            |   3 +-
 ...eChatMessageList.tool-stream-cost.test.tsx |   3 +-
 .../native-chat/NativeChatMessageList.tsx     |  66 +--
 .../NativeChatMessageList.turn-fold.test.tsx  |   3 +-
 ...ativeChatMessageList.turn-history.test.tsx |   3 +-
 ...iveChatMessageList.turn-indicator.test.tsx |   3 +-
 ...veChatMessageList.turn-membership.test.tsx |   3 +-
 ...NativeChatMessageList.turn-timing.test.tsx |   3 +-
 ...iveChatMessageList.unsent-message.test.tsx |   3 +-
 .../NativeChatMessageList.windowing.test.tsx  |   3 +-
 ...iveChatResolvedView.reveal-latest.test.tsx | 106 +++++
 .../native-chat/NativeChatResolvedView.tsx    |  32 +-
 ...ativeChatResolvedView.turn-status.test.tsx |   3 +-
 ...tructuredSession.launch-lifecycle.test.tsx |  14 +
 ...tiveChatStructuredSession.test-harness.tsx |   9 +-
 .../NativeChatStructuredSession.test.tsx      |  81 +++-
 .../NativeChatStructuredSession.tsx           |  16 +-
 .../NativeChatSubagentRun.test.tsx            |  26 +-
 .../native-chat/NativeChatSubagentRun.tsx     |  10 +-
 .../native-chat-app-root-test-render.tsx      |  12 +
 .../native-chat-autoscroll.test.ts            | 119 ++++-
 .../native-chat/native-chat-autoscroll.ts     |  47 ++
 .../native-chat/native-chat-composer-types.ts |   4 +
 .../native-chat-disclosure-store.ts           |  10 +-
 .../native-chat-reader-scroll-input.ts        |   6 +-
 .../native-chat-send-reveal-ratchet.test.ts   |  22 +
 .../use-native-chat-composer-submit.test.tsx  |  13 +-
 .../use-native-chat-composer-submit.ts        |   1 +
 ...tive-chat-picker-command-dispatch.test.tsx |   7 +-
 ...use-native-chat-picker-command-dispatch.ts |   4 +
 ...use-native-chat-pty-composer-send.test.tsx |  16 +-
 .../use-native-chat-pty-composer-send.ts      |   2 +
 .../use-native-chat-rail-history-jump.test.ts |  79 +++-
 .../use-native-chat-rail-history-jump.ts      |  74 ++-
 .../use-native-chat-reader-opens.test.ts      |  84 ++++
 .../use-native-chat-reader-opens.ts           |  75 +++
 .../use-native-chat-reveal-latest.ts          |  17 +
 ...ative-chat-session-option-command.test.tsx |   7 +-
 .../use-native-chat-session-option-command.ts |   6 +-
 ...ive-chat-structured-composer-send.test.tsx |  32 +-
 ...se-native-chat-structured-composer-send.ts |   4 +
 ...use-native-chat-transcript-scroll.test.tsx |  33 ++
 .../use-native-chat-transcript-scroll.ts      |  94 +++-
 .../use-native-chat-transcript-window.ts      |   8 +-
 ...ructured-native-chat-submit-reveal.test.ts |  35 ++
 ...se-structured-native-chat-submit-reveal.ts |  89 ++++
 src/renderer/src/i18n/locales/en.json         |   2 +
 src/renderer/src/i18n/locales/es.json         |   2 +
 src/renderer/src/i18n/locales/fr.json         |   2 +
 src/renderer/src/i18n/locales/ja.json         |   2 +
 src/renderer/src/i18n/locales/ko.json         |   2 +
 src/renderer/src/i18n/locales/zh.json         |   2 +
 66 files changed, 1894 insertions(+), 128 deletions(-)
 create mode 100644 src/renderer/src/components/native-chat/NativeChatJumpControls.test.tsx
 create mode 100644 src/renderer/src/components/native-chat/NativeChatJumpControls.tsx
 create mode 100644 src/renderer/src/components/native-chat/NativeChatMessageList.reader-navigation.test.tsx
 create mode 100644 src/renderer/src/components/native-chat/NativeChatResolvedView.reveal-latest.test.tsx
 create mode 100644 src/renderer/src/components/native-chat/native-chat-app-root-test-render.tsx
 create mode 100644 src/renderer/src/components/native-chat/native-chat-send-reveal-ratchet.test.ts
 create mode 100644 src/renderer/src/components/native-chat/use-native-chat-reader-opens.test.ts
 create mode 100644 src/renderer/src/components/native-chat/use-native-chat-reader-opens.ts
 create mode 100644 src/renderer/src/components/native-chat/use-native-chat-reveal-latest.ts
 create mode 100644 src/renderer/src/components/native-chat/use-structured-native-chat-submit-reveal.test.ts
 create mode 100644 src/renderer/src/components/native-chat/use-structured-native-chat-submit-reveal.ts

diff --git a/src/renderer/src/components/native-chat/NativeChatComposer.tsx b/src/renderer/src/components/native-chat/NativeChatComposer.tsx
index d9fb9f1ec2d7..05b4bb3097a7 100644
--- a/src/renderer/src/components/native-chat/NativeChatComposer.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatComposer.tsx
@@ -63,6 +63,7 @@ const NativeChatComposerPane = forwardRef<NativeChatComposerHandle, NativeChatCo
       optimisticSendOutcome,
       onOptimisticSendCanceled,
       onSlashCommand,
+      onSubmitted,
       onSwitchToTerminal,
       readTerminalScreen,
       launchSeed,
@@ -230,6 +231,7 @@ const NativeChatComposerPane = forwardRef<NativeChatComposerHandle, NativeChatCo
         agent,
         disabled,
         onSlashCommand,
+        onSubmitted,
         resolveTarget,
         setHistory
       })
@@ -274,6 +276,7 @@ const NativeChatComposerPane = forwardRef<NativeChatComposerHandle, NativeChatCo
       onOptimisticSend,
       optimisticSendOutcome,
       onSlashCommand,
+      onSubmitted,
       sessionOptionsSurface: ptySessionOptionsSurface,
       terminalTabId,
       trackPendingSend,
@@ -310,6 +313,7 @@ const NativeChatComposerPane = forwardRef<NativeChatComposerHandle, NativeChatCo
       isDispatchingSessionOption,
       resolveTarget,
       onSlashCommand,
+      onSubmitted,
       sessionOptionsSurface: ptySessionOptionsSurface,
       trackPendingSend,
       setHistory,
diff --git a/src/renderer/src/components/native-chat/NativeChatJumpControls.test.tsx b/src/renderer/src/components/native-chat/NativeChatJumpControls.test.tsx
new file mode 100644
index 000000000000..381e3abb652f
--- /dev/null
+++ b/src/renderer/src/components/native-chat/NativeChatJumpControls.test.tsx
@@ -0,0 +1,67 @@
+// @vitest-environment happy-dom
+
+import '@testing-library/jest-dom/vitest'
+
+import { cleanup, render, screen } from '@testing-library/react'
+import userEvent from '@testing-library/user-event'
+import { createRef } from 'react'
+import { afterEach, expect, it, vi } from 'vitest'
+import { TooltipProvider } from '@/components/ui/tooltip'
+import { NativeChatJumpControls } from './NativeChatJumpControls'
+
+afterEach(cleanup)
+
+// The reader is usually mid-draft when they reach for these: a press must not take the caret.
+it.each(['Jump to latest', 'Jump to top'])(
+  'leaves focus in the composer when "%s" is pressed with the pointer',
+  async (name) => {
+    const onLatest = vi.fn()
+    const startFromBeginning = vi.fn()
+    render(
+      <TooltipProvider>
+        <NativeChatJumpControls
+          showLatest
+          startOutOfView
+          historyJump={{ startPending: false, startFromBeginning }}
+          onLatest={onLatest}
+          transcriptRef={createRef<HTMLElement>()}
+        />
+        <textarea aria-label="Message" />
+      </TooltipProvider>
+    )
+    const composer = screen.getByRole('textbox', { name: 'Message' })
+    composer.focus()
+
+    await userEvent.click(screen.getByRole('button', { name }))
+
+    // Anti-vacuous: the press did act.
+    expect(onLatest.mock.calls.length + startFromBeginning.mock.calls.length).toBe(1)
+    expect(document.activeElement).toBe(composer)
+  }
+)
+
+it('hands focus to the transcript when a focused "Jump to top" hides at the start', () => {
+  const transcriptRef = createRef<HTMLDivElement>()
+  const controls = (startOutOfView: boolean) => (
+    <TooltipProvider>
+      <div ref={transcriptRef} tabIndex={0} aria-label="Conversation" />
+      <NativeChatJumpControls
+        showLatest
+        startOutOfView={startOutOfView}
+        historyJump={{ startPending: false, startFromBeginning: vi.fn() }}
+        onLatest={vi.fn()}
+        transcriptRef={transcriptRef}
+      />
+    </TooltipProvider>
+  )
+  const { rerender } = render(controls(true))
+  const top = screen.getByRole('button', { name: 'Jump to top' })
+  top.focus()
+  // Anti-vacuous: the button held focus before it hid.
+  expect(document.activeElement).toBe(top)
+
+  rerender(controls(false))
+
+  expect(top).toHaveAttribute('inert')
+  expect(document.activeElement).toBe(transcriptRef.current)
+})
diff --git a/src/renderer/src/components/native-chat/NativeChatJumpControls.tsx b/src/renderer/src/components/native-chat/NativeChatJumpControls.tsx
new file mode 100644
index 000000000000..c56fcb9bc444
--- /dev/null
+++ b/src/renderer/src/components/native-chat/NativeChatJumpControls.tsx
@@ -0,0 +1,99 @@
+// The way back out of a transcript the reader has scrolled into: to the latest
+// message, or to the start of the conversation.
+//
+// Both stay mounted so they can fade rather than pop, and a hidden one is inert
+// and hidden from assistive tech, so it can be neither clicked, tabbed to nor read.
+
+import { useLayoutEffect, useRef } from 'react'
+import { ArrowDown, ArrowUp, Loader2 } from 'lucide-react'
+import { Tooltip, TooltipContent, TooltipTrigger } from '@/components/ui/tooltip'
+import { translate } from '@/i18n/i18n'
+import { cn } from '@/lib/utils'
+import type { useNativeChatRailHistoryJump } from './use-native-chat-rail-history-jump'
+
+const JUMP_BUTTON_CLASS =
+  'pointer-events-auto flex h-8 items-center gap-1.5 rounded-full border border-border bg-popover 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'
+
+/** Keeps focus where the reader was typing: a pointer press never moves it here. */
+function keepFocus(event: React.MouseEvent): void {
+  event.preventDefault()
+}
+
+/** A keyboard press that hides the focused button hands focus to the transcript, not the page. */
+function useHandBackFocus(visible: boolean, transcriptRef: React.RefObject<HTMLElement | null>) {
+  const ref = useRef<HTMLButtonElement>(null)
+  useLayoutEffect(() => {
+    if (!visible && ref.current !== null && ref.current === document.activeElement) {
+      transcriptRef.current?.focus({ preventScroll: true })
+    }
+  }, [transcriptRef, visible])
+  return ref
+}
+
+export function NativeChatJumpControls({
+  showLatest,
+  startOutOfView,
+  historyJump,
+  onLatest,
+  transcriptRef
+}: {
+  showLatest: boolean
+  /** Older history is still unloaded, or the loaded top is more than a screen away. */
+  startOutOfView: boolean
+  historyJump: Pick<
+    ReturnType<typeof useNativeChatRailHistoryJump>,
+    'startPending' | 'startFromBeginning'
+  >
+  onLatest: () => void
+  transcriptRef: React.RefObject<HTMLElement | null>
+}): React.JSX.Element {
+  // Offered only beside the way back down, so a reader following the end sees neither.
+  const showTop = showLatest && startOutOfView
+  const latestRef = useHandBackFocus(showLatest, transcriptRef)
+  const topRef = useHandBackFocus(showTop, transcriptRef)
+  const topPending = historyJump.startPending
+  const latestLabel = translate('components.native-chat.jumpToLatest', 'Jump to latest')
+  const topLabel = translate('components.native-chat.jumpToTop', 'Jump to top')
+  return (
+    <div className="pointer-events-none absolute inset-x-0 bottom-3 flex justify-center gap-2">
+      <Tooltip>
+        <TooltipTrigger asChild>
+          <button
+            ref={topRef}
+            type="button"
+            aria-label={topLabel}
+            aria-busy={topPending || undefined}
+            data-shown={showTop}
+            inert={!showTop}
+            aria-hidden={!showTop || undefined}
+            onMouseDown={keepFocus}
+            onClick={historyJump.startFromBeginning}
+            className={cn(JUMP_BUTTON_CLASS, 'w-8 justify-center')}
+          >
+            {topPending ? (
+              <Loader2 className="size-3.5 animate-spin motion-reduce:animate-none" />
+            ) : (
+              <ArrowUp className="size-3.5" />
+            )}
+          </button>
+        </TooltipTrigger>
+        <TooltipContent side="top" sideOffset={4}>
+          {topLabel}
+        </TooltipContent>
+      </Tooltip>
+      <button
+        ref={latestRef}
+        type="button"
+        data-shown={showLatest}
+        inert={!showLatest}
+        aria-hidden={!showLatest || undefined}
+        onMouseDown={keepFocus}
+        onClick={onLatest}
+        className={cn(JUMP_BUTTON_CLASS, 'px-3')}
+      >
+        <ArrowDown className="size-3.5" />
+        <span>{latestLabel}</span>
+      </button>
+    </div>
+  )
+}
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 e2af487149d4..626dbd1b1a05 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'
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 13f98dd4249e..4cfa18668adb 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.message-rail-windowing.test.tsx b/src/renderer/src/components/native-chat/NativeChatMessageList.message-rail-windowing.test.tsx
index e2fd6f65d8c8..df3abf63e989 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,
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 819ee94dbd52..07cfb43e630c 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 db59afdb19db..d2c6758f462a 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 1762674739dd..89752ee23200 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 171385054d63..c98bca34872c 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,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 { useCallback, useMemo, useState } from 'react'
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 import type {
@@ -77,10 +78,13 @@ function PagedTranscript({
 }): 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[]>(
     () =>
@@ -449,6 +453,74 @@ describe('jumping from the rail while following the end', () => {
     expect(screen.queryByText('prompt-5')).toBeNull()
     expect(distanceFromBottom()).toBe(0)
   })
+
+  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()
+    act(() => {
+      scroller().scrollTop = 200
+    })
+    await settle(2)
+
+    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 () => {
+    let openGate: (() => void) | null = null
+    const gate = new Promise<void>((resolve) => {
+      openGate = resolve
+    })
+    render(<PagedTranscript holdPage={() => gate} />)
+    await settle(10)
+    act(() => {
+      scroller().scrollTop = 200
+    })
+    await settle(2)
+    const top = screen.getByRole('button', { name: 'Jump to top' })
+    // Anti-vacuous: idle until pressed, whatever else is already paging.
+    expect(top).not.toHaveAttribute('aria-busy')
+
+    fireEvent.click(top)
+    await frame()
+
+    expect(top).toHaveAttribute('aria-busy', 'true')
+    expect(top.querySelector('svg')).toHaveClass('animate-spin', 'motion-reduce:animate-none')
+    act(() => openGate?.())
+    await settle(60)
+    expect(scroller().scrollTop).toBe(0)
+    expect(top).not.toHaveAttribute('aria-busy')
+  })
+
+  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..42bfbf2d1458
--- /dev/null
+++ b/src/renderer/src/components/native-chat/NativeChatMessageList.reader-navigation.test.tsx
@@ -0,0 +1,447 @@
+// @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 } from 'vitest'
+import type { NativeChatMessage } from '../../../../shared/native-chat-types'
+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()
+    })
+    if (scroller.scrollTop !== lastScrollTop) {
+      lastScrollTop = scroller.scrollTop
+      fireEvent.scroll(scroller)
+      changed = true
+    }
+    if (!changed) {
+      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}
+      fontScale={1}
+    />
+  )
+}
+
+/** 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 {
+  const jump = screen.queryByRole('button', { name: 'Jump to latest' })
+  return jump !== null && !jump.hasAttribute('inert')
+}
+
+describe('reader navigation', () => {
+  let restore: (() => void)[] = []
+  beforeEach(() => {
+    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 = []
+  })
+
+  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}
+        fontScale={1}
+      />
+    )
+    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('leaves a tool run the reader opens where it is while the turn streams on', () => {
+    const toolIndex = TRANSCRIPT_LENGTH
+    const withTool: NativeChatMessage[] = [
+      ...transcript,
+      {
+        id: `message-${toolIndex}`,
+        role: 'assistant',
+        blocks: [
+          { type: 'tool-call', name: 'shell', input: { command: 'pwd' }, state: 'completed' },
+          { type: 'tool-result', output: '/repo' }
+        ],
+        timestamp: toolIndex + 1,
+        source: 'transcript'
+      }
+    ]
+    const view = (messages: NativeChatMessage[]) => (
+      <NativeChatMessageList
+        session={session(messages)}
+        isWorking
+        expandSignal={false}
+        fontScale={1}
+      />
+    )
+    const { container, rerender } = render(view(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 toggle = screen.getAllByRole('button', { expanded: false }).at(-1)
+    const toolRow = toggle?.closest<HTMLElement>('[data-index]')
+    if (!toggle || !toolRow) {
+      throw new Error('the tool run has no mounted toggle')
+    }
+    fireEvent.click(toggle)
+    expect(toggle).toHaveAttribute('aria-expanded', 'true')
+    // The run opens taller, and the turn keeps streaming below it.
+    const heights = Array.from({ length: Number(toolRow.dataset.index) + 1 }, () => ROW_PX)
+    heights[Number(toolRow.dataset.index)] = ROW_PX * 6
+    layout.measuredRowHeights = heights
+    paint(container)
+    rerender(view([...withTool, marker(toolIndex + 1), marker(toolIndex + 2)]))
+    paint(container)
+
+    expect(scrollRoot(container).scrollTop).toBe(scrollTopBeforeOpen)
+    expect(distanceFromBottom(container)).toBeGreaterThan(0)
+  })
+
+  it('follows the end again once the reader closes what they opened there', () => {
+    const toolIndex = TRANSCRIPT_LENGTH
+    const withTool: NativeChatMessage[] = [
+      ...transcript,
+      {
+        id: `message-${toolIndex}`,
+        role: 'assistant',
+        blocks: [
+          { type: 'tool-call', name: 'shell', input: { command: 'pwd' }, state: 'completed' },
+          { type: 'tool-result', output: '/repo' }
+        ],
+        timestamp: toolIndex + 1,
+        source: 'transcript'
+      }
+    ]
+    const view = (messages: NativeChatMessage[]) => (
+      <NativeChatMessageList
+        session={session(messages)}
+        isWorking
+        expandSignal={false}
+        fontScale={1}
+      />
+    )
+    const { container, rerender } = render(view(withTool))
+    paint(container)
+    const toggle = screen.getAllByRole('button', { expanded: false }).at(-1)
+    const toolRow = toggle?.closest<HTMLElement>('[data-index]')
+    if (!toggle || !toolRow) {
+      throw new Error('the tool run has no mounted toggle')
+    }
+    fireEvent.click(toggle)
+    const heights = Array.from({ length: Number(toolRow.dataset.index) + 1 }, () => ROW_PX)
+    heights[Number(toolRow.dataset.index)] = ROW_PX * 6
+    layout.measuredRowHeights = heights
+    paint(container)
+    // Anti-vacuous: the open run pushed the end away, and the reader was left where they were.
+    expect(distanceFromBottom(container)).toBeGreaterThan(0)
+
+    // Closing lands exactly on the end: no offset moves, so no scroll event reports it.
+    fireEvent.click(toggle)
+    layout.measuredRowHeights = []
+    paint(container)
+    expect(distanceFromBottom(container)).toBe(0)
+    rerender(view([...withTool, marker(toolIndex + 1), marker(toolIndex + 2)]))
+    paint(container)
+
+    expect(distanceFromBottom(container)).toBe(0)
+    expect(screen.getByText(`marker-${toolIndex + 2}`)).toBeInTheDocument()
+  })
+
+  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('returns to the end and follows it, however far the turn streamed meanwhile', () => {
+      const { container, rerender } = render(liveList(withTool))
+      paint(container)
+      const [run] = closedRuns(1)
+      toggleRun(container, run.toggle, [run.rowIndex])
+      rerender(liveList(streamedOn))
+      paint(container)
+      // Anti-vacuous: left behind, well outside the band a scroll would re-arm in.
+      expect(distanceFromBottom(container)).toBeGreaterThan(ROW_PX * 5)
+      expect(offersJumpToLatest()).toBe(true)
+
+      toggleRun(container, run.toggle, [])
+      expect(distanceFromBottom(container)).toBe(0)
+      expect(offersJumpToLatest()).toBe(false)
+      rerender(liveList([...streamedOn, marker(toolIndex + 3)]))
+      paint(container)
+
+      expect(distanceFromBottom(container)).toBe(0)
+      expect(screen.getByText(`marker-${toolIndex + 3}`)).toBeInTheDocument()
+    })
+
+    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('follows again only once the last of two opened runs is closed', () => {
+      const twoTools = [...withTool, marker(toolIndex + 1), toolMessage(toolIndex + 2)]
+      const { container, rerender } = render(liveList(twoTools))
+      paint(container)
+      const [first, second] = closedRuns(2)
+      // Anti-vacuous: two different rows.
+      expect(first.rowIndex).not.toBe(second.rowIndex)
+      toggleRun(container, first.toggle, [first.rowIndex])
+      toggleRun(container, second.toggle, [first.rowIndex, second.rowIndex])
+      const scrollTopWhileOpen = scrollRoot(container).scrollTop
+
+      toggleRun(container, first.toggle, [second.rowIndex])
+      rerender(liveList([...twoTools, marker(toolIndex + 3)]))
+      paint(container)
+      expect(scrollRoot(container).scrollTop).toBe(scrollTopWhileOpen)
+      expect(distanceFromBottom(container)).toBeGreaterThan(0)
+
+      toggleRun(container, second.toggle, [])
+      expect(distanceFromBottom(container)).toBe(0)
+    })
+
+    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 a run the reader left open in place when its output settles shorter', () => {
+    const toolIndex = TRANSCRIPT_LENGTH
+    const withTool: NativeChatMessage[] = [
+      ...transcript,
+      {
+        id: `message-${toolIndex}`,
+        role: 'assistant',
+        blocks: [
+          { type: 'tool-call', name: 'shell', input: { command: 'pwd' }, state: 'completed' },
+          { type: 'tool-result', output: '/repo' }
+        ],
+        timestamp: toolIndex + 1,
+        source: 'transcript'
+      }
+    ]
+    const view = (messages: NativeChatMessage[]) => (
+      <NativeChatMessageList
+        session={session(messages)}
+        isWorking
+        expandSignal={false}
+        fontScale={1}
+      />
+    )
+    const { container, rerender } = render(view(withTool))
+    paint(container)
+    const scrollTopBeforeOpen = scrollRoot(container).scrollTop
+    const toggle = screen.getAllByRole('button', { expanded: false }).at(-1)
+    const toolRow = toggle?.closest<HTMLElement>('[data-index]')
+    if (!toggle || !toolRow) {
+      throw new Error('the tool run has no mounted toggle')
+    }
+    fireEvent.click(toggle)
+    const heights = Array.from({ length: Number(toolRow.dataset.index) + 1 }, () => ROW_PX)
+    heights[Number(toolRow.dataset.index)] = ROW_PX * 6
+    layout.measuredRowHeights = heights
+    paint(container)
+
+    // Still open, but now within rounding distance of the end, with no offset moved.
+    layout.measuredRowHeights = heights.with(Number(toolRow.dataset.index), ROW_PX + 2)
+    paint(container)
+    expect(toggle).toHaveAttribute('aria-expanded', 'true')
+    expect(distanceFromBottom(container)).toBe(2)
+    rerender(view([...withTool, marker(toolIndex + 1), marker(toolIndex + 2)]))
+    paint(container)
+
+    expect(scrollRoot(container).scrollTop).toBe(scrollTopBeforeOpen)
+  })
+
+  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('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(screen.getByRole('button', { name: 'Jump to latest' })).not.toHaveAttribute('inert')
+    // 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('hands focus to the transcript when a focused jump button hides, and leaves it inert', () => {
+    const { container } = render(
+      <NativeChatMessageList
+        session={session(transcript)}
+        isWorking={false}
+        expandSignal={false}
+        fontScale={1}
+      />
+    )
+    paint(container)
+    scrollTranscript(container, 1000)
+    paint(container)
+    const latest = screen.getByRole('button', { name: 'Jump to latest' })
+    // Anti-vacuous: shown, so reachable.
+    expect(latest).not.toHaveAttribute('inert')
+
+    latest.focus()
+    fireEvent.click(latest)
+    paint(container)
+
+    expect(latest).toHaveAttribute('inert')
+    expect(document.activeElement).toBe(scrollRoot(container))
+    expect(screen.getByRole('region', { name: 'Conversation' })).toBe(scrollRoot(container))
+  })
+})
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 7efb254c6194..4d1cdd809607 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 968dc5b92e8c..237e159cae0d 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 82b2c43d4681..7493f10a22d8 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 b72562d128a1..4ca3b60664fb 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 d8a9379ca190..f0061e52ec0c 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 efe1c54dd014..d3b730a27eca 100644
--- a/src/renderer/src/components/native-chat/NativeChatMessageList.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatMessageList.tsx
@@ -1,5 +1,4 @@
-import { useCallback, useLayoutEffect, useMemo, useRef, useState } from 'react'
-import { ArrowDown } from 'lucide-react'
+import { useCallback, useImperativeHandle, 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'
@@ -13,10 +12,7 @@ import { NativeChatAwaitingInputRow } from './NativeChatAwaitingInputRow'
 import type { RuntimeFileOperationArgs } from '@/runtime/runtime-file-client'
 import type { NativeChatTurnActivity } from '../../../../shared/native-chat-turn-activity'
 import { NativeChatTurnActivityLine } from './NativeChatTurnActivityLine'
-import {
-  NativeChatDisclosureContext,
-  useNativeChatDisclosures
-} from './native-chat-disclosure-store'
+import { NativeChatDisclosureContext } from './native-chat-disclosure-store'
 import {
   NativeChatTranscriptItems,
   NativeChatWaitingTranscriptItems
@@ -31,7 +27,6 @@ import {
 import { useNativeChatTranscriptWindow } from './use-native-chat-transcript-window'
 import { nativeChatRowsInTranscriptOrder } from './native-chat-subagent-sections'
 import { useNativeChatSubagentSections } from './use-native-chat-subagent-sections'
-import { toggleNativeChatExpandedKey } from './native-chat-expanded-keys'
 import { useNativeChatTurnMembership } from './use-native-chat-turn-membership'
 import { useNativeChatTranscriptScroll } from './use-native-chat-transcript-scroll'
 import { useNativeChatOlderHistoryAutoload } from './use-native-chat-older-history-autoload'
@@ -44,6 +39,9 @@ import type {
 } from './native-chat-message-rail-items'
 import { useNativeChatRailHistoryJump } from './use-native-chat-rail-history-jump'
 import { nativeChatReaderScrollInputHandlers } from './native-chat-reader-scroll-input'
+import { NativeChatJumpControls } from './NativeChatJumpControls'
+import { useNativeChatReaderOpens } from './use-native-chat-reader-opens'
+import type { NativeChatMessageListHandle } from './use-native-chat-reveal-latest'
 
 import type {
   AgentJournalRenderItem,
@@ -67,6 +65,7 @@ type NativeChatNavigationRequest =
   | { kind: 'rail'; messageId: string; requestId: number }
 
 export function NativeChatMessageList({
+  ref,
   session,
   journalItems,
   journalSubmissions,
@@ -85,6 +84,7 @@ export function NativeChatMessageList({
   turnActivity,
   runtimeContext
 }: {
+  ref?: React.Ref<NativeChatMessageListHandle>
   session: NativeChatLiveSession
   journalItems?: readonly AgentJournalRenderItem[]
   /** With the items, what places each row in its turn (structured lane). */
@@ -124,10 +124,6 @@ export function NativeChatMessageList({
   const scrollRef = useRef<HTMLDivElement | null>(null)
   const contentRef = useRef<HTMLDivElement | null>(null)
   const [expandedTurnIds, setExpandedTurnIds] = useState<ReadonlySet<string>>(new Set())
-  const disclosures = useNativeChatDisclosures()
-  const toggleExpandedTurn = useCallback((turnKey: string) => {
-    setExpandedTurnIds((current) => toggleNativeChatExpandedKey(current, turnKey))
-  }, [])
 
   const { hasMore, loadingEarlier, loadEarlier } = session
   // No paging from a pending or errored read: the lane would no-op, and its recovery
@@ -226,7 +222,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,
@@ -265,10 +261,19 @@ 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
+  const readerOpens = useNativeChatReaderOpens({
+    subagentDisclosure,
+    expandedTurnIds,
+    setExpandedTurnIds,
+    follow: transcriptScroll,
+    abortNavigation: beginNavigation
+  })
   // 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(
@@ -297,10 +302,12 @@ export function NativeChatMessageList({
     },
     [beginNavigation, openSubagentSections]
   )
+  const { scrollToBottom, scrollMessageToTop } = transcriptScroll
   const jumpToLatest = useCallback(() => {
     beginNavigation()
     scrollToBottom()
   }, [beginNavigation, scrollToBottom])
+  useImperativeHandle(ref, () => ({ revealLatest: jumpToLatest }), [jumpToLatest])
   const readerScrollInput = useMemo(
     () => nativeChatReaderScrollInputHandlers(beginNavigation),
     [beginNavigation]
@@ -337,8 +344,8 @@ export function NativeChatMessageList({
       allowFileUriLinks,
       runtimeContext,
       onLinkClick,
-      onToggleExpandedTurn: toggleExpandedTurn,
-      subagentDisclosure,
+      onToggleExpandedTurn: readerOpens.toggleExpandedTurn,
+      subagentDisclosure: readerOpens.subagentDisclosure,
       onScrollMessageToTop: scrollMessageToTop,
       onRevealDiff: revealDiff
     }),
@@ -353,24 +360,25 @@ export function NativeChatMessageList({
       runtimeContext,
       scrollMessageToTop,
       taskListPredecessors,
-      subagentDisclosure,
-      toggleExpandedTurn
+      readerOpens.subagentDisclosure,
+      readerOpens.toggleExpandedTurn
     ]
   )
 
   return (
-    <NativeChatDisclosureContext.Provider value={disclosures}>
+    <NativeChatDisclosureContext.Provider value={readerOpens.disclosures}>
       <div className="relative flex min-h-0 flex-1 flex-col">
         <div className="relative min-h-0 flex-1">
           <div
             ref={scrollRef}
-            onScroll={onScroll}
+            onScroll={transcriptScroll.onScroll}
             {...readerScrollInput}
             // 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"
             // Why: `zoom` scales the chat transcript's text and layout together,
             // scoped to this pane so the rest of the app is untouched. It sits on
             // the scroll container rather than the content inside it so that
@@ -416,17 +424,13 @@ export function NativeChatMessageList({
             onReaderScroll={beginNavigation}
             pendingId={railHistoryJump.pendingId}
           />
-          {showJump ? (
-            <button
-              type="button"
-              onClick={jumpToLatest}
-              aria-label={translate('components.native-chat.jumpToLatest', 'Jump to latest')}
-              className="absolute bottom-3 left-1/2 flex -translate-x-1/2 items-center gap-1.5 rounded-full border border-border bg-card/90 px-3 py-1.5 text-xs text-muted-foreground shadow-sm backdrop-blur hover:bg-accent hover:text-accent-foreground focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring"
-            >
-              <ArrowDown className="size-3.5" />
-              <span>{translate('components.native-chat.jumpToLatest', 'Jump to latest')}</span>
-            </button>
-          ) : null}
+          <NativeChatJumpControls
+            showLatest={transcriptScroll.showJump}
+            startOutOfView={showOlderHistory || transcriptScroll.awayFromTop}
+            historyJump={railHistoryJump}
+            onLatest={jumpToLatest}
+            transcriptRef={scrollRef}
+          />
         </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 7c62a9efe3ef..3b96eece233f 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 c4b2bc2ed6fb..86fc3afd2073 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 d48c1d04dab0..1cacdf2a65c2 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 29f977046f6c..f9fd4b96f7bd 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 546c7b5cba7d..a33da08fa2dc 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.unsent-message.test.tsx b/src/renderer/src/components/native-chat/NativeChatMessageList.unsent-message.test.tsx
index ac6ab467ace2..1a51ff55d604 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 bf31f92a3d93..ba18ce53f037 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/NativeChatResolvedView.reveal-latest.test.tsx b/src/renderer/src/components/native-chat/NativeChatResolvedView.reveal-latest.test.tsx
new file mode 100644
index 000000000000..8f01e7fd6f67
--- /dev/null
+++ b/src/renderer/src/components/native-chat/NativeChatResolvedView.reveal-latest.test.tsx
@@ -0,0 +1,106 @@
+// @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 { NativeChatInteractiveSend } from './use-native-chat-interactive-send'
+
+// 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<{ revealLatest: () => void }> }) => {
+    useImperativeHandle(props.ref, () => ({ revealLatest: stubs.revealLatest }))
+    return null
+  }
+}))
+vi.mock('./use-native-chat-interactive-send', () => ({
+  useNativeChatInteractiveSend: (): NativeChatInteractiveSend => ({
+    sendAnswer: () => ({ settleAfterMs: 0, waitsForVerifiedDelivery: false }),
+    sendRaw: () => {},
+    cancelPending: () => {},
+    cancel: () => {}
+  })
+}))
+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 { 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: only the answers are sends.
+    stubs.cardSend?.sendAnswer({ questions: [] }, [])
+    expect(stubs.revealLatest).toHaveBeenCalledTimes(2)
+    stubs.cardSend?.sendRaw('1')
+    expect(stubs.revealLatest).toHaveBeenCalledTimes(3)
+    stubs.cardSend?.cancel()
+    expect(stubs.revealLatest).toHaveBeenCalledTimes(3)
+  })
+})
diff --git a/src/renderer/src/components/native-chat/NativeChatResolvedView.tsx b/src/renderer/src/components/native-chat/NativeChatResolvedView.tsx
index 7c9c3f8337eb..587552fd11ac 100644
--- a/src/renderer/src/components/native-chat/NativeChatResolvedView.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatResolvedView.tsx
@@ -6,6 +6,7 @@ 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 { useNativeChatRevealLatest } from './use-native-chat-reveal-latest'
 import { useNativeChatLaunchPromptDeliveryNotice } from './use-native-chat-launch-prompt-delivery-notice'
 import { NativeChatComposer, type NativeChatComposerHandle } from './NativeChatComposer'
 import { useNativeChatFontScale } from './use-native-chat-font-scale'
@@ -13,7 +14,10 @@ import { useNativeChatCanSend } from './use-native-chat-can-send'
 import { NativeChatInteractiveCard } from './NativeChatInteractiveCard'
 import { useNativeChatInteractivePromptCard } from './use-native-chat-interactive-prompt-card'
 import { NativeChatEmptyState } from './NativeChatEmptyState'
-import { useNativeChatInteractiveSend } from './use-native-chat-interactive-send'
+import {
+  useNativeChatInteractiveSend,
+  type NativeChatInteractiveSend
+} from './use-native-chat-interactive-send'
 import { shouldClearNativeChatWorkingSuppression } from './native-chat-working-suppression'
 import { resolveNativeChatTerminalTurn } from './native-chat-terminal-turn'
 import { useNativeChatTerminalTurnTiming } from './use-native-chat-terminal-turn-timing'
@@ -110,7 +114,29 @@ 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 { sendAnswer, sendRaw, cancelPending, cancel } = 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 = useMemo<NativeChatInteractiveSend>(
+    () => ({
+      sendAnswer: (...args) => {
+        revealLatest()
+        return sendAnswer(...args)
+      },
+      sendRaw: (raw) => {
+        revealLatest()
+        sendRaw(raw)
+      },
+      cancelPending,
+      cancel
+    }),
+    [cancel, cancelPending, revealLatest, sendAnswer, sendRaw]
+  )
   const [workingInterrupted, setWorkingInterrupted] = useState(false)
   const previousWorkingEpochRef = useRef<number | null>(null)
   // True while a question card owns the input region, so the composer is hidden.
@@ -356,6 +382,7 @@ export function NativeChatResolvedView({
           <NativeChatEmptyState kind="empty" agent={agent} />
         ) : (
           <NativeChatMessageList
+            ref={messageListRef}
             session={sessionWithPending}
             isVisible={isVisible}
             isWorking={turnActive}
@@ -396,6 +423,7 @@ export function NativeChatResolvedView({
           onOptimisticSendCanceled={delivery.cancel}
           optimisticSendOutcome={delivery}
           onSlashCommand={onSlashCommand}
+          onSubmitted={revealLatest}
           onSwitchToTerminal={onSwitchToTerminal}
           readTerminalScreen={readTerminalScreen}
           launchSeed={{ ...launchDraftSignal, ownsTabWideLaunchDraft }}
diff --git a/src/renderer/src/components/native-chat/NativeChatResolvedView.turn-status.test.tsx b/src/renderer/src/components/native-chat/NativeChatResolvedView.turn-status.test.tsx
index 97d8acc7d75c..1ea8609a6b8f 100644
--- a/src/renderer/src/components/native-chat/NativeChatResolvedView.turn-status.test.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatResolvedView.turn-status.test.tsx
@@ -3,7 +3,8 @@
 import '@testing-library/jest-dom/vitest'
 
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
-import { act, cleanup, render, screen } from '@testing-library/react'
+import { act, cleanup, screen } from '@testing-library/react'
+import { render } from './native-chat-app-root-test-render'
 import type { AgentStatusEntry, AgentStatusPayload } from '../../../../shared/agent-status-types'
 import type { NativeChatMessage } from '../../../../shared/native-chat-types'
 import type { NativeChatLiveSession } from './use-native-chat-live-session'
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 644c1c657500..0b35e9ed5255 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
@@ -240,6 +240,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.test-harness.tsx b/src/renderer/src/components/native-chat/NativeChatStructuredSession.test-harness.tsx
index 89fda3f7f31b..ea56db918357 100644
--- a/src/renderer/src/components/native-chat/NativeChatStructuredSession.test-harness.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatStructuredSession.test-harness.tsx
@@ -89,6 +89,7 @@ export function seedOutbox(sessionId: string, entries: unknown[]): void {
 }
 
 type StructuredSessionMessageListProps = {
+  ref?: React.Ref<{ revealLatest: () => void }>
   allowFileUriLinks?: boolean
   isVisible?: boolean
   onLinkClick?: (...args: unknown[]) => void
@@ -126,6 +127,7 @@ export function createStructuredSessionMocks() {
       structuredTransport?: Record<string, unknown>
       isWorking?: boolean
       onStop?: () => void
+      steerQueued?: () => boolean
     }>(),
     approvalCardProps: initialApprovalCardProps,
     questionCardProps: null as NativeChatQuestionCardProps | null,
@@ -157,7 +159,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 = {
@@ -300,6 +303,7 @@ export function createStructuredSessionMocks() {
     nativeChatMessageList: () => ({
       NativeChatMessageList: (props: typeof mocks.messageListProps) => {
         mocks.messageListProps = props
+        useImperativeHandle(props?.ref, () => ({ revealLatest: mocks.revealLatest }))
         return <DeliveryNoticesMock notices={props?.deliveryNotices} />
       }
     }),
@@ -374,6 +378,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 e2c4c6ff0304..cec62ef95b67 100644
--- a/src/renderer/src/components/native-chat/NativeChatStructuredSession.test.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatStructuredSession.test.tsx
@@ -4,6 +4,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
@@ -256,7 +257,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',
@@ -309,6 +310,7 @@ describe('NativeChatStructuredSession', () => {
       kind: 'option',
       optionId: 'allow'
     })
+    await waitFor(() => expect(mocks.revealLatest).toHaveBeenCalledOnce())
     expect(mocks.messageListProps?.awaitingInput).toBe('shown')
 
     act(() => mocks.approvalCardProps?.onCancel?.())
@@ -605,4 +607,81 @@ 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 for the submits this pane makes, and not for refused ones', async () => {
+    mocks.promptItems = legacySingleQuestionPromptItems
+    const { rerender } = render(
+      <NativeChatStructuredSession
+        isVisible
+        isFocusedGroup
+        tabId="structured-tab-reveal"
+        sessionId="session-reveal"
+        target={{ kind: 'local' }}
+        agent="claude"
+      />
+    )
+    // Refused by the host: nothing was answered, so the reader is left where they are.
+    mocks.respond.mockResolvedValueOnce(null)
+    mocks.questionCardProps?.onAnswer([{ indices: [1], other: '' }])
+    await new Promise<void>((resolve) => setTimeout(resolve, 0))
+    expect(mocks.respond).toHaveBeenCalledOnce()
+    expect(mocks.revealLatest).not.toHaveBeenCalled()
+
+    mocks.respond.mockResolvedValueOnce({ itemId: 'question-1', revision: 2 })
+    mocks.questionCardProps?.onAnswer([{ indices: [1], other: '' }])
+    await waitFor(() => 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 reports only sends its transport accepted.
+    onSubmitted()
+    expect(mocks.revealLatest).toHaveBeenCalledOnce()
+    mocks.queuedSteerNewest.mockReturnValue(true)
+    expect(steerQueued()).toBe(true)
+    expect(mocks.revealLatest).toHaveBeenCalledTimes(2)
+  })
+
+  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 e69056836c48..e1ebaa3a6870 100644
--- a/src/renderer/src/components/native-chat/NativeChatStructuredSession.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatStructuredSession.tsx
@@ -8,6 +8,7 @@ import { NativeChatComposer, type NativeChatComposerHandle } from './NativeChatC
 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'
@@ -111,6 +112,8 @@ export function NativeChatStructuredSession(
     }),
     [controller, historyPhase, props.agent, props.sessionId]
   )
+  const submits = useStructuredNativeChatSubmitReveal(controller, provisionalLaunch.retry)
+  const { retryDelivery, revealLatest } = submits
   const agentLabel = structuredAgentLabel(props.agent === 'codex' ? 'codex' : 'claude')
   const deliveryNotices = useStructuredAgentSessionDeliveryNotices({
     outbox: controller.outbox,
@@ -208,6 +211,7 @@ export function NativeChatStructuredSession(
       contextUsage: controller.contextUsage,
       worktreeId: fileLinkContext?.worktreeId,
       onError: setComposerError,
+      onSubmitted: revealLatest,
       runtime: (props.target.kind === 'local' ? 'local' : 'remote') as 'local' | 'remote',
       sessionId: props.sessionId,
       runtimeEnvironmentId:
@@ -220,6 +224,7 @@ export function NativeChatStructuredSession(
     props.agent,
     props.sessionId,
     props.target,
+    revealLatest,
     sendThroughRelaunch
   ])
 
@@ -253,6 +258,7 @@ export function NativeChatStructuredSession(
           <NativeChatEmptyState kind="empty" agent={props.agent} />
         ) : (
           <NativeChatMessageList
+            ref={submits.messageListRef}
             session={session}
             journalItems={controller.journalItems}
             journalSubmissions={controller.submissions}
@@ -277,11 +283,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}
         focusComposer={() => {
           composerRef.current?.focus()
         }}
@@ -317,7 +323,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={props.isVisible && props.isFocusedGroup}
           onLinkClick={onLinkClick}
@@ -350,7 +356,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}
@@ -366,7 +372,7 @@ export function NativeChatStructuredSession(
           canSend={!prompt}
           isWorking={controller.canStop}
           onStop={() => void controller.stop()}
-          steerQueued={controller.queuedMessages.steerNewest}
+          steerQueued={submits.queuedMessages.steerNewest}
           structuredTransport={structuredTransport}
           launchSeed={{ ...launchDraftSignal, ownsTabWideLaunchDraft: true }}
         />
diff --git a/src/renderer/src/components/native-chat/NativeChatSubagentRun.test.tsx b/src/renderer/src/components/native-chat/NativeChatSubagentRun.test.tsx
index e66130b9c932..c3345cfc667e 100644
--- a/src/renderer/src/components/native-chat/NativeChatSubagentRun.test.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatSubagentRun.test.tsx
@@ -3,13 +3,14 @@
 import '@testing-library/jest-dom/vitest'
 
 import { cleanup, fireEvent, render, screen } from '@testing-library/react'
-import { afterEach, describe, expect, it } from 'vitest'
+import { afterEach, describe, expect, it, vi } from 'vitest'
 import type {
   NativeChatSubagentEntry,
   NativeChatSubagentGroupBlock
 } from '../../../../shared/native-chat-types'
 import { NativeChatSubagentRun } from './NativeChatSubagentRun'
 import { NativeChatToolRun } from './NativeChatToolRun'
+import { NativeChatDisclosureContext } from './native-chat-disclosure-store'
 
 afterEach(cleanup)
 
@@ -335,3 +336,26 @@ describe('NativeChatToolRun with a spawn group', () => {
     expect(screen.getByRole('button', { name: /search/, expanded: true })).toBeInTheDocument()
   })
 })
+
+const onToggle = vi.fn()
+const TRANSCRIPT_DISCLOSURES = { read: () => undefined, write: vi.fn(), onToggle }
+
+// Without a held open state the run keeps its own, and the transcript still hears the reader toggle it.
+it('reports opening and closing an unheld run to the transcript', () => {
+  onToggle.mockClear()
+  render(
+    <NativeChatDisclosureContext.Provider value={TRANSCRIPT_DISCLOSURES}>
+      <NativeChatSubagentRun block={group([{ id: 'a', label: 'read', state: 'working' }])} />
+    </NativeChatDisclosureContext.Provider>
+  )
+  const toggle = screen.getByRole('button')
+
+  fireEvent.click(toggle)
+  expect(toggle).toHaveAttribute('aria-expanded', 'true')
+  expect(onToggle.mock.calls).toEqual([[expect.any(String), true]])
+  fireEvent.click(toggle)
+  // The close names the row the open did, so the transcript can match them.
+  const [[openedRow], [closedRow, closedOpen]] = onToggle.mock.calls
+  expect(closedOpen).toBe(false)
+  expect(closedRow).toBe(openedRow)
+})
diff --git a/src/renderer/src/components/native-chat/NativeChatSubagentRun.tsx b/src/renderer/src/components/native-chat/NativeChatSubagentRun.tsx
index eda50ae49f35..63f1df15b25c 100644
--- a/src/renderer/src/components/native-chat/NativeChatSubagentRun.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatSubagentRun.tsx
@@ -1,4 +1,5 @@
-import { useMemo, useState } from 'react'
+import { useMemo } from 'react'
+import { useNativeChatDisclosure } from './native-chat-disclosure-store'
 import { Bot, ChevronRight } from 'lucide-react'
 import { cn } from '@/lib/utils'
 import { translate } from '@/i18n/i18n'
@@ -241,9 +242,10 @@ export function NativeChatSubagentRun({
   sections?: ReadonlyMap<string, boolean>
   onSetSectionOpen?: (agentId: string, open: boolean) => void
 }): React.JSX.Element | null {
-  const [localOpen, setLocalOpen] = useState(false)
-  const open = heldOpen ?? localOpen
-  const setOpen = onSetOpen ?? setLocalOpen
+  // Unkeyed, but still a reader's open the transcript hears about.
+  const local = useNativeChatDisclosure(undefined, false)
+  const open = heldOpen ?? local.open
+  const setOpen = onSetOpen ?? local.setOpen
   const agents = block.agents
   const summary = useMemo(() => summarizeSubagentGroup(agents), [agents])
   if (summary.total === 0) {
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..0d83aefcb00f 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
@@ -1,11 +1,15 @@
 import { describe, it, expect } from 'vitest'
 import {
   distanceFromBottom,
+  FOLLOWING,
   isNearBottom,
   nextFollowingEnd,
+  nextFollowState,
   shouldShowJumpToLatest,
   NATIVE_CHAT_BOTTOM_THRESHOLD_PX,
-  NATIVE_CHAT_FOLLOW_REARM_PX
+  NATIVE_CHAT_FOLLOW_REARM_PX,
+  type FollowEvent,
+  type FollowState
 } from './native-chat-autoscroll'
 
 const atBottom = { scrollTop: 952, scrollHeight: 1000, clientHeight: 48 }
@@ -142,3 +146,116 @@ describe('nextFollowingEnd', () => {
     expect(nextFollowingEnd({ ...following, geometry: parkedAbove(1.5) })).toBe(true)
   })
 })
+
+describe('nextFollowState', () => {
+  const opened = (...rows: string[]): FollowState => ({
+    kind: 'detached',
+    reason: 'open',
+    opens: new Set(rows)
+  })
+  const scrolled: FollowState = { kind: 'detached', reason: 'scroll' }
+  const navigated: FollowState = { kind: 'detached', reason: 'navigation' }
+  const scroll = (distance: number, programmatic = false): FollowEvent => ({
+    kind: 'scroll',
+    programmatic,
+    geometry: parkedAbove(distance),
+    previousDistanceFromEnd: 400
+  })
+  const events = {
+    'reader opens a': { kind: 'open', row: 'a' },
+    'reader opens c': { kind: 'open', row: 'c' },
+    'reader closes a': { kind: 'close', row: 'a' },
+    // Opened before this detach, so never one of its opens.
+    'reader closes c': { kind: 'close', row: 'c' },
+    'reader scrolls away': scroll(200),
+    'reader scrolls to the end': scroll(0),
+    'application scrolls away': scroll(200, true),
+    'application scrolls to the end': scroll(0, true),
+    'reader reveals the latest': { kind: 'reveal-latest' },
+    'reader navigates': { kind: 'navigate' }
+  } satisfies Record<string, FollowEvent>
+
+  const row = (
+    name: string,
+    state: FollowState,
+    after: Record<keyof typeof events, FollowState>
+  ): { name: string; state: FollowState; after: Map<string, FollowState> } => ({
+    name,
+    state,
+    after: new Map(Object.entries(after))
+  })
+  const table = [
+    row('following', FOLLOWING, {
+      'reader opens a': opened('a'),
+      'reader opens c': opened('c'),
+      'reader closes a': FOLLOWING,
+      'reader closes c': FOLLOWING,
+      'reader scrolls away': scrolled,
+      'reader scrolls to the end': FOLLOWING,
+      'application scrolls away': FOLLOWING,
+      'application scrolls to the end': FOLLOWING,
+      'reader reveals the latest': FOLLOWING,
+      'reader navigates': navigated
+    }),
+    row('scrolled away', scrolled, {
+      'reader opens a': scrolled,
+      'reader opens c': scrolled,
+      'reader closes a': scrolled,
+      'reader closes c': scrolled,
+      'reader scrolls away': scrolled,
+      'reader scrolls to the end': FOLLOWING,
+      'application scrolls away': scrolled,
+      'application scrolls to the end': scrolled,
+      'reader reveals the latest': FOLLOWING,
+      'reader navigates': navigated
+    }),
+    row('navigated away', navigated, {
+      'reader opens a': navigated,
+      'reader opens c': navigated,
+      'reader closes a': navigated,
+      'reader closes c': navigated,
+      'reader scrolls away': scrolled,
+      'reader scrolls to the end': FOLLOWING,
+      'application scrolls away': navigated,
+      'application scrolls to the end': navigated,
+      'reader reveals the latest': FOLLOWING,
+      'reader navigates': navigated
+    }),
+    row('opened a', opened('a'), {
+      'reader opens a': opened('a'),
+      'reader opens c': opened('a', 'c'),
+      'reader closes a': FOLLOWING,
+      'reader closes c': opened('a'),
+      'reader scrolls away': scrolled,
+      'reader scrolls to the end': FOLLOWING,
+      'application scrolls away': opened('a'),
+      'application scrolls to the end': opened('a'),
+      'reader reveals the latest': FOLLOWING,
+      'reader navigates': navigated
+    }),
+    row('opened a and b', opened('a', 'b'), {
+      'reader opens a': opened('a', 'b'),
+      'reader opens c': opened('a', 'b', 'c'),
+      'reader closes a': opened('b'),
+      'reader closes c': opened('a', 'b'),
+      'reader scrolls away': scrolled,
+      'reader scrolls to the end': FOLLOWING,
+      'application scrolls away': opened('a', 'b'),
+      'application scrolls to the end': opened('a', 'b'),
+      'reader reveals the latest': FOLLOWING,
+      'reader navigates': navigated
+    })
+  ]
+
+  const cases = table.flatMap(({ name, state, after }) =>
+    Object.entries(events).map(([eventName, event]) => ({
+      name: `${name}: ${eventName}`,
+      state,
+      event,
+      expected: after.get(eventName)
+    }))
+  )
+  it.each(cases)('$name', ({ state, event, expected }) => {
+    expect(nextFollowState(state, event)).toEqual(expected)
+  })
+})
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..e7170c9e4cc0 100644
--- a/src/renderer/src/components/native-chat/native-chat-autoscroll.ts
+++ b/src/renderer/src/components/native-chat/native-chat-autoscroll.ts
@@ -70,3 +70,50 @@ export function nextFollowingEnd(intent: FollowIntent): boolean {
   }
   return isNearBottom(intent.geometry, NATIVE_CHAT_FOLLOW_REARM_PX)
 }
+
+/** Whether the transcript follows its end, and if not, what the reader did to stop it. */
+export type FollowState =
+  | { kind: 'following' }
+  | { kind: 'detached'; reason: 'scroll' | 'navigation' }
+  /** Stopped only by opening rows, and not scrolled since: closing the last one follows again. */
+  | { kind: 'detached'; reason: 'open'; opens: ReadonlySet<string> }
+
+export type FollowEvent =
+  | { kind: 'open' | 'close'; row: string }
+  | ({ kind: 'scroll' } & Omit<FollowIntent, 'following'>)
+  | { kind: 'reveal-latest' }
+  | { kind: 'navigate' }
+
+export const FOLLOWING: FollowState = { kind: 'following' }
+
+export function nextFollowState(state: FollowState, event: FollowEvent): FollowState {
+  switch (event.kind) {
+    case 'open':
+      if (state.kind === 'following') {
+        return { kind: 'detached', reason: 'open', opens: new Set([event.row]) }
+      }
+      return state.reason === 'open' && !state.opens.has(event.row)
+        ? { ...state, opens: new Set([...state.opens, event.row]) }
+        : state
+    case 'close': {
+      // By identity: a row opened before this detach is not one of its opens.
+      if (state.kind === 'following' || state.reason !== 'open' || !state.opens.has(event.row)) {
+        return state
+      }
+      const opens = new Set(state.opens)
+      opens.delete(event.row)
+      return opens.size === 0 ? FOLLOWING : { ...state, opens }
+    }
+    case 'scroll':
+      if (event.programmatic) {
+        return state
+      }
+      return nextFollowingEnd({ ...event, following: state.kind === 'following' })
+        ? FOLLOWING
+        : { kind: 'detached', reason: 'scroll' }
+    case 'reveal-latest':
+      return FOLLOWING
+    case 'navigate':
+      return { kind: 'detached', reason: 'navigation' }
+  }
+}
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 922d16924f3f..5276059d546b 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
@@ -31,6 +31,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
+  /** The host accepted a message, a command it runs itself, or a goal. */
+  onSubmitted?: () => void
   runtime: 'local' | 'remote'
   /** The session behind this composer; a real user send relinquishes orchestration ownership. */
   sessionId: string
@@ -67,6 +69,8 @@ export type NativeChatComposerProps = {
   onOptimisticSendCanceled?: (pendingId: string) => void
   /** Record a dispatched slash command that does not create a chat turn. */
   onSlashCommand?: (command: string) => void
+  /** Anything delivered 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-disclosure-store.ts b/src/renderer/src/components/native-chat/native-chat-disclosure-store.ts
index 956ae3b0ca1a..53e4d315feb5 100644
--- a/src/renderer/src/components/native-chat/native-chat-disclosure-store.ts
+++ b/src/renderer/src/components/native-chat/native-chat-disclosure-store.ts
@@ -7,11 +7,13 @@
 // the reader's back. Rows read through this store when the transcript provides
 // one, and fall back to their own state when they are rendered standalone.
 
-import { createContext, useCallback, useContext, useMemo, useState } from 'react'
+import { createContext, useCallback, useContext, useId, useMemo, useState } from 'react'
 
 export type NativeChatDisclosureStore = {
   read: (key: string) => boolean | undefined
   write: (key: string, open: boolean) => void
+  /** Told whenever the reader opens or closes a row, keyed or not, and which one. */
+  onToggle?: (row: string, open: boolean) => void
 }
 
 export const NativeChatDisclosureContext = createContext<NativeChatDisclosureStore | null>(null)
@@ -54,6 +56,9 @@ export function useNativeChatDisclosure(
   const store = useContext(NativeChatDisclosureContext)
   const [local, setLocal] = useState({ key, initialOpen, open: initialOpen })
   const write = store?.write
+  const onToggle = store?.onToggle
+  const unkeyedRow = useId()
+  const row = key ?? unkeyedRow
   const isStored = key !== undefined && store !== null
   const localOpen =
     local.key === key && local.initialOpen === initialOpen ? local.open : initialOpen
@@ -64,8 +69,9 @@ export function useNativeChatDisclosure(
       if (key !== undefined && write) {
         write(key, next)
       }
+      onToggle?.(row, next)
     },
-    [initialOpen, key, write]
+    [initialOpen, key, onToggle, row, write]
   )
   return { open, setOpen }
 }
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..448c5054ee3a 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
@@ -22,15 +22,17 @@ function isEditableTarget(target: EventTarget): boolean {
 
 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. */
+ *  scrollbar grab. Focusable, so the scroll keys reach it; a named region once focused. */
 export function nativeChatReaderScrollInputHandlers(
   onReaderScroll: () => void
 ): NativeChatReaderScrollInputHandlers {
   return {
+    tabIndex: 0,
+    role: 'region',
     onWheel: onReaderScroll,
     onTouchMove: onReaderScroll,
     onKeyDown: (event) => {
diff --git a/src/renderer/src/components/native-chat/native-chat-send-reveal-ratchet.test.ts b/src/renderer/src/components/native-chat/native-chat-send-reveal-ratchet.test.ts
new file mode 100644
index 000000000000..1da480d95db7
--- /dev/null
+++ b/src/renderer/src/components/native-chat/native-chat-send-reveal-ratchet.test.ts
@@ -0,0 +1,22 @@
+import { readdirSync, readFileSync } from 'node:fs'
+import path from 'node:path'
+import { expect, it } from 'vitest'
+
+/** Files that send without revealing the latest, each with its reason. */
+const EXEMPT: Readonly<Record<string, string>> = {}
+
+// A send path that skips `onSubmitted` leaves a scrolled-up reader looking at old output.
+it('reveals the latest from every file that sends a native chat message', () => {
+  const dir = import.meta.dirname
+  const senders = readdirSync(dir, { recursive: true, encoding: 'utf8' })
+    .filter((name) => /\.tsx?$/.test(name) && !/\.test\.tsx?$/.test(name))
+    .map((name) => ({ name, source: readFileSync(path.join(dir, name), 'utf8') }))
+    .filter(({ source }) => source.includes('emitNativeChatMessageSent('))
+  const silent = senders
+    .filter(({ name, source }) => !(name in EXEMPT) && !/\bonSubmitted\?\.\(\)/.test(source))
+    .map(({ name }) => name)
+
+  // Anti-vacuous: the scan found the send sites.
+  expect(senders.length).toBeGreaterThan(0)
+  expect(silent).toEqual([])
+})
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 bbbf99d2a5d2..3d1e63d02c7f 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
@@ -29,9 +29,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 = {
@@ -53,7 +55,7 @@ function harness(options: {
       }),
     { initialProps: { draft: options.draft, caret: options.caret ?? options.draft.length } }
   )
-  return { hook, calls, onError }
+  return { hook, calls, onError, onSubmitted }
 }
 
 describe('composer goal mode', () => {
@@ -86,13 +88,15 @@ 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 } = harness({ draft: '/go', threadGoal: { setObjective } })
+    const { hook, calls, onSubmitted } = harness({ draft: '/go', threadGoal: { setObjective } })
     act(() => hook.result.current.goalMode.interceptPick(vi.fn())(GOAL_ITEM))
     hook.rerender({ draft: '  Ship the parser  ', caret: 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(calls.setDraft).toHaveBeenLastCalledWith('')
     expect(hook.result.current.goalMode.active).toBe(false)
@@ -100,7 +104,7 @@ 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 } = harness({ draft: '/go', threadGoal: { setObjective } })
+    const { hook, calls, onSubmitted } = harness({ draft: '/go', threadGoal: { setObjective } })
     act(() => hook.result.current.goalMode.interceptPick(vi.fn())(GOAL_ITEM))
     calls.setDraft.mockClear()
     hook.rerender({ draft: 'Ship the parser', caret: 0 })
@@ -108,6 +112,7 @@ describe('composer goal mode', () => {
     await act(async () => hook.result.current.send())
 
     expect(setObjective).toHaveBeenCalledOnce()
+    expect(onSubmitted).not.toHaveBeenCalled()
     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 7bf8ea7f8705..83f61abce9ed 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
@@ -89,6 +89,7 @@ export function useNativeChatComposerSubmit(args: {
         return
       }
       structuredTransport.onError(null)
+      structuredTransport.onSubmitted?.()
       setHistory((previous) => pushHistory(previous, draft))
       if (composition.current !== draft) {
         return
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 0022514fd974..cffff0a37ce3 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
@@ -24,6 +24,7 @@ export function useNativeChatPickerCommandDispatch(args: {
   isDispatchingSessionOption: boolean
   resolveTarget: () => NativeChatResolvedTarget | null
   onSlashCommand?: (command: string) => void
+  onSubmitted?: () => void
   sessionOptionsSurface: NativeChatPtySessionOptionsSurface | null
   trackPendingSend: NativeChatSendLifecycle['trackPendingSend']
   setHistory: Dispatch<SetStateAction<HistoryState>>
@@ -40,6 +41,7 @@ export function useNativeChatPickerCommandDispatch(args: {
     isDispatchingSessionOption,
     resolveTarget,
     onSlashCommand,
+    onSubmitted,
     sessionOptionsSurface,
     trackPendingSend,
     setHistory,
@@ -73,6 +75,7 @@ export function useNativeChatPickerCommandDispatch(args: {
         agent,
         runtime: nativeChatComposerTargetIsRemote(target.ptyId) ? 'remote' : 'local'
       })
+      onSubmitted?.()
       setHistory((previous) => pushHistory(previous, text))
       setDraft('')
       setCaret(0)
@@ -88,6 +91,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 385396190e4a..61048014a44a 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
@@ -34,6 +34,7 @@ export function useNativeChatPtyComposerSend(args: {
   onOptimisticSend?: (text: string, imagePaths?: string[]) => string | undefined
   optimisticSendOutcome?: NativeChatOptimisticSendOutcome
   onSlashCommand?: (command: string) => void
+  onSubmitted?: () => void
   sessionOptionsSurface: NativeChatPtySessionOptionsSurface | null
   terminalTabId: string
   trackPendingSend: NativeChatSendLifecycle['trackPendingSend']
@@ -121,6 +122,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..7bd0a8eb9cff 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',
+    jumpToStart: () => void = () => {},
+    isVisible = true
   ) => {
     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 }
@@ -306,3 +310,74 @@ 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', 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', 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', 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()
+  })
+
+  // 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 jumpToStart = vi.fn()
+    const { result, rerender } = renderHook(
+      ({ isVisible }: { isVisible: boolean }) =>
+        useLaneRailJump(vi.fn(), 'session-1', jumpToStart, isVisible),
+      { 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-reader-opens.test.ts b/src/renderer/src/components/native-chat/use-native-chat-reader-opens.test.ts
new file mode 100644
index 000000000000..a839525a27a2
--- /dev/null
+++ b/src/renderer/src/components/native-chat/use-native-chat-reader-opens.test.ts
@@ -0,0 +1,84 @@
+// @vitest-environment happy-dom
+import { act, renderHook } from '@testing-library/react'
+import { useState } from 'react'
+import { expect, it, vi } from 'vitest'
+import { useNativeChatReaderOpens } from './use-native-chat-reader-opens'
+
+function harness() {
+  const spies = {
+    readerOpened: vi.fn(),
+    readerClosed: vi.fn(),
+    abortNavigation: vi.fn(),
+    setSectionOpen: vi.fn(),
+    setRosterOpen: vi.fn()
+  }
+  const { result } = renderHook(() => {
+    const [expandedTurnIds, setExpandedTurnIds] = useState<ReadonlySet<string>>(new Set())
+    return useNativeChatReaderOpens({
+      subagentDisclosure: {
+        setSectionOpen: spies.setSectionOpen,
+        setRosterOpen: spies.setRosterOpen
+      },
+      expandedTurnIds,
+      setExpandedTurnIds,
+      follow: { readerOpened: spies.readerOpened, readerClosed: spies.readerClosed },
+      abortNavigation: spies.abortNavigation
+    })
+  })
+  const reacted = (): number => spies.readerOpened.mock.calls.length
+  return { result, spies, reacted }
+}
+
+// Each way a reader opens a row reports it under its own identity and abandons a history jump still paging.
+it.each([
+  [
+    'a disclosure',
+    'run:1',
+    (opens: ReturnType<typeof useNativeChatReaderOpens>) =>
+      opens.disclosures.onToggle?.('run:1', true)
+  ],
+  [
+    'a folded turn',
+    'turn:turn-1',
+    (opens: ReturnType<typeof useNativeChatReaderOpens>) => opens.toggleExpandedTurn('turn-1')
+  ],
+  [
+    'a subagent section',
+    'section:a',
+    (opens: ReturnType<typeof useNativeChatReaderOpens>) =>
+      opens.subagentDisclosure.setSectionOpen('a', true)
+  ],
+  [
+    'a subagent roster',
+    'roster:r',
+    (opens: ReturnType<typeof useNativeChatReaderOpens>) =>
+      opens.subagentDisclosure.setRosterOpen('r', true)
+  ]
+])('reacts to the reader opening %s', (_kind, row, open) => {
+  const { result, spies } = harness()
+  act(() => open(result.current))
+  expect(spies.readerOpened).toHaveBeenCalledExactlyOnceWith(row)
+  expect(spies.abortNavigation).toHaveBeenCalledOnce()
+})
+
+it('reports each close under the identity its open used, without stopping following again', () => {
+  const { result, spies, reacted } = harness()
+  act(() => result.current.toggleExpandedTurn('turn-1'))
+  expect(reacted()).toBe(1)
+
+  act(() => result.current.toggleExpandedTurn('turn-1'))
+  act(() => result.current.subagentDisclosure.setSectionOpen('a', false))
+  act(() => result.current.subagentDisclosure.setRosterOpen('r', false))
+
+  act(() => result.current.disclosures.onToggle?.('run:1', false))
+
+  expect(reacted()).toBe(1)
+  expect(spies.readerClosed.mock.calls).toEqual([
+    ['turn:turn-1'],
+    ['section:a'],
+    ['roster:r'],
+    ['run:1']
+  ])
+  expect(spies.setSectionOpen).toHaveBeenCalledWith('a', false)
+  expect(spies.setRosterOpen).toHaveBeenCalledWith('r', false)
+})
diff --git a/src/renderer/src/components/native-chat/use-native-chat-reader-opens.ts b/src/renderer/src/components/native-chat/use-native-chat-reader-opens.ts
new file mode 100644
index 000000000000..11db1f9eecb6
--- /dev/null
+++ b/src/renderer/src/components/native-chat/use-native-chat-reader-opens.ts
@@ -0,0 +1,75 @@
+// Every transcript row a reader can open, routed so that opening one stops the
+// transcript following its end, and abandons a history jump still paging: either
+// would slide what they opened off the screen. Each is reported under its own
+// identity, so closing the last row that stopped the following resumes it.
+
+import { useCallback, useMemo, type Dispatch, type SetStateAction } from 'react'
+import {
+  useNativeChatDisclosures,
+  type NativeChatDisclosureStore
+} from './native-chat-disclosure-store'
+import { toggleNativeChatExpandedKey } from './native-chat-expanded-keys'
+import type { NativeChatSubagentDisclosure } from './native-chat-subagent-sections'
+import type { NativeChatTranscriptScroll } from './use-native-chat-transcript-scroll'
+
+export function useNativeChatReaderOpens({
+  subagentDisclosure,
+  expandedTurnIds,
+  setExpandedTurnIds,
+  follow,
+  abortNavigation
+}: {
+  subagentDisclosure: NativeChatSubagentDisclosure
+  expandedTurnIds: ReadonlySet<string>
+  setExpandedTurnIds: Dispatch<SetStateAction<ReadonlySet<string>>>
+  follow: Pick<NativeChatTranscriptScroll, 'readerOpened' | 'readerClosed'>
+  abortNavigation: () => void
+}): {
+  disclosures: NativeChatDisclosureStore
+  subagentDisclosure: NativeChatSubagentDisclosure
+  toggleExpandedTurn: (turnKey: string) => void
+} {
+  const disclosures = useNativeChatDisclosures()
+  // Taken apart: the scroll result is a new object each render, its callbacks are not.
+  const { readerOpened, readerClosed } = follow
+  const readerToggled = useCallback(
+    (row: string, open: boolean) => {
+      if (!open) {
+        readerClosed(row)
+        return
+      }
+      abortNavigation()
+      readerOpened(row)
+    },
+    [abortNavigation, readerClosed, readerOpened]
+  )
+  const readerDisclosures = useMemo(
+    () => ({ ...disclosures, onToggle: readerToggled }),
+    [disclosures, readerToggled]
+  )
+  const readerSubagentDisclosure = useMemo<NativeChatSubagentDisclosure>(
+    () => ({
+      setSectionOpen: (agentId, open) => {
+        readerToggled(`section:${agentId}`, open)
+        subagentDisclosure.setSectionOpen(agentId, open)
+      },
+      setRosterOpen: (rosterRowId, open) => {
+        readerToggled(`roster:${rosterRowId}`, open)
+        subagentDisclosure.setRosterOpen(rosterRowId, open)
+      }
+    }),
+    [readerToggled, subagentDisclosure]
+  )
+  const toggleExpandedTurn = useCallback(
+    (turnKey: string) => {
+      readerToggled(`turn:${turnKey}`, !expandedTurnIds.has(turnKey))
+      setExpandedTurnIds((current) => toggleNativeChatExpandedKey(current, turnKey))
+    },
+    [expandedTurnIds, readerToggled, setExpandedTurnIds]
+  )
+  return {
+    disclosures: readerDisclosures,
+    subagentDisclosure: readerSubagentDisclosure,
+    toggleExpandedTurn
+  }
+}
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..1676a2c2d78a
--- /dev/null
+++ b/src/renderer/src/components/native-chat/use-native-chat-reveal-latest.ts
@@ -0,0 +1,17 @@
+// How a chat pane tells its transcript that the reader just sent something.
+
+import { useCallback, useRef } from 'react'
+
+export type NativeChatMessageListHandle = {
+  /** Bring the latest into view and follow it, wherever the reader had scrolled. */
+  revealLatest: () => void
+}
+
+export function useNativeChatRevealLatest(): {
+  messageListRef: React.RefObject<NativeChatMessageListHandle | null>
+  revealLatest: () => void
+} {
+  const messageListRef = useRef<NativeChatMessageListHandle>(null)
+  const revealLatest = useCallback(() => messageListRef.current?.revealLatest(), [])
+  return { messageListRef, 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..d8cb27250dff 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>())
@@ -112,6 +113,7 @@ export function useNativeChatSessionOptionCommand(args: {
           agent,
           runtime: nativeChatComposerTargetIsRemote(target.ptyId) ? 'remote' : 'local'
         })
+        onSubmitted?.()
         setHistory((previous) => pushHistory(previous, command))
         const outcome = observer ? await observer.result : undefined
         return { outcome }
@@ -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 39892a49219f..eae1617fd514 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,31 @@ describe('attachment guard follows what the host claims', () => {
     expect(structuredTransport.send).not.toHaveBeenCalled()
   })
 })
+
+// The pane brings the latest into view on this: a command the chat ran itself counts, a refusal does not.
+describe('reports only an accepted send as submitted', () => {
+  it('reports a host-run command, then not a message the transport refused', async () => {
+    const onSubmitted = vi.fn()
+    const { send, structuredTransport } = harness('claude', undefined, onSubmitted)
+    send('/compact', [])
+    await vi.waitFor(() => 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 f208e6cb4a93..65db86d5e433 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
@@ -63,6 +63,10 @@ export function useNativeChatStructuredComposerSend({
             return
           }
           emitNativeChatMessageSent({ agent, runtime: structuredTransport.runtime })
+          // An accepted command can still be one chat sessions don't run; nothing landed then.
+          if (!error) {
+            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..4d136b0abc77 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
@@ -34,6 +34,8 @@ function TranscriptHarness({
   return (
     <div ref={scrollRef} data-testid="scroll" onScroll={transcript.onScroll}>
       <div ref={contentRef} />
+      <button onClick={() => transcript.readerOpened('row')}>open</button>
+      <button onClick={() => transcript.readerClosed('row')}>close</button>
     </div>
   )
 }
@@ -130,4 +132,35 @@ describe('native chat transcript follow', () => {
 
     expect(scrollToEnd).toHaveBeenCalled()
   })
+
+  // A close that resizes nothing reaches no observer, so the close itself has to pin.
+  it('pins to the end the moment the reader closes the row that stopped it following', () => {
+    let scrollTop = 900
+    const scrollToEnd = vi.fn()
+    const view = render(
+      <TranscriptHarness isVisible restoreScrollOffset={vi.fn()} scrollToEnd={scrollToEnd} />
+    )
+    Object.defineProperties(view.getByTestId('scroll'), {
+      clientHeight: { configurable: true, get: () => 100 },
+      scrollHeight: { configurable: true, get: () => 1_400 },
+      scrollTop: { configurable: true, get: () => scrollTop, set: (value) => (scrollTop = value) }
+    })
+
+    fireEvent.click(view.getByText('open'))
+    scrollToEnd.mockClear()
+    view.rerender(
+      <TranscriptHarness
+        isVisible
+        restoreScrollOffset={vi.fn()}
+        scrollToEnd={scrollToEnd}
+        itemCount={101}
+      />
+    )
+    // Anti-vacuous: opening stopped the following, 400px from the end.
+    expect(scrollToEnd).not.toHaveBeenCalled()
+
+    fireEvent.click(view.getByText('close'))
+
+    expect(scrollToEnd).toHaveBeenCalledOnce()
+  })
 })
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..9c702efbcbce 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
@@ -9,8 +9,10 @@
 //
 // 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.
+// marks every application offset; follow intent changes only on a reader's own
+// act — an unmarked scroll, a navigation, or opening or closing a row — never from
+// delayed geometry alone. A detach remembers which act caused it: one caused only
+// by opening rows ends when the last of those rows closes, wherever the end is by then.
 
 import {
   useCallback,
@@ -22,8 +24,10 @@ import {
 } from 'react'
 import {
   distanceFromBottom,
-  nextFollowingEnd,
+  FOLLOWING,
+  nextFollowState,
   shouldShowJumpToLatest,
+  type FollowEvent,
   type ScrollGeometry
 } from './native-chat-autoscroll'
 
@@ -41,10 +45,17 @@ 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
+  /** The reader opened a row to read it: leave it where it is. */
+  readerOpened: (row: string) => void
+  /** The reader closed a row: follow again if only their opens had stopped it. */
+  readerClosed: (row: string) => void
 }
 
 export function useNativeChatTranscriptScroll({
@@ -74,12 +85,19 @@ export function useNativeChatTranscriptScroll({
   reconcileReaderScroll: (isTakingOver: boolean) => void
 }): NativeChatTranscriptScroll {
   const [showJump, setShowJump] = useState(false)
-  const followingRef = useRef(true)
+  const [awayFromTop, setAwayFromTop] = useState(false)
+  const followRef = useRef(FOLLOWING)
   const detachedScrollTopRef = useRef<number | null>(null)
   const isVisibleRef = useRef(isVisible)
   const previousIsVisibleRef = useRef(isVisible)
   const previousDistanceFromEndRef = useRef(Number.POSITIVE_INFINITY)
 
+  /** Applies a reader's act; true when the transcript follows its end afterwards. */
+  const follow = useCallback((event: FollowEvent): boolean => {
+    followRef.current = nextFollowState(followRef.current, event)
+    return followRef.current.kind === 'following'
+  }, [])
+
   const syncScrollState = useCallback(
     (event?: Event): ScrollGeometry | null => {
       const element = scrollRef.current
@@ -88,24 +106,25 @@ export function useNativeChatTranscriptScroll({
       }
       const geometry = geometryOf(element)
       if (event) {
-        const wasFollowing = followingRef.current
+        const wasFollowing = followRef.current.kind === 'following'
         const programmatic = consumeProgrammaticScroll(event)
-        const following = nextFollowingEnd({
-          following: followingRef.current,
+        const following = follow({
+          kind: 'scroll',
           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))
+      const following = followRef.current.kind === 'following'
+      detachedScrollTopRef.current = following ? null : geometry.scrollTop
+      setShowJump(shouldShowJumpToLatest(following, geometry))
+      setAwayFromTop(geometry.scrollTop > geometry.clientHeight)
       return geometry
     },
-    [consumeProgrammaticScroll, reconcileReaderScroll, scrollRef]
+    [consumeProgrammaticScroll, follow, reconcileReaderScroll, scrollRef]
   )
 
   const onScroll = useCallback<UIEventHandler<HTMLDivElement>>(
@@ -125,17 +144,47 @@ export function useNativeChatTranscriptScroll({
   }, [scrollRef, scrollToEnd])
 
   const scrollToBottom = useCallback(() => {
-    followingRef.current = true
+    follow({ kind: 'reveal-latest' })
     scrollToEndWhenMeasurable()
     setShowJump(false)
-  }, [scrollToEndWhenMeasurable])
+  }, [follow, scrollToEndWhenMeasurable])
+
+  const scrollToTop = useCallback(() => {
+    follow({ kind: 'navigate' })
+    // Also where a hidden pane lands once revealed, since the write below waits for layout.
+    detachedScrollTopRef.current = 0
+    restoreScrollOffset(0)
+  }, [follow, restoreScrollOffset])
 
   const scrollMessageToTop = useCallback(
     (element: HTMLElement) => {
-      followingRef.current = false
+      follow({ kind: 'navigate' })
       alignToViewportTop(element)
     },
-    [alignToViewportTop]
+    [alignToViewportTop, follow]
+  )
+
+  const readerOpened = useCallback(
+    (row: string) => {
+      follow({ kind: 'open', row })
+      syncScrollState()
+    },
+    [follow, syncScrollState]
+  )
+
+  // Read at close time: the pin is rebuilt on a reveal, and every row's toggle hangs off this.
+  const scrollToBottomRef = useRef(scrollToBottom)
+  useEffect(() => {
+    scrollToBottomRef.current = scrollToBottom
+  })
+  const readerClosed = useCallback(
+    (row: string) => {
+      const wasFollowing = followRef.current.kind === 'following'
+      if (follow({ kind: 'close', row }) && !wasFollowing) {
+        scrollToBottomRef.current()
+      }
+    },
+    [follow]
   )
 
   useLayoutEffect(() => {
@@ -145,7 +194,7 @@ export function useNativeChatTranscriptScroll({
     if (!isVisible) {
       return
     }
-    if (!followingRef.current) {
+    if (followRef.current.kind !== 'following') {
       if (revealed && detachedScrollTopRef.current !== null) {
         restoreScrollOffset(detachedScrollTopRef.current)
       }
@@ -167,7 +216,7 @@ export function useNativeChatTranscriptScroll({
       return
     }
     const observer = new ResizeObserver(() => {
-      if (followingRef.current) {
+      if (followRef.current.kind === 'following') {
         scrollToEndWhenMeasurable()
       } else {
         syncScrollState()
@@ -182,5 +231,14 @@ export function useNativeChatTranscriptScroll({
     return () => observer.disconnect()
   }, [contentRef, scrollRef, scrollToEndWhenMeasurable, syncScrollState])
 
-  return { showJump, onScroll, scrollToBottom, scrollMessageToTop }
+  return {
+    showJump,
+    awayFromTop,
+    onScroll,
+    scrollToBottom,
+    scrollToTop,
+    scrollMessageToTop,
+    readerOpened,
+    readerClosed
+  }
 }
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 495cdd87cfe3..c0089b55f2ae 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
@@ -13,6 +13,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'
@@ -101,6 +102,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]
@@ -264,17 +266,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-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..75ed46de6e31
--- /dev/null
+++ b/src/renderer/src/components/native-chat/use-structured-native-chat-submit-reveal.test.ts
@@ -0,0 +1,35 @@
+// @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'
+
+// Submits outside the composer: each is the reader acting, so each brings the latest into view.
+it('reveals the latest for a delivery Retry, a launch Retry and a queue Resume, before they act', async () => {
+  const order: string[] = []
+  const controller = {
+    respond: vi.fn(async () => null),
+    retry: vi.fn(() => order.push('retry')),
+    queuedMessages: {
+      cards: [],
+      pause: null,
+      resuming: false,
+      resume: vi.fn(async () => {
+        order.push('resume')
+      }),
+      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', 'reveal', 'resume'])
+})
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..acb116ef9b66
--- /dev/null
+++ b/src/renderer/src/components/native-chat/use-structured-native-chat-submit-reveal.ts
@@ -0,0 +1,89 @@
+// A structured pane's own submits outside the composer — retrying a delivery or a
+// failed start, answering a prompt, sending a queued message now, resuming the queue — each
+// bring the latest into view, wherever the reader had scrolled. An answer waits
+// for the host to accept it, as a composer send does; the others report no outcome.
+// The host delivering on its own (a mobile send, the queue draining) is not the
+// reader acting here, so it never moves them.
+
+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's transport, which knows when a send was accepted. */
+  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']>(
+    async (...args) => {
+      const result = await respond(...args)
+      // Null is a refused or failed answer: nothing was sent, so the reader stays put.
+      if (result !== null) {
+        revealLatest()
+      }
+      return result
+    },
+    [respond, revealLatest]
+  )
+  const revealingQueue = useMemo<StructuredAgentSessionQueuedMessagesController>(
+    () => ({
+      ...queuedMessages,
+      steer: (messageId) => {
+        revealLatest()
+        return queuedMessages.steer(messageId)
+      },
+      resume: () => {
+        revealLatest()
+        return queuedMessages.resume()
+      },
+      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 e2038632d5a8..2e80be006554 100644
--- a/src/renderer/src/i18n/locales/en.json
+++ b/src/renderer/src/i18n/locales/en.json
@@ -17953,6 +17953,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 0ed1d209c1ec..88e7fd612dc4 100644
--- a/src/renderer/src/i18n/locales/es.json
+++ b/src/renderer/src/i18n/locales/es.json
@@ -15129,6 +15129,8 @@
         "failedAfter": "Falló tras {{value0}}"
       },
       "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 afaef580140a..ab1ce09f6804 100644
--- a/src/renderer/src/i18n/locales/fr.json
+++ b/src/renderer/src/i18n/locales/fr.json
@@ -17677,6 +17677,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 3f9aed9a8225..d86a14b8f51f 100644
--- a/src/renderer/src/i18n/locales/ja.json
+++ b/src/renderer/src/i18n/locales/ja.json
@@ -17614,6 +17614,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 33c5f8c86b96..3e0837122b53 100644
--- a/src/renderer/src/i18n/locales/ko.json
+++ b/src/renderer/src/i18n/locales/ko.json
@@ -17614,6 +17614,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 b3bf3c86ed1a..c2dc56208579 100644
--- a/src/renderer/src/i18n/locales/zh.json
+++ b/src/renderer/src/i18n/locales/zh.json
@@ -17631,6 +17631,8 @@
         "toggleDetails": "切换回合详情"
       },
       "jumpToLatest": "跳到最新消息",
+      "jumpToTop": "跳转到顶部",
+      "transcriptLabel": "对话",
       "toggle": {
         "showTerminal": "显示终端",
         "showChat": "显示聊天视图"

From ffd54053686ecafb36b74989f45527126aa39d8f Mon Sep 17 00:00:00 2001
From: Kelvin Amoaba <97001695+AmoabaKelvin@users.noreply.github.com>
Date: Fri, 2 Oct 2026 04:54:25 +0000
Subject: [PATCH 02/14] fix(native-chat): a late or unsent answer no longer
 moves a reader who scrolled away

An answer's reveal is now held from the click and dropped if the reader acts before the host accepts. In the terminal lane, an answer with no terminal to write to reveals nothing.
---
 ...ChatMessageList.reader-navigation.test.tsx | 29 +++++++++++++++++++
 .../native-chat/NativeChatMessageList.tsx     |  5 ++--
 ...iveChatResolvedView.reveal-latest.test.tsx | 28 ++++++++++++++++--
 .../native-chat/NativeChatResolvedView.tsx    | 11 +++++--
 ...tiveChatStructuredSession.test-harness.tsx |  8 +++--
 .../use-native-chat-reveal-latest.ts          | 24 +++++++++++++--
 .../use-native-chat-transcript-scroll.ts      | 18 +++++++++++-
 ...ructured-native-chat-submit-reveal.test.ts |  5 +++-
 ...se-structured-native-chat-submit-reveal.ts | 10 ++++---
 9 files changed, 121 insertions(+), 17 deletions(-)

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
index 42bfbf2d1458..ae7cd5a7c83a 100644
--- a/src/renderer/src/components/native-chat/NativeChatMessageList.reader-navigation.test.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatMessageList.reader-navigation.test.tsx
@@ -170,6 +170,35 @@ describe('reader navigation', () => {
     expect(screen.queryByRole('button', { name: 'Jump to latest' })).toBeNull()
   })
 
+  it('drops a reveal held for a slow send once the reader scrolls away again', () => {
+    const handle = createRef<NativeChatMessageListHandle>()
+    const { container } = render(
+      <NativeChatMessageList
+        ref={handle}
+        session={session(transcript)}
+        isWorking
+        expandSignal={false}
+        fontScale={1}
+      />
+    )
+    paint(container)
+    scrollTranscript(container, 1000)
+    paint(container)
+    const lapsed = handle.current?.holdRevealLatest()
+    scrollTranscript(container, 600)
+    paint(container)
+    const scrollTop = scrollRoot(container).scrollTop
+    act(() => lapsed?.())
+    paint(container)
+    expect(scrollRoot(container).scrollTop).toBe(scrollTop)
+
+    // Anti-vacuous: one the reader leaves alone still lands on the end.
+    const kept = handle.current?.holdRevealLatest()
+    act(() => kept?.())
+    paint(container)
+    expect(distanceFromBottom(container)).toBe(0)
+  })
+
   it('leaves a tool run the reader opens where it is while the turn streams on', () => {
     const toolIndex = TRANSCRIPT_LENGTH
     const withTool: NativeChatMessage[] = [
diff --git a/src/renderer/src/components/native-chat/NativeChatMessageList.tsx b/src/renderer/src/components/native-chat/NativeChatMessageList.tsx
index d3b730a27eca..ae9464cc457a 100644
--- a/src/renderer/src/components/native-chat/NativeChatMessageList.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatMessageList.tsx
@@ -1,4 +1,4 @@
-import { useCallback, useImperativeHandle, useLayoutEffect, useMemo, useRef, useState } from 'react'
+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'
@@ -41,6 +41,7 @@ import { useNativeChatRailHistoryJump } from './use-native-chat-rail-history-jum
 import { nativeChatReaderScrollInputHandlers } from './native-chat-reader-scroll-input'
 import { NativeChatJumpControls } from './NativeChatJumpControls'
 import { useNativeChatReaderOpens } from './use-native-chat-reader-opens'
+import { useNativeChatMessageListHandle } from './use-native-chat-reveal-latest'
 import type { NativeChatMessageListHandle } from './use-native-chat-reveal-latest'
 
 import type {
@@ -307,7 +308,7 @@ export function NativeChatMessageList({
     beginNavigation()
     scrollToBottom()
   }, [beginNavigation, scrollToBottom])
-  useImperativeHandle(ref, () => ({ revealLatest: jumpToLatest }), [jumpToLatest])
+  useNativeChatMessageListHandle(ref, jumpToLatest, transcriptScroll.untilReaderActs)
   const readerScrollInput = useMemo(
     () => nativeChatReaderScrollInputHandlers(beginNavigation),
     [beginNavigation]
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
index 8f01e7fd6f67..f07eede9e71f 100644
--- a/src/renderer/src/components/native-chat/NativeChatResolvedView.reveal-latest.test.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatResolvedView.reveal-latest.test.tsx
@@ -5,6 +5,7 @@ import { cleanup, render } from '@testing-library/react'
 import { useImperativeHandle } from 'react'
 import type { NativeChatLiveSession } from './use-native-chat-live-session'
 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.
@@ -21,8 +22,11 @@ vi.mock('./use-native-chat-retained-session', () => ({
   useNativeChatRetainedSession: () => stubs.session
 }))
 vi.mock('./NativeChatMessageList', () => ({
-  NativeChatMessageList: (props: { ref?: React.Ref<{ revealLatest: () => void }> }) => {
-    useImperativeHandle(props.ref, () => ({ revealLatest: stubs.revealLatest }))
+  NativeChatMessageList: (props: { ref?: React.Ref<NativeChatMessageListHandle> }) => {
+    useImperativeHandle(props.ref, () => ({
+      revealLatest: stubs.revealLatest,
+      holdRevealLatest: () => stubs.revealLatest
+    }))
     return null
   }
 }))
@@ -103,4 +107,24 @@ describe('NativeChatResolvedView sends', () => {
     stubs.cardSend?.cancel()
     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({ questions: [] }, [])
+    stubs.cardSend?.sendRaw('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 587552fd11ac..77812cc167e2 100644
--- a/src/renderer/src/components/native-chat/NativeChatResolvedView.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatResolvedView.tsx
@@ -124,18 +124,23 @@ export function NativeChatResolvedView({
   const { messageListRef, revealLatest } = useNativeChatRevealLatest()
   const interactiveSend = useMemo<NativeChatInteractiveSend>(
     () => ({
+      // Without a terminal nothing is written, so the reader stays put.
       sendAnswer: (...args) => {
-        revealLatest()
+        if (targetPtyId) {
+          revealLatest()
+        }
         return sendAnswer(...args)
       },
       sendRaw: (raw) => {
-        revealLatest()
+        if (targetPtyId) {
+          revealLatest()
+        }
         sendRaw(raw)
       },
       cancelPending,
       cancel
     }),
-    [cancel, cancelPending, revealLatest, sendAnswer, sendRaw]
+    [cancel, cancelPending, revealLatest, sendAnswer, sendRaw, targetPtyId]
   )
   const [workingInterrupted, setWorkingInterrupted] = useState(false)
   const previousWorkingEpochRef = useRef<number | null>(null)
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 ea56db918357..67c6ef8cf804 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 { NativeChatOlderPageResult } from './native-chat-pagination'
 import type { StructuredAgentSessionThreadGoal } from './use-structured-agent-session-thread-goal'
 import type { StructuredAgentSessionLaunchLifecycle } from '@/lib/structured-agent-session-launch'
@@ -89,7 +90,7 @@ export function seedOutbox(sessionId: string, entries: unknown[]): void {
 }
 
 type StructuredSessionMessageListProps = {
-  ref?: React.Ref<{ revealLatest: () => void }>
+  ref?: React.Ref<NativeChatMessageListHandle>
   allowFileUriLinks?: boolean
   isVisible?: boolean
   onLinkClick?: (...args: unknown[]) => void
@@ -303,7 +304,10 @@ export function createStructuredSessionMocks() {
     nativeChatMessageList: () => ({
       NativeChatMessageList: (props: typeof mocks.messageListProps) => {
         mocks.messageListProps = props
-        useImperativeHandle(props?.ref, () => ({ revealLatest: mocks.revealLatest }))
+        useImperativeHandle(props?.ref, () => ({
+          revealLatest: mocks.revealLatest,
+          holdRevealLatest: () => mocks.revealLatest
+        }))
         return <DeliveryNoticesMock notices={props?.deliveryNotices} />
       }
     }),
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
index 1676a2c2d78a..68557e00524d 100644
--- 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
@@ -1,17 +1,37 @@
 // How a chat pane tells its transcript that the reader just sent something.
 
-import { useCallback, useRef } from 'react'
+import { useCallback, useImperativeHandle, useRef } from 'react'
 
 export type NativeChatMessageListHandle = {
   /** Bring the latest into view and follow it, wherever the reader had scrolled. */
   revealLatest: () => void
+  /** For a send whose outcome arrives later: a reveal that lapses if the reader acts first. */
+  holdRevealLatest: () => () => void
 }
 
 export function useNativeChatRevealLatest(): {
   messageListRef: React.RefObject<NativeChatMessageListHandle | null>
   revealLatest: () => void
+  holdRevealLatest: () => () => void
 } {
   const messageListRef = useRef<NativeChatMessageListHandle>(null)
   const revealLatest = useCallback(() => messageListRef.current?.revealLatest(), [])
-  return { messageListRef, revealLatest }
+  const holdRevealLatest = useCallback(
+    () => messageListRef.current?.holdRevealLatest() ?? (() => {}),
+    []
+  )
+  return { messageListRef, revealLatest, holdRevealLatest }
+}
+
+/** The transcript's side: what a pane's reveal does to this list. */
+export function useNativeChatMessageListHandle(
+  ref: React.Ref<NativeChatMessageListHandle> | undefined,
+  revealLatest: () => void,
+  untilReaderActs: (act: () => void) => () => void
+): void {
+  useImperativeHandle(
+    ref,
+    () => ({ revealLatest, holdRevealLatest: () => untilReaderActs(revealLatest) }),
+    [revealLatest, untilReaderActs]
+  )
 }
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 9c702efbcbce..034acaae8bb0 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
@@ -56,6 +56,8 @@ export type NativeChatTranscriptScroll = {
   readerOpened: (row: string) => void
   /** The reader closed a row: follow again if only their opens had stopped it. */
   readerClosed: (row: string) => void
+  /** Wraps an act so it lapses if the reader acts first. */
+  untilReaderActs: (act: () => void) => () => void
 }
 
 export function useNativeChatTranscriptScroll({
@@ -93,7 +95,11 @@ export function useNativeChatTranscriptScroll({
   const previousDistanceFromEndRef = useRef(Number.POSITIVE_INFINITY)
 
   /** Applies a reader's act; true when the transcript follows its end afterwards. */
+  const readerActsRef = useRef(0)
   const follow = useCallback((event: FollowEvent): boolean => {
+    if (event.kind !== 'scroll' || !event.programmatic) {
+      readerActsRef.current += 1
+    }
     followRef.current = nextFollowState(followRef.current, event)
     return followRef.current.kind === 'following'
   }, [])
@@ -187,6 +193,15 @@ export function useNativeChatTranscriptScroll({
     [follow]
   )
 
+  const untilReaderActs = useCallback((act: () => void) => {
+    const acts = readerActsRef.current
+    return () => {
+      if (readerActsRef.current === acts) {
+        act()
+      }
+    }
+  }, [])
+
   useLayoutEffect(() => {
     const revealed = isVisible && !previousIsVisibleRef.current
     isVisibleRef.current = isVisible
@@ -239,6 +254,7 @@ export function useNativeChatTranscriptScroll({
     scrollToTop,
     scrollMessageToTop,
     readerOpened,
-    readerClosed
+    readerClosed,
+    untilReaderActs
   }
 }
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
index 75ed46de6e31..eabe7f935680 100644
--- 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
@@ -24,7 +24,10 @@ it('reveals the latest for a delivery Retry, a launch Retry and a queue Resume,
   }
   const retryLaunch = (): number => order.push('launch')
   const { result } = renderHook(() => useStructuredNativeChatSubmitReveal(controller, retryLaunch))
-  result.current.messageListRef.current = { revealLatest: () => order.push('reveal') }
+  result.current.messageListRef.current = {
+    revealLatest: () => order.push('reveal'),
+    holdRevealLatest: () => () => order.push('reveal')
+  }
 
   act(() => result.current.retryDelivery('client-1'))
   act(() => result.current.retryLaunch())
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
index acb116ef9b66..8196d195210b 100644
--- 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
@@ -1,7 +1,7 @@
 // A structured pane's own submits outside the composer — retrying a delivery or a
 // failed start, answering a prompt, sending a queued message now, resuming the queue — each
 // bring the latest into view, wherever the reader had scrolled. An answer waits
-// for the host to accept it, as a composer send does; the others report no outcome.
+// for the host to accept it, unless the reader moved meanwhile; the others report no outcome.
 // The host delivering on its own (a mobile send, the queue draining) is not the
 // reader acting here, so it never moves them.
 
@@ -28,7 +28,7 @@ export function useStructuredNativeChatSubmitReveal(
   respond: StructuredController['respond']
   queuedMessages: StructuredAgentSessionQueuedMessagesController
 } {
-  const { messageListRef, revealLatest } = useNativeChatRevealLatest()
+  const { messageListRef, revealLatest, holdRevealLatest } = 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)
@@ -48,14 +48,16 @@ export function useStructuredNativeChatSubmitReveal(
   }, [retryLaunch, revealLatest])
   const revealingRespond = useCallback<StructuredController['respond']>(
     async (...args) => {
+      // Held from the click: a reader who scrolls away while the host decides stays there.
+      const reveal = holdRevealLatest()
       const result = await respond(...args)
       // Null is a refused or failed answer: nothing was sent, so the reader stays put.
       if (result !== null) {
-        revealLatest()
+        reveal()
       }
       return result
     },
-    [respond, revealLatest]
+    [holdRevealLatest, respond]
   )
   const revealingQueue = useMemo<StructuredAgentSessionQueuedMessagesController>(
     () => ({

From 70a02d518b8392546e40feceabee2f2a52bd439c Mon Sep 17 00:00:00 2001
From: Kelvin Amoaba <97001695+AmoabaKelvin@users.noreply.github.com>
Date: Fri, 2 Oct 2026 04:56:43 +0000
Subject: [PATCH 03/14] fix(native-chat): an empty answer no longer moves the
 reader

The terminal lane's reveal now uses the same check the send does, and the send-site guard test ignores comments.
---
 .../NativeChatResolvedView.reveal-latest.test.tsx    | 12 ++++++++++--
 .../native-chat/NativeChatResolvedView.tsx           |  9 +++++----
 .../native-chat-send-reveal-ratchet.test.ts          |  6 +++++-
 3 files changed, 20 insertions(+), 7 deletions(-)

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
index f07eede9e71f..a80b07535a44 100644
--- a/src/renderer/src/components/native-chat/NativeChatResolvedView.reveal-latest.test.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatResolvedView.reveal-latest.test.tsx
@@ -4,6 +4,7 @@ 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'
 
@@ -60,6 +61,10 @@ afterEach(() => {
   stubs.cardSend = null
 })
 
+const prompt: AskPrompt = {
+  questions: [{ question: 'Indent with?', multiSelect: false, options: [{ label: 'Tabs' }] }]
+}
+
 describe('NativeChatResolvedView sends', () => {
   it('brings the latest into view for a composer send and a prompt answer, not a Stop', () => {
     stubs.session = {
@@ -100,7 +105,10 @@ describe('NativeChatResolvedView sends', () => {
     stubs.composer?.onSubmitted?.()
     expect(stubs.revealLatest).toHaveBeenCalledOnce()
     // A question answer and an approval option, then Stop: only the answers are sends.
-    stubs.cardSend?.sendAnswer({ questions: [] }, [])
+    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)
     stubs.cardSend?.sendRaw('1')
     expect(stubs.revealLatest).toHaveBeenCalledTimes(3)
@@ -122,7 +130,7 @@ describe('NativeChatResolvedView sends', () => {
         ownsTabWideLaunchDraft={false}
       />
     )
-    stubs.cardSend?.sendAnswer({ questions: [] }, [])
+    stubs.cardSend?.sendAnswer(prompt, [{ indices: [0] }])
     stubs.cardSend?.sendRaw('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 77812cc167e2..6ca0eaa23c19 100644
--- a/src/renderer/src/components/native-chat/NativeChatResolvedView.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatResolvedView.tsx
@@ -13,6 +13,7 @@ import { useNativeChatFontScale } from './use-native-chat-font-scale'
 import { useNativeChatCanSend } from './use-native-chat-can-send'
 import { NativeChatInteractiveCard } from './NativeChatInteractiveCard'
 import { useNativeChatInteractivePromptCard } from './use-native-chat-interactive-prompt-card'
+import { hasAskAnswer } from './native-chat-interactive-prompt'
 import { NativeChatEmptyState } from './NativeChatEmptyState'
 import {
   useNativeChatInteractiveSend,
@@ -124,12 +125,12 @@ export function NativeChatResolvedView({
   const { messageListRef, revealLatest } = useNativeChatRevealLatest()
   const interactiveSend = useMemo<NativeChatInteractiveSend>(
     () => ({
-      // Without a terminal nothing is written, so the reader stays put.
-      sendAnswer: (...args) => {
-        if (targetPtyId) {
+      // 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(...args)
+        return sendAnswer(prompt, selections, onDeliverySettled)
       },
       sendRaw: (raw) => {
         if (targetPtyId) {
diff --git a/src/renderer/src/components/native-chat/native-chat-send-reveal-ratchet.test.ts b/src/renderer/src/components/native-chat/native-chat-send-reveal-ratchet.test.ts
index 1da480d95db7..d03414687415 100644
--- a/src/renderer/src/components/native-chat/native-chat-send-reveal-ratchet.test.ts
+++ b/src/renderer/src/components/native-chat/native-chat-send-reveal-ratchet.test.ts
@@ -10,7 +10,11 @@ it('reveals the latest from every file that sends a native chat message', () =>
   const dir = import.meta.dirname
   const senders = readdirSync(dir, { recursive: true, encoding: 'utf8' })
     .filter((name) => /\.tsx?$/.test(name) && !/\.test\.tsx?$/.test(name))
-    .map((name) => ({ name, source: readFileSync(path.join(dir, name), 'utf8') }))
+    // Comments dropped, so only a real call counts.
+    .map((name) => ({
+      name,
+      source: readFileSync(path.join(dir, name), 'utf8').replace(/\/\/.*$/gm, '')
+    }))
     .filter(({ source }) => source.includes('emitNativeChatMessageSent('))
   const silent = senders
     .filter(({ name, source }) => !(name in EXEMPT) && !/\bonSubmitted\?\.\(\)/.test(source))

From f351fc5e0ce9ce77007295b05bd3ae9369dd0ac0 Mon Sep 17 00:00:00 2001
From: Neil <4138956+nwparker@users.noreply.github.com>
Date: Sun, 4 Oct 2026 22:51:01 -0700
Subject: [PATCH 04/14] fix(native-chat): preserve upstream retry and question
 cancellation

---
 ...iveChatResolvedView.reveal-latest.test.tsx |  1 +
 .../native-chat/NativeChatResolvedView.tsx    |  5 ++--
 .../NativeChatStructuredSession.test.tsx      | 27 +++++++++++++++++++
 .../NativeChatStructuredSession.tsx           |  2 +-
 4 files changed, 32 insertions(+), 3 deletions(-)

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
index a80b07535a44..1c9c3329c09b 100644
--- a/src/renderer/src/components/native-chat/NativeChatResolvedView.reveal-latest.test.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatResolvedView.reveal-latest.test.tsx
@@ -36,6 +36,7 @@ vi.mock('./use-native-chat-interactive-send', () => ({
     sendAnswer: () => ({ settleAfterMs: 0, waitsForVerifiedDelivery: false }),
     sendRaw: () => {},
     cancelPending: () => {},
+    cancelAsk: () => {},
     cancel: () => {}
   })
 }))
diff --git a/src/renderer/src/components/native-chat/NativeChatResolvedView.tsx b/src/renderer/src/components/native-chat/NativeChatResolvedView.tsx
index 6ca0eaa23c19..e693f2c11f85 100644
--- a/src/renderer/src/components/native-chat/NativeChatResolvedView.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatResolvedView.tsx
@@ -115,7 +115,7 @@ 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 { sendAnswer, sendRaw, cancelPending, cancel } = useNativeChatInteractiveSend(
+  const { sendAnswer, sendRaw, cancelPending, cancelAsk, cancel } = useNativeChatInteractiveSend(
     terminalTabId,
     paneKey,
     targetPtyId,
@@ -139,9 +139,10 @@ export function NativeChatResolvedView({
         sendRaw(raw)
       },
       cancelPending,
+      cancelAsk,
       cancel
     }),
-    [cancel, cancelPending, revealLatest, sendAnswer, sendRaw, targetPtyId]
+    [cancel, cancelAsk, cancelPending, revealLatest, sendAnswer, sendRaw, targetPtyId]
   )
   const [workingInterrupted, setWorkingInterrupted] = useState(false)
   const previousWorkingEpochRef = useRef<number | null>(null)
diff --git a/src/renderer/src/components/native-chat/NativeChatStructuredSession.test.tsx b/src/renderer/src/components/native-chat/NativeChatStructuredSession.test.tsx
index cec62ef95b67..1f806e7bdca4 100644
--- a/src/renderer/src/components/native-chat/NativeChatStructuredSession.test.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatStructuredSession.test.tsx
@@ -29,6 +29,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'
 
 describe('NativeChatStructuredSession', () => {
   afterEach(() => {
@@ -662,6 +663,32 @@ describe('NativeChatStructuredSession', () => {
     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' }
diff --git a/src/renderer/src/components/native-chat/NativeChatStructuredSession.tsx b/src/renderer/src/components/native-chat/NativeChatStructuredSession.tsx
index e1ebaa3a6870..342c5db03b42 100644
--- a/src/renderer/src/components/native-chat/NativeChatStructuredSession.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatStructuredSession.tsx
@@ -121,7 +121,7 @@ export function NativeChatStructuredSession(
     journalItems: controller.journalItems,
     failedHere: controller.failedHere,
     queuedMessageIds: controller.queuedMessageIds,
-    retry: controller.retry,
+    retry: retryDelivery,
     agentName: agentLabel
   })
   const viewState = selectNativeChatViewState(session, { readRetries: true })

From b5974c11a87b23e7e82a350b984b0dad4d1cdf69 Mon Sep 17 00:00:00 2001
From: Brennan Benson <79079362+brennanb2025@users.noreply.github.com>
Date: Mon, 5 Oct 2026 15:23:00 -0700
Subject: [PATCH 05/14] refactor(native-chat): leave Jump to top out of this
 change

Jump to top moves to its own PR so this one lands the send reveal and
follow behaviour on their own.
---
 .../NativeChatJumpControls.test.tsx           | 63 ++++----------
 .../native-chat/NativeChatJumpControls.tsx    | 47 +---------
 ...eChatMessageList.growth-windowing.test.tsx |  3 +-
 ...MessageList.interrupted-turn-fold.test.tsx |  3 +-
 ...essageList.message-rail-windowing.test.tsx |  3 +-
 ...tiveChatMessageList.older-history.test.tsx |  3 +-
 ...atMessageList.provider-retry-runs.test.tsx |  3 +-
 ...ChatMessageList.queued-turn-order.test.tsx |  3 +-
 ...ChatMessageList.rail-history-jump.test.tsx | 53 +-----------
 ...ChatMessageList.reader-navigation.test.tsx | 22 +----
 ...hatMessageList.stream-render.perf.test.tsx |  3 +-
 ...ChatMessageList.subagent-sections.test.tsx |  3 +-
 ...eChatMessageList.task-list-frames.test.tsx |  3 +-
 .../NativeChatMessageList.test.tsx            |  3 +-
 ...eChatMessageList.tool-stream-cost.test.tsx |  3 +-
 .../native-chat/NativeChatMessageList.tsx     |  5 +-
 .../NativeChatMessageList.turn-fold.test.tsx  |  3 +-
 ...ativeChatMessageList.turn-history.test.tsx |  3 +-
 ...iveChatMessageList.turn-indicator.test.tsx |  3 +-
 ...veChatMessageList.turn-membership.test.tsx |  3 +-
 ...NativeChatMessageList.turn-timing.test.tsx |  3 +-
 ...iveChatMessageList.unsent-message.test.tsx |  3 +-
 .../NativeChatMessageList.windowing.test.tsx  |  3 +-
 ...ativeChatResolvedView.turn-status.test.tsx |  3 +-
 .../native-chat-app-root-test-render.tsx      | 12 ---
 .../use-native-chat-rail-history-jump.test.ts | 86 ++++---------------
 .../use-native-chat-rail-history-jump.ts      | 69 +++++----------
 .../use-native-chat-transcript-scroll.ts      | 14 ---
 src/renderer/src/i18n/locales/en.json         |  1 -
 src/renderer/src/i18n/locales/es.json         |  1 -
 src/renderer/src/i18n/locales/fr.json         |  1 -
 src/renderer/src/i18n/locales/ja.json         |  1 -
 src/renderer/src/i18n/locales/ko.json         |  1 -
 src/renderer/src/i18n/locales/zh.json         |  1 -
 34 files changed, 80 insertions(+), 354 deletions(-)
 delete mode 100644 src/renderer/src/components/native-chat/native-chat-app-root-test-render.tsx

diff --git a/src/renderer/src/components/native-chat/NativeChatJumpControls.test.tsx b/src/renderer/src/components/native-chat/NativeChatJumpControls.test.tsx
index 381e3abb652f..b280987dcc4b 100644
--- a/src/renderer/src/components/native-chat/NativeChatJumpControls.test.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatJumpControls.test.tsx
@@ -6,62 +6,29 @@ import { cleanup, render, screen } from '@testing-library/react'
 import userEvent from '@testing-library/user-event'
 import { createRef } from 'react'
 import { afterEach, expect, it, vi } from 'vitest'
-import { TooltipProvider } from '@/components/ui/tooltip'
 import { NativeChatJumpControls } from './NativeChatJumpControls'
 
 afterEach(cleanup)
 
-// The reader is usually mid-draft when they reach for these: a press must not take the caret.
-it.each(['Jump to latest', 'Jump to top'])(
-  'leaves focus in the composer when "%s" is pressed with the pointer',
-  async (name) => {
-    const onLatest = vi.fn()
-    const startFromBeginning = vi.fn()
-    render(
-      <TooltipProvider>
-        <NativeChatJumpControls
-          showLatest
-          startOutOfView
-          historyJump={{ startPending: false, startFromBeginning }}
-          onLatest={onLatest}
-          transcriptRef={createRef<HTMLElement>()}
-        />
-        <textarea aria-label="Message" />
-      </TooltipProvider>
-    )
-    const composer = screen.getByRole('textbox', { name: 'Message' })
-    composer.focus()
-
-    await userEvent.click(screen.getByRole('button', { name }))
-
-    // Anti-vacuous: the press did act.
-    expect(onLatest.mock.calls.length + startFromBeginning.mock.calls.length).toBe(1)
-    expect(document.activeElement).toBe(composer)
-  }
-)
-
-it('hands focus to the transcript when a focused "Jump to top" hides at the start', () => {
-  const transcriptRef = createRef<HTMLDivElement>()
-  const controls = (startOutOfView: boolean) => (
-    <TooltipProvider>
-      <div ref={transcriptRef} tabIndex={0} aria-label="Conversation" />
+// 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 "Jump to latest" is pressed with the pointer', async () => {
+  const onLatest = vi.fn()
+  render(
+    <>
       <NativeChatJumpControls
         showLatest
-        startOutOfView={startOutOfView}
-        historyJump={{ startPending: false, startFromBeginning: vi.fn() }}
-        onLatest={vi.fn()}
-        transcriptRef={transcriptRef}
+        onLatest={onLatest}
+        transcriptRef={createRef<HTMLElement>()}
       />
-    </TooltipProvider>
+      <textarea aria-label="Message" />
+    </>
   )
-  const { rerender } = render(controls(true))
-  const top = screen.getByRole('button', { name: 'Jump to top' })
-  top.focus()
-  // Anti-vacuous: the button held focus before it hid.
-  expect(document.activeElement).toBe(top)
+  const composer = screen.getByRole('textbox', { name: 'Message' })
+  composer.focus()
 
-  rerender(controls(false))
+  await userEvent.click(screen.getByRole('button', { name: 'Jump to latest' }))
 
-  expect(top).toHaveAttribute('inert')
-  expect(document.activeElement).toBe(transcriptRef.current)
+  // Anti-vacuous: the press did act.
+  expect(onLatest).toHaveBeenCalledOnce()
+  expect(document.activeElement).toBe(composer)
 })
diff --git a/src/renderer/src/components/native-chat/NativeChatJumpControls.tsx b/src/renderer/src/components/native-chat/NativeChatJumpControls.tsx
index c56fcb9bc444..0269a828cd7a 100644
--- a/src/renderer/src/components/native-chat/NativeChatJumpControls.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatJumpControls.tsx
@@ -1,15 +1,12 @@
-// The way back out of a transcript the reader has scrolled into: to the latest
-// message, or to the start of the conversation.
+// The way back out of a transcript the reader has scrolled into: to the latest message.
 //
-// Both stay mounted so they can fade rather than pop, and a hidden one is inert
+// It stays mounted so it can fade rather than pop, and while hidden it is inert
 // and hidden from assistive tech, so it can be neither clicked, tabbed to nor read.
 
 import { useLayoutEffect, useRef } from 'react'
-import { ArrowDown, ArrowUp, Loader2 } from 'lucide-react'
-import { Tooltip, TooltipContent, TooltipTrigger } from '@/components/ui/tooltip'
+import { ArrowDown } from 'lucide-react'
 import { translate } from '@/i18n/i18n'
 import { cn } from '@/lib/utils'
-import type { useNativeChatRailHistoryJump } from './use-native-chat-rail-history-jump'
 
 const JUMP_BUTTON_CLASS =
   'pointer-events-auto flex h-8 items-center gap-1.5 rounded-full border border-border bg-popover 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'
@@ -32,55 +29,17 @@ function useHandBackFocus(visible: boolean, transcriptRef: React.RefObject<HTMLE
 
 export function NativeChatJumpControls({
   showLatest,
-  startOutOfView,
-  historyJump,
   onLatest,
   transcriptRef
 }: {
   showLatest: boolean
-  /** Older history is still unloaded, or the loaded top is more than a screen away. */
-  startOutOfView: boolean
-  historyJump: Pick<
-    ReturnType<typeof useNativeChatRailHistoryJump>,
-    'startPending' | 'startFromBeginning'
-  >
   onLatest: () => void
   transcriptRef: React.RefObject<HTMLElement | null>
 }): React.JSX.Element {
-  // Offered only beside the way back down, so a reader following the end sees neither.
-  const showTop = showLatest && startOutOfView
   const latestRef = useHandBackFocus(showLatest, transcriptRef)
-  const topRef = useHandBackFocus(showTop, transcriptRef)
-  const topPending = historyJump.startPending
   const latestLabel = translate('components.native-chat.jumpToLatest', 'Jump to latest')
-  const topLabel = translate('components.native-chat.jumpToTop', 'Jump to top')
   return (
     <div className="pointer-events-none absolute inset-x-0 bottom-3 flex justify-center gap-2">
-      <Tooltip>
-        <TooltipTrigger asChild>
-          <button
-            ref={topRef}
-            type="button"
-            aria-label={topLabel}
-            aria-busy={topPending || undefined}
-            data-shown={showTop}
-            inert={!showTop}
-            aria-hidden={!showTop || undefined}
-            onMouseDown={keepFocus}
-            onClick={historyJump.startFromBeginning}
-            className={cn(JUMP_BUTTON_CLASS, 'w-8 justify-center')}
-          >
-            {topPending ? (
-              <Loader2 className="size-3.5 animate-spin motion-reduce:animate-none" />
-            ) : (
-              <ArrowUp className="size-3.5" />
-            )}
-          </button>
-        </TooltipTrigger>
-        <TooltipContent side="top" sideOffset={4}>
-          {topLabel}
-        </TooltipContent>
-      </Tooltip>
       <button
         ref={latestRef}
         type="button"
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 626dbd1b1a05..e2af487149d4 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,8 +2,7 @@
 
 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 { act, cleanup, fireEvent, render, screen } from '@testing-library/react'
 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.interrupted-turn-fold.test.tsx b/src/renderer/src/components/native-chat/NativeChatMessageList.interrupted-turn-fold.test.tsx
index 44d683182435..acce19bcf523 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,8 +2,7 @@
 
 import '@testing-library/jest-dom/vitest'
 
-import { cleanup, screen } from '@testing-library/react'
-import { render } from './native-chat-app-root-test-render'
+import { cleanup, render, screen } from '@testing-library/react'
 import { afterAll, afterEach, beforeAll, describe, expect, it, vi } from 'vitest'
 import type {
   AgentJournalRenderItem,
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 df3abf63e989..e2fd6f65d8c8 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,8 +2,7 @@
 
 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 { act, cleanup, fireEvent, render, screen } from '@testing-library/react'
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 import type {
   AgentJournalItemBody,
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 07cfb43e630c..819ee94dbd52 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,8 +2,7 @@
 
 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 { act, cleanup, fireEvent, render, screen } from '@testing-library/react'
 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 d2c6758f462a..db59afdb19db 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,8 +2,7 @@
 
 import '@testing-library/jest-dom/vitest'
 
-import { cleanup, screen } from '@testing-library/react'
-import { render } from './native-chat-app-root-test-render'
+import { cleanup, render, screen } from '@testing-library/react'
 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 89752ee23200..1762674739dd 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,8 +2,7 @@
 
 import '@testing-library/jest-dom/vitest'
 
-import { cleanup, screen } from '@testing-library/react'
-import { render } from './native-chat-app-root-test-render'
+import { cleanup, render, screen } from '@testing-library/react'
 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 c98bca34872c..73d478c6b18f 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,7 @@
 
 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 { act, cleanup, fireEvent, render, screen } from '@testing-library/react'
 import { useCallback, useMemo, useState } from 'react'
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 import type {
@@ -78,13 +77,10 @@ function PagedTranscript({
 }): 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, loaded])
+  }, [holdPage])
   const messages = useMemo(() => HISTORY.slice(TOTAL - loaded), [loaded])
   const railOutline = useMemo<NativeChatRailOutlineEntry[]>(
     () =>
@@ -454,51 +450,6 @@ describe('jumping from the rail while following the end', () => {
     expect(distanceFromBottom()).toBe(0)
   })
 
-  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()
-    act(() => {
-      scroller().scrollTop = 200
-    })
-    await settle(2)
-
-    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 () => {
-    let openGate: (() => void) | null = null
-    const gate = new Promise<void>((resolve) => {
-      openGate = resolve
-    })
-    render(<PagedTranscript holdPage={() => gate} />)
-    await settle(10)
-    act(() => {
-      scroller().scrollTop = 200
-    })
-    await settle(2)
-    const top = screen.getByRole('button', { name: 'Jump to top' })
-    // Anti-vacuous: idle until pressed, whatever else is already paging.
-    expect(top).not.toHaveAttribute('aria-busy')
-
-    fireEvent.click(top)
-    await frame()
-
-    expect(top).toHaveAttribute('aria-busy', 'true')
-    expect(top.querySelector('svg')).toHaveClass('animate-spin', 'motion-reduce:animate-none')
-    act(() => openGate?.())
-    await settle(60)
-    expect(scroller().scrollTop).toBe(0)
-    expect(top).not.toHaveAttribute('aria-busy')
-  })
-
   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)',
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
index ae7cd5a7c83a..66c274e0e688 100644
--- a/src/renderer/src/components/native-chat/NativeChatMessageList.reader-navigation.test.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatMessageList.reader-navigation.test.tsx
@@ -2,8 +2,7 @@
 
 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 { act, cleanup, fireEvent, render, screen } from '@testing-library/react'
 import { createRef } from 'react'
 import { afterEach, beforeEach, describe, expect, it } from 'vitest'
 import type { NativeChatMessage } from '../../../../shared/native-chat-types'
@@ -20,8 +19,7 @@ import {
   session,
   stubLayout,
   stubResizeObserver,
-  TRANSCRIPT_LENGTH,
-  VIEWPORT_PX
+  TRANSCRIPT_LENGTH
 } from './native-chat-windowing-test-harness'
 
 afterEach(cleanup)
@@ -433,22 +431,6 @@ describe('reader navigation', () => {
     expect(scrollRoot(container)).toHaveAttribute('tabindex', '0')
   })
 
-  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(screen.getByRole('button', { name: 'Jump to latest' })).not.toHaveAttribute('inert')
-    // 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('hands focus to the transcript when a focused jump button hides, and leaves it inert', () => {
     const { container } = render(
       <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 4d1cdd809607..7efb254c6194 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,8 +2,7 @@
 
 import '@testing-library/jest-dom/vitest'
 
-import { cleanup, fireEvent, screen } from '@testing-library/react'
-import { render } from './native-chat-app-root-test-render'
+import { cleanup, fireEvent, render, screen } from '@testing-library/react'
 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 237e159cae0d..968dc5b92e8c 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,8 +2,7 @@
 
 import '@testing-library/jest-dom/vitest'
 
-import { cleanup, fireEvent, screen, within } from '@testing-library/react'
-import { render } from './native-chat-app-root-test-render'
+import { cleanup, fireEvent, render, screen, within } from '@testing-library/react'
 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 7493f10a22d8..82b2c43d4681 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,8 +2,7 @@
 
 import '@testing-library/jest-dom/vitest'
 
-import { cleanup, fireEvent, screen, within } from '@testing-library/react'
-import { render } from './native-chat-app-root-test-render'
+import { cleanup, fireEvent, render, screen, within } from '@testing-library/react'
 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 4ca3b60664fb..b72562d128a1 100644
--- a/src/renderer/src/components/native-chat/NativeChatMessageList.test.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatMessageList.test.tsx
@@ -2,8 +2,7 @@
 
 import '@testing-library/jest-dom/vitest'
 
-import { cleanup, fireEvent, screen } from '@testing-library/react'
-import { render } from './native-chat-app-root-test-render'
+import { cleanup, fireEvent, render, screen } from '@testing-library/react'
 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 f0061e52ec0c..d8a9379ca190 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,6 +1,5 @@
 // @vitest-environment happy-dom
-import { cleanup, screen } from '@testing-library/react'
-import { render } from './native-chat-app-root-test-render'
+import { cleanup, render, screen } from '@testing-library/react'
 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 ae9464cc457a..2849cde4a10f 100644
--- a/src/renderer/src/components/native-chat/NativeChatMessageList.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatMessageList.tsx
@@ -264,8 +264,7 @@ export function NativeChatMessageList({
     sessionKey: `${session.agent}:${session.sessionId}`,
     isVisible,
     loadEarlier,
-    jumpToLoaded: requestRailJump,
-    jumpToStart: transcriptScroll.scrollToTop
+    jumpToLoaded: requestRailJump
   })
   const { start: startHistoryJump, abort: beginNavigation } = railHistoryJump
   const readerOpens = useNativeChatReaderOpens({
@@ -427,8 +426,6 @@ export function NativeChatMessageList({
           />
           <NativeChatJumpControls
             showLatest={transcriptScroll.showJump}
-            startOutOfView={showOlderHistory || transcriptScroll.awayFromTop}
-            historyJump={railHistoryJump}
             onLatest={jumpToLatest}
             transcriptRef={scrollRef}
           />
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 3b96eece233f..7c62a9efe3ef 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,8 +2,7 @@
 
 import '@testing-library/jest-dom/vitest'
 
-import { cleanup, fireEvent, screen } from '@testing-library/react'
-import { render } from './native-chat-app-root-test-render'
+import { cleanup, fireEvent, render, screen } from '@testing-library/react'
 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 86fc3afd2073..c4b2bc2ed6fb 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,7 +1,6 @@
 // @vitest-environment happy-dom
 import '@testing-library/jest-dom/vitest'
-import { cleanup, fireEvent, screen } from '@testing-library/react'
-import { render } from './native-chat-app-root-test-render'
+import { cleanup, fireEvent, render, screen } from '@testing-library/react'
 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 1cacdf2a65c2..d48c1d04dab0 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,8 +2,7 @@
 
 import '@testing-library/jest-dom/vitest'
 
-import { cleanup, fireEvent, screen } from '@testing-library/react'
-import { render } from './native-chat-app-root-test-render'
+import { cleanup, fireEvent, render, screen } from '@testing-library/react'
 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 f9fd4b96f7bd..29f977046f6c 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,8 +2,7 @@
 
 import '@testing-library/jest-dom/vitest'
 
-import { cleanup, screen } from '@testing-library/react'
-import { render } from './native-chat-app-root-test-render'
+import { cleanup, render, screen } from '@testing-library/react'
 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 a33da08fa2dc..546c7b5cba7d 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,8 +2,7 @@
 
 import '@testing-library/jest-dom/vitest'
 
-import { cleanup, screen } from '@testing-library/react'
-import { render } from './native-chat-app-root-test-render'
+import { cleanup, render, screen } from '@testing-library/react'
 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.unsent-message.test.tsx b/src/renderer/src/components/native-chat/NativeChatMessageList.unsent-message.test.tsx
index 1a51ff55d604..ac6ab467ace2 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,8 +6,7 @@
 
 import '@testing-library/jest-dom/vitest'
 
-import { cleanup } from '@testing-library/react'
-import { render } from './native-chat-app-root-test-render'
+import { cleanup, render } from '@testing-library/react'
 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 ba18ce53f037..bf31f92a3d93 100644
--- a/src/renderer/src/components/native-chat/NativeChatMessageList.windowing.test.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatMessageList.windowing.test.tsx
@@ -2,8 +2,7 @@
 
 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 { act, cleanup, fireEvent, render, screen } from '@testing-library/react'
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 import type {
   AgentJournalItemBody,
diff --git a/src/renderer/src/components/native-chat/NativeChatResolvedView.turn-status.test.tsx b/src/renderer/src/components/native-chat/NativeChatResolvedView.turn-status.test.tsx
index 1ea8609a6b8f..97d8acc7d75c 100644
--- a/src/renderer/src/components/native-chat/NativeChatResolvedView.turn-status.test.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatResolvedView.turn-status.test.tsx
@@ -3,8 +3,7 @@
 import '@testing-library/jest-dom/vitest'
 
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
-import { act, cleanup, screen } from '@testing-library/react'
-import { render } from './native-chat-app-root-test-render'
+import { act, cleanup, render, screen } from '@testing-library/react'
 import type { AgentStatusEntry, AgentStatusPayload } from '../../../../shared/agent-status-types'
 import type { NativeChatMessage } from '../../../../shared/native-chat-types'
 import type { NativeChatLiveSession } from './use-native-chat-live-session'
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
deleted file mode 100644
index e7cab5387f92..000000000000
--- a/src/renderer/src/components/native-chat/native-chat-app-root-test-render.tsx
+++ /dev/null
@@ -1,12 +0,0 @@
-// 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/use-native-chat-rail-history-jump.test.ts b/src/renderer/src/components/native-chat/use-native-chat-rail-history-jump.test.ts
index 7bd0a8eb9cff..40502c656d12 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
@@ -89,7 +89,6 @@ function createLane({
   const useLaneRailJump = (
     jumpToLoaded: (item: NativeChatRailItem) => void,
     sessionKey = 'session-1',
-    jumpToStart: () => void = () => {},
     isVisible = true
   ) => {
     const current = useSyncExternalStore(lane.subscribe, lane.getSnapshot)
@@ -107,8 +106,7 @@ function createLane({
       sessionKey,
       isVisible,
       loadEarlier: lane.loadEarlier,
-      jumpToLoaded,
-      jumpToStart
+      jumpToLoaded
     })
   }
   return { lane, useLaneRailJump }
@@ -296,88 +294,38 @@ describe('rail jump through unloaded history', () => {
     expect(jumpToLoaded).not.toHaveBeenCalled()
   })
 
-  it('abandons the jump when the list unmounts mid-page', async () => {
+  // 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, unmount } = renderHook(() => useLaneRailJump(jumpToLoaded))
+    const { result, rerender } = renderHook(
+      ({ isVisible }: { isVisible: boolean }) =>
+        useLaneRailJump(jumpToLoaded, 'session-1', isVisible),
+      { initialProps: { isVisible: true } }
+    )
 
-    act(() => result.current.start(outlineItem('m2')))
+    act(() => result.current.start(outlineItem('m25')))
     await waitFor(() => expect(lane.reads.count).toBe(1))
-    unmount()
-    await releasePage(lane)
-    expect(lane.reads.count).toBe(1)
-    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', jumpToStart))
-
-    act(() => result.current.startFromBeginning())
-    expect(result.current.startPending).toBe(true)
+    rerender({ isVisible: false })
     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', 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', 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()
+    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 () => {
+  it('abandons the jump when the list unmounts 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', jumpToStart, isVisible),
-      { initialProps: { isVisible: true } }
-    )
+    const jumpToLoaded = vi.fn()
+    const { result, unmount } = renderHook(() => useLaneRailJump(jumpToLoaded))
 
-    act(() => result.current.startFromBeginning())
+    act(() => result.current.start(outlineItem('m2')))
     await waitFor(() => expect(lane.reads.count).toBe(1))
-    rerender({ isVisible: false })
-    expect(result.current.startPending).toBe(false)
+    unmount()
     await releasePage(lane)
-
     expect(lane.reads.count).toBe(1)
-    expect(jumpToStart).not.toHaveBeenCalled()
+    expect(jumpToLoaded).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 1d92581a4314..c065a7d8f4fc 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,6 +1,5 @@
 // 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. Jumping
-// to the start of the conversation is the same walk, with no older page as its target.
+// until the message has a slot, then hand it to the ordinary rail jump.
 //
 // 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
@@ -17,9 +16,6 @@ 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
@@ -32,8 +28,7 @@ export function useNativeChatRailHistoryJump({
   sessionKey,
   isVisible,
   loadEarlier,
-  jumpToLoaded,
-  jumpToStart
+  jumpToLoaded
 }: {
   items: readonly NativeChatRailItem[]
   /** A change abandons the jump: its target belongs to the previous session. */
@@ -42,24 +37,20 @@ export function useNativeChatRailHistoryJump({
   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 [pending, setPending] = useState<HistoryJumpTarget | null>(null)
+  const [pendingId, setPendingId] = useState<string | null>(null)
   const [, requestCommit] = useReducer((count: number) => count + 1, 0)
   const controllerRef = useRef<AbortController | null>(null)
-  const committedRef = useRef({ items, loadEarlier, jumpToLoaded, jumpToStart })
+  const committedRef = useRef({ items, loadEarlier, jumpToLoaded })
   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, jumpToStart }
+    committedRef.current = { items, loadEarlier, jumpToLoaded }
     const waiters = [...commitWaitersRef.current]
     commitWaitersRef.current.clear()
     for (const resolve of waiters) {
@@ -83,32 +74,22 @@ export function useNativeChatRailHistoryJump({
   }, [])
 
   const run = useCallback(
-    async (target: HistoryJumpTarget, signal: AbortSignal): Promise<void> => {
+    async (id: string, signal: AbortSignal): Promise<void> => {
       for (let pages = 0; ; pages += 1) {
-        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) {
+        // 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) {
           return
         }
-        const result = await committedRef.current.loadEarlier()
-        if (signal.aborted) {
+        if (target.slotIndex !== null) {
+          committedRef.current.jumpToLoaded(target)
           return
         }
-        // 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()
+        if (pages >= NATIVE_CHAT_RAIL_JUMP_MAX_PAGES) {
           return
         }
-        if (result !== 'applied') {
+        const result = await committedRef.current.loadEarlier()
+        if (signal.aborted || result !== 'applied') {
           return
         }
         await nextCommit(signal)
@@ -127,37 +108,29 @@ export function useNativeChatRailHistoryJump({
     }
     controllerRef.current = null
     controller.abort()
-    setPending(null)
+    setPendingId(null)
   }, [])
 
   // The latest pick wins; a page the previous jump started is joined, not repeated.
-  const begin = useCallback(
-    (target: HistoryJumpTarget) => {
+  const start = useCallback(
+    (item: NativeChatRailItem) => {
       controllerRef.current?.abort()
       const controller = new AbortController()
       controllerRef.current = controller
-      setPending(target)
-      void run(target, controller.signal)
+      setPendingId(item.id)
+      void run(item.id, controller.signal)
         .catch(() => undefined)
         .finally(() => {
           if (controllerRef.current === controller) {
             controllerRef.current = null
-            setPending(null)
+            setPendingId(null)
           }
         })
     },
     [run]
   )
-  const start = useCallback((item: NativeChatRailItem) => begin(item.id), [begin])
-  const startFromBeginning = useCallback(() => begin(HISTORY_START), [begin])
 
   useEffect(() => abort, [abort, sessionKey, isVisible])
 
-  return {
-    pendingId: typeof pending === 'string' ? pending : null,
-    startPending: pending === HISTORY_START,
-    start,
-    startFromBeginning,
-    abort
-  }
+  return { pendingId, start, abort }
 }
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 034acaae8bb0..a37dbbe5aee7 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
@@ -45,11 +45,8 @@ 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
   /** The reader opened a row to read it: leave it where it is. */
@@ -87,7 +84,6 @@ export function useNativeChatTranscriptScroll({
   reconcileReaderScroll: (isTakingOver: boolean) => void
 }): NativeChatTranscriptScroll {
   const [showJump, setShowJump] = useState(false)
-  const [awayFromTop, setAwayFromTop] = useState(false)
   const followRef = useRef(FOLLOWING)
   const detachedScrollTopRef = useRef<number | null>(null)
   const isVisibleRef = useRef(isVisible)
@@ -127,7 +123,6 @@ export function useNativeChatTranscriptScroll({
       const following = followRef.current.kind === 'following'
       detachedScrollTopRef.current = following ? null : geometry.scrollTop
       setShowJump(shouldShowJumpToLatest(following, geometry))
-      setAwayFromTop(geometry.scrollTop > geometry.clientHeight)
       return geometry
     },
     [consumeProgrammaticScroll, follow, reconcileReaderScroll, scrollRef]
@@ -155,13 +150,6 @@ export function useNativeChatTranscriptScroll({
     setShowJump(false)
   }, [follow, scrollToEndWhenMeasurable])
 
-  const scrollToTop = useCallback(() => {
-    follow({ kind: 'navigate' })
-    // Also where a hidden pane lands once revealed, since the write below waits for layout.
-    detachedScrollTopRef.current = 0
-    restoreScrollOffset(0)
-  }, [follow, restoreScrollOffset])
-
   const scrollMessageToTop = useCallback(
     (element: HTMLElement) => {
       follow({ kind: 'navigate' })
@@ -248,10 +236,8 @@ export function useNativeChatTranscriptScroll({
 
   return {
     showJump,
-    awayFromTop,
     onScroll,
     scrollToBottom,
-    scrollToTop,
     scrollMessageToTop,
     readerOpened,
     readerClosed,
diff --git a/src/renderer/src/i18n/locales/en.json b/src/renderer/src/i18n/locales/en.json
index 40f2b9b32612..49e0e32721c1 100644
--- a/src/renderer/src/i18n/locales/en.json
+++ b/src/renderer/src/i18n/locales/en.json
@@ -18068,7 +18068,6 @@
         "groupTasks": "Tasks"
       },
       "jumpToLatest": "Jump to latest",
-      "jumpToTop": "Jump to top",
       "transcriptLabel": "Conversation",
       "toggle": {
         "showTerminal": "Show terminal",
diff --git a/src/renderer/src/i18n/locales/es.json b/src/renderer/src/i18n/locales/es.json
index 23269c6eff77..29a701aad5ed 100644
--- a/src/renderer/src/i18n/locales/es.json
+++ b/src/renderer/src/i18n/locales/es.json
@@ -17742,7 +17742,6 @@
         "toggleDetails": "Alternar detalles del turno"
       },
       "jumpToLatest": "Saltar a lo último",
-      "jumpToTop": "Ir al principio",
       "transcriptLabel": "Conversación",
       "toggle": {
         "showTerminal": "Mostrar terminal",
diff --git a/src/renderer/src/i18n/locales/fr.json b/src/renderer/src/i18n/locales/fr.json
index dd7912ffbba8..e9561533c47e 100644
--- a/src/renderer/src/i18n/locales/fr.json
+++ b/src/renderer/src/i18n/locales/fr.json
@@ -17841,7 +17841,6 @@
         "toggleDetails": "Basculer les détails du tour"
       },
       "jumpToLatest": "Aller au dernier message",
-      "jumpToTop": "Remonter en haut",
       "transcriptLabel": "Conversation",
       "toggle": {
         "showTerminal": "Afficher le terminal",
diff --git a/src/renderer/src/i18n/locales/ja.json b/src/renderer/src/i18n/locales/ja.json
index 469439dd855d..0b31de254772 100644
--- a/src/renderer/src/i18n/locales/ja.json
+++ b/src/renderer/src/i18n/locales/ja.json
@@ -17777,7 +17777,6 @@
         "toggleDetails": "ターンの詳細を切り替えます"
       },
       "jumpToLatest": "最新にジャンプ",
-      "jumpToTop": "先頭へジャンプ",
       "transcriptLabel": "会話",
       "toggle": {
         "showTerminal": "ターミナルを表示",
diff --git a/src/renderer/src/i18n/locales/ko.json b/src/renderer/src/i18n/locales/ko.json
index 16d483c78883..bec8dbade616 100644
--- a/src/renderer/src/i18n/locales/ko.json
+++ b/src/renderer/src/i18n/locales/ko.json
@@ -17777,7 +17777,6 @@
         "toggleDetails": "턴 세부정보 전환"
       },
       "jumpToLatest": "최신으로 이동",
-      "jumpToTop": "맨 위로 이동",
       "transcriptLabel": "대화",
       "toggle": {
         "showTerminal": "terminal 표시",
diff --git a/src/renderer/src/i18n/locales/zh.json b/src/renderer/src/i18n/locales/zh.json
index 5f0db78d5324..4aebaa551448 100644
--- a/src/renderer/src/i18n/locales/zh.json
+++ b/src/renderer/src/i18n/locales/zh.json
@@ -17742,7 +17742,6 @@
         "toggleDetails": "切换回合详情"
       },
       "jumpToLatest": "跳到最新消息",
-      "jumpToTop": "跳转到顶部",
       "transcriptLabel": "对话",
       "toggle": {
         "showTerminal": "显示终端",

From da90399af2f7a29e526e4bd04dff34fa17f3d6c4 Mon Sep 17 00:00:00 2001
From: Brennan Benson <79079362+brennanb2025@users.noreply.github.com>
Date: Mon, 5 Oct 2026 17:04:31 -0700
Subject: [PATCH 06/14] refactor(native-chat): keep Jump to latest's existing
 look in this change

The solid, fading Jump to latest button moves to the UI PR (#25702) so this one carries only the scroll behaviour.
---
 .../NativeChatJumpControls.test.tsx           | 34 -----------
 .../native-chat/NativeChatJumpControls.tsx    | 58 -------------------
 ...ChatMessageList.reader-navigation.test.tsx | 26 +--------
 .../native-chat/NativeChatMessageList.tsx     | 30 +++++-----
 4 files changed, 20 insertions(+), 128 deletions(-)
 delete mode 100644 src/renderer/src/components/native-chat/NativeChatJumpControls.test.tsx
 delete mode 100644 src/renderer/src/components/native-chat/NativeChatJumpControls.tsx

diff --git a/src/renderer/src/components/native-chat/NativeChatJumpControls.test.tsx b/src/renderer/src/components/native-chat/NativeChatJumpControls.test.tsx
deleted file mode 100644
index b280987dcc4b..000000000000
--- a/src/renderer/src/components/native-chat/NativeChatJumpControls.test.tsx
+++ /dev/null
@@ -1,34 +0,0 @@
-// @vitest-environment happy-dom
-
-import '@testing-library/jest-dom/vitest'
-
-import { cleanup, render, screen } from '@testing-library/react'
-import userEvent from '@testing-library/user-event'
-import { createRef } from 'react'
-import { afterEach, expect, it, vi } from 'vitest'
-import { NativeChatJumpControls } from './NativeChatJumpControls'
-
-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 "Jump to latest" is pressed with the pointer', async () => {
-  const onLatest = vi.fn()
-  render(
-    <>
-      <NativeChatJumpControls
-        showLatest
-        onLatest={onLatest}
-        transcriptRef={createRef<HTMLElement>()}
-      />
-      <textarea aria-label="Message" />
-    </>
-  )
-  const composer = screen.getByRole('textbox', { name: 'Message' })
-  composer.focus()
-
-  await userEvent.click(screen.getByRole('button', { name: 'Jump to latest' }))
-
-  // Anti-vacuous: the press did act.
-  expect(onLatest).toHaveBeenCalledOnce()
-  expect(document.activeElement).toBe(composer)
-})
diff --git a/src/renderer/src/components/native-chat/NativeChatJumpControls.tsx b/src/renderer/src/components/native-chat/NativeChatJumpControls.tsx
deleted file mode 100644
index 0269a828cd7a..000000000000
--- a/src/renderer/src/components/native-chat/NativeChatJumpControls.tsx
+++ /dev/null
@@ -1,58 +0,0 @@
-// The way back out of a transcript the reader has scrolled into: to the latest message.
-//
-// It stays mounted so it can fade rather than pop, and while hidden it is inert
-// and hidden from assistive tech, so it can be neither clicked, tabbed to nor read.
-
-import { useLayoutEffect, useRef } from 'react'
-import { ArrowDown } from 'lucide-react'
-import { translate } from '@/i18n/i18n'
-import { cn } from '@/lib/utils'
-
-const JUMP_BUTTON_CLASS =
-  'pointer-events-auto flex h-8 items-center gap-1.5 rounded-full border border-border bg-popover 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'
-
-/** Keeps focus where the reader was typing: a pointer press never moves it here. */
-function keepFocus(event: React.MouseEvent): void {
-  event.preventDefault()
-}
-
-/** A keyboard press that hides the focused button hands focus to the transcript, not the page. */
-function useHandBackFocus(visible: boolean, transcriptRef: React.RefObject<HTMLElement | null>) {
-  const ref = useRef<HTMLButtonElement>(null)
-  useLayoutEffect(() => {
-    if (!visible && ref.current !== null && ref.current === document.activeElement) {
-      transcriptRef.current?.focus({ preventScroll: true })
-    }
-  }, [transcriptRef, visible])
-  return ref
-}
-
-export function NativeChatJumpControls({
-  showLatest,
-  onLatest,
-  transcriptRef
-}: {
-  showLatest: boolean
-  onLatest: () => void
-  transcriptRef: React.RefObject<HTMLElement | null>
-}): React.JSX.Element {
-  const latestRef = useHandBackFocus(showLatest, transcriptRef)
-  const latestLabel = translate('components.native-chat.jumpToLatest', 'Jump to latest')
-  return (
-    <div className="pointer-events-none absolute inset-x-0 bottom-3 flex justify-center gap-2">
-      <button
-        ref={latestRef}
-        type="button"
-        data-shown={showLatest}
-        inert={!showLatest}
-        aria-hidden={!showLatest || undefined}
-        onMouseDown={keepFocus}
-        onClick={onLatest}
-        className={cn(JUMP_BUTTON_CLASS, 'px-3')}
-      >
-        <ArrowDown className="size-3.5" />
-        <span>{latestLabel}</span>
-      </button>
-    </div>
-  )
-}
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
index 66c274e0e688..75acda4f4cb3 100644
--- a/src/renderer/src/components/native-chat/NativeChatMessageList.reader-navigation.test.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatMessageList.reader-navigation.test.tsx
@@ -120,8 +120,7 @@ function toggleRun(container: HTMLElement, toggle: HTMLElement, openRows: readon
 }
 
 function offersJumpToLatest(): boolean {
-  const jump = screen.queryByRole('button', { name: 'Jump to latest' })
-  return jump !== null && !jump.hasAttribute('inert')
+  return screen.queryByRole('button', { name: 'Jump to latest' }) !== null
 }
 
 describe('reader navigation', () => {
@@ -431,28 +430,9 @@ describe('reader navigation', () => {
     expect(scrollRoot(container)).toHaveAttribute('tabindex', '0')
   })
 
-  it('hands focus to the transcript when a focused jump button hides, and leaves it inert', () => {
-    const { container } = render(
-      <NativeChatMessageList
-        session={session(transcript)}
-        isWorking={false}
-        expandSignal={false}
-        fontScale={1}
-      />
-    )
-    paint(container)
-    scrollTranscript(container, 1000)
-    paint(container)
-    const latest = screen.getByRole('button', { name: 'Jump to latest' })
-    // Anti-vacuous: shown, so reachable.
-    expect(latest).not.toHaveAttribute('inert')
-
-    latest.focus()
-    fireEvent.click(latest)
-    paint(container)
+  it('names the transcript as a region, so a focused scroll stop is announced', () => {
+    const { container } = render(list(transcript))
 
-    expect(latest).toHaveAttribute('inert')
-    expect(document.activeElement).toBe(scrollRoot(container))
     expect(screen.getByRole('region', { name: 'Conversation' })).toBe(scrollRoot(container))
   })
 })
diff --git a/src/renderer/src/components/native-chat/NativeChatMessageList.tsx b/src/renderer/src/components/native-chat/NativeChatMessageList.tsx
index 2849cde4a10f..84640e2e5a7f 100644
--- a/src/renderer/src/components/native-chat/NativeChatMessageList.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatMessageList.tsx
@@ -1,4 +1,5 @@
 import { useCallback, useLayoutEffect, useMemo, useRef, useState } from 'react'
+import { ArrowDown } from 'lucide-react'
 import type { CommentMarkdownLinkClickHandler } from '@/components/sidebar/CommentMarkdown'
 import { translate } from '@/i18n/i18n'
 import type { NativeChatLiveSession } from './use-native-chat-live-session'
@@ -39,10 +40,8 @@ import type {
 } from './native-chat-message-rail-items'
 import { useNativeChatRailHistoryJump } from './use-native-chat-rail-history-jump'
 import { nativeChatReaderScrollInputHandlers } from './native-chat-reader-scroll-input'
-import { NativeChatJumpControls } from './NativeChatJumpControls'
 import { useNativeChatReaderOpens } from './use-native-chat-reader-opens'
 import { useNativeChatMessageListHandle } from './use-native-chat-reveal-latest'
-import type { NativeChatMessageListHandle } from './use-native-chat-reveal-latest'
 
 import type {
   AgentJournalRenderItem,
@@ -85,7 +84,7 @@ export function NativeChatMessageList({
   turnActivity,
   runtimeContext
 }: {
-  ref?: React.Ref<NativeChatMessageListHandle>
+  ref?: Parameters<typeof useNativeChatMessageListHandle>[0]
   session: NativeChatLiveSession
   journalItems?: readonly AgentJournalRenderItem[]
   /** With the items, what places each row in its turn (structured lane). */
@@ -223,7 +222,7 @@ export function NativeChatMessageList({
     // mutually exclusive things to be doing.
     revealIndex: nativeChatSlotIndexOf(slots, railJump?.messageId ?? revealedDiff?.messageId)
   })
-  const transcriptScroll = useNativeChatTranscriptScroll({
+  const { scrollToBottom, scrollMessageToTop, ...follow } = useNativeChatTranscriptScroll({
     scrollRef,
     contentRef,
     itemCount: slots.length,
@@ -271,7 +270,7 @@ export function NativeChatMessageList({
     subagentDisclosure,
     expandedTurnIds,
     setExpandedTurnIds,
-    follow: transcriptScroll,
+    follow,
     abortNavigation: beginNavigation
   })
   // Every navigation begins by aborting a history jump still paging, which would
@@ -302,12 +301,11 @@ export function NativeChatMessageList({
     },
     [beginNavigation, openSubagentSections]
   )
-  const { scrollToBottom, scrollMessageToTop } = transcriptScroll
   const jumpToLatest = useCallback(() => {
     beginNavigation()
     scrollToBottom()
   }, [beginNavigation, scrollToBottom])
-  useNativeChatMessageListHandle(ref, jumpToLatest, transcriptScroll.untilReaderActs)
+  useNativeChatMessageListHandle(ref, jumpToLatest, follow.untilReaderActs)
   const readerScrollInput = useMemo(
     () => nativeChatReaderScrollInputHandlers(beginNavigation),
     [beginNavigation]
@@ -371,7 +369,7 @@ export function NativeChatMessageList({
         <div className="relative min-h-0 flex-1">
           <div
             ref={scrollRef}
-            onScroll={transcriptScroll.onScroll}
+            onScroll={follow.onScroll}
             {...readerScrollInput}
             // Named so measurement can find the scroll root without depending on
             // which utility class happens to make it scroll.
@@ -424,11 +422,17 @@ export function NativeChatMessageList({
             onReaderScroll={beginNavigation}
             pendingId={railHistoryJump.pendingId}
           />
-          <NativeChatJumpControls
-            showLatest={transcriptScroll.showJump}
-            onLatest={jumpToLatest}
-            transcriptRef={scrollRef}
-          />
+          {follow.showJump ? (
+            <button
+              type="button"
+              onClick={jumpToLatest}
+              aria-label={translate('components.native-chat.jumpToLatest', 'Jump to latest')}
+              className="absolute bottom-3 left-1/2 flex -translate-x-1/2 items-center gap-1.5 rounded-full border border-border bg-card/90 px-3 py-1.5 text-xs text-muted-foreground shadow-sm backdrop-blur hover:bg-accent hover:text-accent-foreground focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring"
+            >
+              <ArrowDown className="size-3.5" />
+              <span>{translate('components.native-chat.jumpToLatest', 'Jump to latest')}</span>
+            </button>
+          ) : null}
         </div>
         {taskListState.list && taskListState.list.tasks.length > 0 ? (
           <div className="shrink-0 px-3 pb-2 sm:px-4">

From 8639591b922752ad5e0cf7e1b163dedea42c3551 Mon Sep 17 00:00:00 2001
From: Brennan Benson <79079362+brennanb2025@users.noreply.github.com>
Date: Mon, 5 Oct 2026 21:28:45 -0700
Subject: [PATCH 07/14] Preserve native chat reader intent across submissions
 and disclosure layout

Replace open-row lifetime tracking with bounded position preservation, and tie delayed reveals to the originating reader and session. Keep queued drafts and picker actions from navigating the transcript.

Co-authored-by: Kelvin Amoaba <97001695+AmoabaKelvin@users.noreply.github.com>
---
 .../native-chat/NativeChatComposer.tsx        |   2 +
 .../native-chat/NativeChatDiffCard.tsx        |   2 +-
 .../native-chat/NativeChatJumpToLatest.tsx    |  16 +
 ...eChatMessageList.growth-windowing.test.tsx |   1 +
 ...ChatMessageList.rail-history-jump.test.tsx |  24 +-
 ...ChatMessageList.reader-navigation.test.tsx |  98 +++-
 .../native-chat/NativeChatMessageList.tsx     |  62 +--
 .../native-chat/NativeChatMessageRail.tsx     |   7 +-
 .../native-chat/NativeChatResolvedView.tsx    |  10 +-
 ...tiveChatStructuredSession.test-harness.tsx |   1 +
 .../NativeChatStructuredSession.tsx           |  19 +-
 ...tiveChatStructuredSessionDelivery.test.tsx |   1 +
 .../native-chat-autoscroll.test.ts            | 132 +-----
 .../native-chat/native-chat-autoscroll.ts     |  97 ++--
 .../native-chat/native-chat-composer-types.ts |   9 +-
 .../native-chat-disclosure-store.ts           |   8 +-
 .../native-chat-reader-scroll-input.test.tsx  |  83 ++++
 .../native-chat-reader-scroll-input.ts        | 143 +++++-
 .../native-chat-root-key-routing.ts           |   9 +
 .../native-chat-send-reveal-ratchet.test.ts   |  26 --
 ...ative-chat-structured-composer-dispatch.ts |  11 +-
 ...native-chat-submission-navigation.test.tsx | 441 ++++++++++++++++++
 .../native-chat-windowing-test-harness.tsx    |   1 +
 .../use-native-chat-composer-submit.ts        |   3 +-
 ...e-native-chat-disclosure-position.test.tsx | 160 +++++++
 .../use-native-chat-disclosure-position.ts    |  89 ++++
 .../use-native-chat-local-command-answer.ts   |   2 +
 ...use-native-chat-picker-command-dispatch.ts |   1 +
 .../use-native-chat-reader-opens.test.ts      |  25 +-
 .../use-native-chat-reader-opens.ts           |  35 +-
 .../use-native-chat-reveal-latest.ts          |  51 +-
 .../use-native-chat-session-option-command.ts |  16 +-
 ...se-native-chat-structured-composer-send.ts |   8 +-
 ...use-native-chat-transcript-scroll.test.tsx |  24 +-
 .../use-native-chat-transcript-scroll.ts      | 232 ++++-----
 ...tured-agent-session.queued-gating.test.tsx |  33 +-
 .../use-structured-agent-session.ts           |  24 +-
 ...se-structured-native-chat-submit-reveal.ts |   2 +
 .../structured-agent-session-composer.ts      |   3 +
 39 files changed, 1464 insertions(+), 447 deletions(-)
 create mode 100644 src/renderer/src/components/native-chat/NativeChatJumpToLatest.tsx
 create mode 100644 src/renderer/src/components/native-chat/native-chat-reader-scroll-input.test.tsx
 delete mode 100644 src/renderer/src/components/native-chat/native-chat-send-reveal-ratchet.test.ts
 create mode 100644 src/renderer/src/components/native-chat/native-chat-submission-navigation.test.tsx
 create mode 100644 src/renderer/src/components/native-chat/use-native-chat-disclosure-position.test.tsx
 create mode 100644 src/renderer/src/components/native-chat/use-native-chat-disclosure-position.ts

diff --git a/src/renderer/src/components/native-chat/NativeChatComposer.tsx b/src/renderer/src/components/native-chat/NativeChatComposer.tsx
index dddb1d8ecb6e..b370b44d2453 100644
--- a/src/renderer/src/components/native-chat/NativeChatComposer.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatComposer.tsx
@@ -65,6 +65,7 @@ const NativeChatComposerPane = forwardRef<NativeChatComposerHandle, NativeChatCo
       onOptimisticSendCanceled,
       onSlashCommand,
       onSubmitted,
+      holdRevealLatest,
       answerCommandLocally,
       onSwitchToTerminal,
       readTerminalScreen,
@@ -222,6 +223,7 @@ const NativeChatComposerPane = forwardRef<NativeChatComposerHandle, NativeChatCo
         disabled,
         onSlashCommand,
         onSubmitted,
+        holdRevealLatest,
         resolveTarget,
         setHistory
       })
diff --git a/src/renderer/src/components/native-chat/NativeChatDiffCard.tsx b/src/renderer/src/components/native-chat/NativeChatDiffCard.tsx
index bc0f47f22602..8d38710c30e1 100644
--- a/src/renderer/src/components/native-chat/NativeChatDiffCard.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatDiffCard.tsx
@@ -131,7 +131,7 @@ export function NativeChatDiffCard({
   const cardRef = useRef<HTMLDivElement>(null)
   useLayoutEffect(() => {
     if (revealSignal && cardRef.current) {
-      setExpanded(true)
+      setExpanded(true, false)
       // Reported from the card, not the row: a turn that touched four files must
       // land on the one that was asked for, and only the card knows where it is.
       onReveal?.(cardRef.current)
diff --git a/src/renderer/src/components/native-chat/NativeChatJumpToLatest.tsx b/src/renderer/src/components/native-chat/NativeChatJumpToLatest.tsx
new file mode 100644
index 000000000000..63d3adc1fe56
--- /dev/null
+++ b/src/renderer/src/components/native-chat/NativeChatJumpToLatest.tsx
@@ -0,0 +1,16 @@
+import { ArrowDown } from 'lucide-react'
+import { translate } from '@/i18n/i18n'
+
+export function NativeChatJumpToLatest({ onClick }: { onClick: () => void }): React.JSX.Element {
+  return (
+    <button
+      type="button"
+      onClick={onClick}
+      aria-label={translate('components.native-chat.jumpToLatest', 'Jump to latest')}
+      className="absolute bottom-3 left-1/2 flex -translate-x-1/2 items-center gap-1.5 rounded-full border border-border bg-card/90 px-3 py-1.5 text-xs text-muted-foreground shadow-sm backdrop-blur hover:bg-accent hover:text-accent-foreground focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring"
+    >
+      <ArrowDown className="size-3.5" />
+      <span>{translate('components.native-chat.jumpToLatest', 'Jump to latest')}</span>
+    </button>
+  )
+}
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 e2af487149d4..62488d8b4bea 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
@@ -454,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.rail-history-jump.test.tsx b/src/renderer/src/components/native-chat/NativeChatMessageList.rail-history-jump.test.tsx
index 73d478c6b18f..ceacd4da04d8 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
@@ -3,7 +3,7 @@
 import '@testing-library/jest-dom/vitest'
 
 import { act, cleanup, fireEvent, render, screen } from '@testing-library/react'
-import { useCallback, useMemo, useState } from 'react'
+import { createRef, useCallback, useMemo, useState } from 'react'
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 import type {
   AgentJournalItemBody,
@@ -11,6 +11,7 @@ import type {
 } from '../../../../shared/agent-session-journal-types'
 import type { NativeChatMessage } from '../../../../shared/native-chat-types'
 import { projectStructuredItemsToNativeChat } from '../../../../shared/structured-agent-session-projection'
+import type { NativeChatMessageListHandle } from './use-native-chat-reveal-latest'
 import { NativeChatMessageList } from './NativeChatMessageList'
 import type { NativeChatRailOutlineEntry } from './native-chat-message-rail-items'
 import type { NativeChatOlderPageResult } from './native-chat-pagination'
@@ -70,10 +71,12 @@ 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,
+  handle
 }: {
   /** Awaited before a page lands, to keep it in flight. */
   holdPage?: () => Promise<void>
+  handle?: React.RefObject<NativeChatMessageListHandle | null>
 }): React.JSX.Element {
   const [loaded, setLoaded] = useState(PAGE)
   const loadEarlier = useCallback(async (): Promise<NativeChatOlderPageResult> => {
@@ -95,6 +98,7 @@ function PagedTranscript({
   )
   return (
     <NativeChatMessageList
+      ref={handle}
       session={{ ...session(messages), hasMore: loaded < TOTAL, loadEarlier }}
       railOutline={railOutline}
       isWorking={false}
@@ -346,6 +350,21 @@ describe('jumping from the rail while following the end', () => {
     await frame()
   }
 
+  it('a delayed accepted answer cannot cancel a newer unloaded rail selection', async () => {
+    const pages = holdFirstPage()
+    const handle = createRef<NativeChatMessageListHandle>()
+    render(<PagedTranscript holdPage={pages.holdPage} handle={handle} />)
+    await settle(10)
+    const acceptance = handle.current?.holdRevealLatest()
+    await pickUnloadedWhilePaging('prompt-5')
+    expect(pages.asked()).toBe(1)
+    act(() => acceptance?.())
+    expect(screen.getByRole('button', { name: 'prompt-5' }).getAttribute('aria-busy')).toBe('true')
+    pages.release()
+    await settle(60)
+    expect(Math.abs(rowOffsetFromViewportTop('prompt-5'))).toBeLessThanOrEqual(2)
+  })
+
   it('keeps the list open with the pick marked busy until its history lands', async () => {
     const pages = holdFirstPage()
     render(<PagedTranscript holdPage={pages.holdPage} />)
@@ -434,6 +453,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)
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
index 75acda4f4cb3..a192e9b1065f 100644
--- a/src/renderer/src/components/native-chat/NativeChatMessageList.reader-navigation.test.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatMessageList.reader-navigation.test.tsx
@@ -4,8 +4,9 @@ import '@testing-library/jest-dom/vitest'
 
 import { act, cleanup, fireEvent, render, screen } from '@testing-library/react'
 import { createRef } from 'react'
-import { afterEach, beforeEach, describe, expect, it } from 'vitest'
+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 {
@@ -40,13 +41,14 @@ function paint(container: HTMLElement): void {
     let changed = false
     act(() => {
       changed = deliverResizes()
+      vi.advanceTimersByTime(16)
     })
     if (scroller.scrollTop !== lastScrollTop) {
       lastScrollTop = scroller.scrollTop
       fireEvent.scroll(scroller)
       changed = true
     }
-    if (!changed) {
+    if (!changed && pass >= 2) {
       return
     }
   }
@@ -126,6 +128,7 @@ function offersJumpToLatest(): boolean {
 describe('reader navigation', () => {
   let restore: (() => void)[] = []
   beforeEach(() => {
+    vi.useFakeTimers()
     restore = [stubLayout({ scrollGeometry: true, offsetChain: true }), stubResizeObserver()]
     layout.belowTranscriptPx = BELOW_TRANSCRIPT_PX
     layout.aboveTranscriptPx = 0
@@ -135,6 +138,7 @@ describe('reader navigation', () => {
       undo()
     }
     layout.measuredRowHeights = []
+    vi.useRealTimers()
   })
 
   it('brings a reader who scrolled up to what they just sent, and follows its reply', () => {
@@ -299,7 +303,7 @@ describe('reader navigation', () => {
     const withTool = [...transcript, toolMessage(toolIndex)]
     const streamedOn = [...withTool, marker(toolIndex + 1), marker(toolIndex + 2)]
 
-    it('returns to the end and follows it, however far the turn streamed meanwhile', () => {
+    it('closing the last open run preserves history when the tail is still distant', () => {
       const { container, rerender } = render(liveList(withTool))
       paint(container)
       const [run] = closedRuns(1)
@@ -310,14 +314,16 @@ describe('reader navigation', () => {
       expect(distanceFromBottom(container)).toBeGreaterThan(ROW_PX * 5)
       expect(offersJumpToLatest()).toBe(true)
 
+      const beforeClose = scrollRoot(container).scrollTop
       toggleRun(container, run.toggle, [])
-      expect(distanceFromBottom(container)).toBe(0)
-      expect(offersJumpToLatest()).toBe(false)
+      expect(scrollRoot(container).scrollTop).toBe(beforeClose)
+      expect(distanceFromBottom(container)).toBeGreaterThan(0)
+      expect(offersJumpToLatest()).toBe(true)
       rerender(liveList([...streamedOn, marker(toolIndex + 3)]))
       paint(container)
 
-      expect(distanceFromBottom(container)).toBe(0)
-      expect(screen.getByText(`marker-${toolIndex + 3}`)).toBeInTheDocument()
+      expect(scrollRoot(container).scrollTop).toBe(beforeClose)
+      expect(distanceFromBottom(container)).toBeGreaterThan(0)
     })
 
     it('stays where the reader scrolled to while it was open', () => {
@@ -337,7 +343,7 @@ describe('reader navigation', () => {
       expect(offersJumpToLatest()).toBe(true)
     })
 
-    it('follows again only once the last of two opened runs is closed', () => {
+    it('derives following from geometry rather than counting two open runs', () => {
       const twoTools = [...withTool, marker(toolIndex + 1), toolMessage(toolIndex + 2)]
       const { container, rerender } = render(liveList(twoTools))
       paint(container)
@@ -355,7 +361,7 @@ describe('reader navigation', () => {
       expect(distanceFromBottom(container)).toBeGreaterThan(0)
 
       toggleRun(container, second.toggle, [])
-      expect(distanceFromBottom(container)).toBe(0)
+      expect(distanceFromBottom(container)).toBeGreaterThan(0)
     })
 
     it('leaves a reader who had already scrolled away where they are', () => {
@@ -424,6 +430,80 @@ describe('reader navigation', () => {
     expect(scrollRoot(container).scrollTop).toBe(scrollTopBeforeOpen)
   })
 
+  it('replaces a pending numeric tail pin before a disclosure inserts earlier rows', () => {
+    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}
+        fontScale={1}
+        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 toggle = screen.getByRole('button', { name: 'Toggle turn details' })
+    const window = container.querySelector<HTMLElement>('[data-native-chat-window]')
+    const beforeSlots = window?.querySelectorAll('[data-index]').length ?? 0
+    toggle.getBoundingClientRect = () => new DOMRect(0, -scroller.scrollTop, 100, 20)
+    // A pin created outside the painted frames is still waiting to reconcile by numeric index.
+    layout.belowTranscriptPx += 20
+    deliverResizes()
+    const before = scroller.scrollTop
+    expect(before).toBeGreaterThan(0)
+    fireEvent.click(toggle)
+    const expandedSlots = window?.querySelectorAll('[data-index]').length ?? 0
+    expect(expandedSlots).toBeGreaterThan(beforeSlots)
+    paint(container)
+    expect(scroller.scrollTop).toBe(before)
+    expect(distanceFromBottom(container)).toBeGreaterThan(0)
+    act(() => vi.advanceTimersByTime(160))
+    expect(scroller.scrollTop).toBe(before)
+  })
+
+  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('makes the transcript a keyboard stop, so the scroll keys can reach it', () => {
     const { container } = render(list(transcript))
 
diff --git a/src/renderer/src/components/native-chat/NativeChatMessageList.tsx b/src/renderer/src/components/native-chat/NativeChatMessageList.tsx
index 84640e2e5a7f..a198ee67ba40 100644
--- a/src/renderer/src/components/native-chat/NativeChatMessageList.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatMessageList.tsx
@@ -1,5 +1,5 @@
 import { useCallback, useLayoutEffect, useMemo, useRef, useState } from 'react'
-import { ArrowDown } from 'lucide-react'
+import { NativeChatJumpToLatest } from './NativeChatJumpToLatest'
 import type { CommentMarkdownLinkClickHandler } from '@/components/sidebar/CommentMarkdown'
 import { translate } from '@/i18n/i18n'
 import type { NativeChatLiveSession } from './use-native-chat-live-session'
@@ -39,7 +39,7 @@ 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 { useNativeChatReaderOpens } from './use-native-chat-reader-opens'
 import { useNativeChatMessageListHandle } from './use-native-chat-reveal-latest'
 
@@ -265,10 +265,14 @@ export function NativeChatMessageList({
     loadEarlier,
     jumpToLoaded: requestRailJump
   })
-  const { start: startHistoryJump, abort: beginNavigation } = railHistoryJump
+  const { readerActs, readerLeavesEnd } = follow
+  const { start: startHistoryJump, abort: abortHistoryJump } = railHistoryJump
+  const beginNavigation = useCallback(() => {
+    abortHistoryJump()
+    readerActs()
+  }, [abortHistoryJump, readerActs])
   const readerOpens = useNativeChatReaderOpens({
     subagentDisclosure,
-    expandedTurnIds,
     setExpandedTurnIds,
     follow,
     abortNavigation: beginNavigation
@@ -277,18 +281,20 @@ export function NativeChatMessageList({
   // 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)
@@ -299,26 +305,18 @@ export function NativeChatMessageList({
         target: { ...target, requestId: navigationSequence.current }
       })
     },
-    [beginNavigation, openSubagentSections]
+    [beginNavigation, readerLeavesEnd, openSubagentSections]
   )
   const jumpToLatest = useCallback(() => {
     beginNavigation()
     scrollToBottom()
   }, [beginNavigation, scrollToBottom])
   useNativeChatMessageListHandle(ref, jumpToLatest, follow.untilReaderActs)
-  const readerScrollInput = useMemo(
-    () => nativeChatReaderScrollInputHandlers(beginNavigation),
-    [beginNavigation]
-  )
-  // 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
-  // token snaps the reader straight back down.
-  //
-  // Serviced once per request, then released. `slots` takes a new identity on
-  // every render, so an effect that merely depended on it would re-scroll to this
-  // row forever; and a request left standing would keep its pin, which outranks
-  // the diff reveal that shares it.
+  const readerScrollInput = useNativeChatReaderScrollInput(scrollRef, {
+    onReaderScroll: beginNavigation,
+    onLeaveEnd: readerLeavesEnd
+  })
+  // Service each pinned request once; a streaming render must not restart its scroll.
   useLayoutEffect(() => {
     if (railJump === null || servicedRailJumpRef.current === railJump.requestId) {
       return
@@ -370,19 +368,15 @@ export function NativeChatMessageList({
           <div
             ref={scrollRef}
             onScroll={follow.onScroll}
-            {...readerScrollInput}
+            {...readerScrollInput.scrollerProps}
+            onClickCapture={follow.captureDisclosureTarget}
             // 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] focus-visible:outline-none focus-visible:ring-1 focus-visible:ring-inset focus-visible:ring-ring"
-            // Why: `zoom` scales the chat transcript's text and layout together,
-            // scoped to this pane so the rest of the app is untouched. It sits on
-            // the scroll container rather than the content inside it so that
-            // scroll offsets and row measurements share one coordinate space —
-            // measuring zoomed content against an unzoomed scroller misplaces the
-            // window by exactly `fontScale`. (Chromium/Electron only.)
+            // Zoom shares the scroll container's coordinate space with virtualized measurements.
             style={{ zoom: fontScale }}
           >
             {showOlderHistory ? (
@@ -419,20 +413,10 @@ export function NativeChatMessageList({
             rail={rail}
             scrollRef={scrollRef}
             onSelect={selectRailItem}
-            onReaderScroll={beginNavigation}
+            onReaderScroll={readerScrollInput.railWheel}
             pendingId={railHistoryJump.pendingId}
           />
-          {follow.showJump ? (
-            <button
-              type="button"
-              onClick={jumpToLatest}
-              aria-label={translate('components.native-chat.jumpToLatest', 'Jump to latest')}
-              className="absolute bottom-3 left-1/2 flex -translate-x-1/2 items-center gap-1.5 rounded-full border border-border bg-card/90 px-3 py-1.5 text-xs text-muted-foreground shadow-sm backdrop-blur hover:bg-accent hover:text-accent-foreground focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring"
-            >
-              <ArrowDown className="size-3.5" />
-              <span>{translate('components.native-chat.jumpToLatest', 'Jump to latest')}</span>
-            </button>
-          ) : null}
+          {follow.showJump ? <NativeChatJumpToLatest onClick={jumpToLatest} /> : null}
         </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/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/NativeChatResolvedView.tsx b/src/renderer/src/components/native-chat/NativeChatResolvedView.tsx
index 3aefe5ce2e8f..74b7b087706e 100644
--- a/src/renderer/src/components/native-chat/NativeChatResolvedView.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatResolvedView.tsx
@@ -123,7 +123,9 @@ export function NativeChatResolvedView({
     agent
   )
   // Every send this pane makes brings the latest into view, wherever the reader had scrolled.
-  const { messageListRef, revealLatest } = useNativeChatRevealLatest()
+  const revealScope = `${agent}:${sessionId}:${targetPtyId}`
+  const reveals = useNativeChatRevealLatest(revealScope, isVisible)
+  const { messageListRef, revealLatest, holdRevealLatest } = reveals
   const interactiveSend = useMemo<NativeChatInteractiveSend>(
     () => ({
       // Only what is written moves the reader: no terminal, or an empty answer, writes nothing.
@@ -180,9 +182,7 @@ export function NativeChatResolvedView({
     }
   })
 
-  // Optimistic "queued" sends (mobile parity): a composer send is echoed
-  // immediately and pruned once its real user turn lands in the transcript, so
-  // the message never vanishes between send and transcript catch-up.
+  // Keep the optimistic echo until its real transcript turn arrives.
   const commandMarkerScope = useMemo(
     () => ({ paneKey, agent, sessionId }),
     [paneKey, agent, sessionId]
@@ -392,6 +392,7 @@ export function NativeChatResolvedView({
           <NativeChatEmptyState kind="empty" agent={agent} />
         ) : (
           <NativeChatMessageList
+            key={`${agent}:${sessionId}`}
             ref={messageListRef}
             session={sessionWithPending}
             isVisible={isVisible}
@@ -434,6 +435,7 @@ export function NativeChatResolvedView({
           optimisticSendOutcome={delivery}
           onSlashCommand={onSlashCommand}
           onSubmitted={revealLatest}
+          holdRevealLatest={holdRevealLatest}
           answerCommandLocally={answerLocally}
           onSwitchToTerminal={onSwitchToTerminal}
           readTerminalScreen={readTerminalScreen}
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 67c6ef8cf804..ac3a590a4566 100644
--- a/src/renderer/src/components/native-chat/NativeChatStructuredSession.test-harness.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatStructuredSession.test-harness.tsx
@@ -223,6 +223,7 @@ export function createStructuredSessionMocks() {
             failedHere: outbox.failedHere,
             submissions: mocks.submissions,
             send: outbox.send,
+            sendFromComposer: outbox.send,
             retry: outbox.retry,
             isWorking: mocks.isWorking,
             backgroundTasks: {
diff --git a/src/renderer/src/components/native-chat/NativeChatStructuredSession.tsx b/src/renderer/src/components/native-chat/NativeChatStructuredSession.tsx
index 446819562d11..adcc4411ff39 100644
--- a/src/renderer/src/components/native-chat/NativeChatStructuredSession.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatStructuredSession.tsx
@@ -116,7 +116,7 @@ export function NativeChatStructuredSession(
     [controller, historyPhase, props.agent, props.sessionId]
   )
   const submits = useStructuredNativeChatSubmitReveal(controller, provisionalLaunch.retry)
-  const { retryDelivery, revealLatest } = submits
+  const { retryDelivery, revealLatest, holdRevealLatest } = submits
   const agentLabel = structuredAgentLabel(props.agent === 'codex' ? 'codex' : 'claude')
   const deliveryNotices = useStructuredAgentSessionDeliveryNotices({
     outbox: controller.outbox,
@@ -189,16 +189,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.sendFromComposer(
             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,
@@ -222,6 +229,7 @@ export function NativeChatStructuredSession(
       worktreeId: fileLinkContext?.worktreeId,
       onError: setComposerError,
       onSubmitted: revealLatest,
+      holdRevealLatest,
       runtime: (props.target.kind === 'local' ? 'local' : 'remote') as 'local' | 'remote',
       sessionId: props.sessionId,
       runtimeEnvironmentId:
@@ -235,6 +243,7 @@ export function NativeChatStructuredSession(
     props.sessionId,
     props.target,
     revealLatest,
+    holdRevealLatest,
     sendThroughRelaunch
   ])
 
diff --git a/src/renderer/src/components/native-chat/NativeChatStructuredSessionDelivery.test.tsx b/src/renderer/src/components/native-chat/NativeChatStructuredSessionDelivery.test.tsx
index d5493654e8e0..ff8272ece544 100644
--- a/src/renderer/src/components/native-chat/NativeChatStructuredSessionDelivery.test.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatStructuredSessionDelivery.test.tsx
@@ -86,6 +86,7 @@ vi.mock('./use-structured-agent-session', async () => {
         failedHere: outbox.failedHere,
         submissions: mocks.submissions,
         send: outbox.send,
+        sendFromComposer: outbox.send,
         retry: outbox.retry,
         isWorking: false,
         isMonitoringBackgroundTasks: mocks.monitoringBackgroundTasks,
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 0d83aefcb00f..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
@@ -1,15 +1,12 @@
 import { describe, it, expect } from 'vitest'
 import {
   distanceFromBottom,
-  FOLLOWING,
   isNearBottom,
   nextFollowingEnd,
-  nextFollowState,
   shouldShowJumpToLatest,
   NATIVE_CHAT_BOTTOM_THRESHOLD_PX,
   NATIVE_CHAT_FOLLOW_REARM_PX,
-  type FollowEvent,
-  type FollowState
+  readerGestureLeavesEnd
 } from './native-chat-autoscroll'
 
 const atBottom = { scrollTop: 952, scrollHeight: 1000, clientHeight: 48 }
@@ -80,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])(
@@ -102,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)
   })
@@ -147,115 +144,16 @@ describe('nextFollowingEnd', () => {
   })
 })
 
-describe('nextFollowState', () => {
-  const opened = (...rows: string[]): FollowState => ({
-    kind: 'detached',
-    reason: 'open',
-    opens: new Set(rows)
-  })
-  const scrolled: FollowState = { kind: 'detached', reason: 'scroll' }
-  const navigated: FollowState = { kind: 'detached', reason: 'navigation' }
-  const scroll = (distance: number, programmatic = false): FollowEvent => ({
-    kind: 'scroll',
-    programmatic,
-    geometry: parkedAbove(distance),
-    previousDistanceFromEnd: 400
-  })
-  const events = {
-    'reader opens a': { kind: 'open', row: 'a' },
-    'reader opens c': { kind: 'open', row: 'c' },
-    'reader closes a': { kind: 'close', row: 'a' },
-    // Opened before this detach, so never one of its opens.
-    'reader closes c': { kind: 'close', row: 'c' },
-    'reader scrolls away': scroll(200),
-    'reader scrolls to the end': scroll(0),
-    'application scrolls away': scroll(200, true),
-    'application scrolls to the end': scroll(0, true),
-    'reader reveals the latest': { kind: 'reveal-latest' },
-    'reader navigates': { kind: 'navigate' }
-  } satisfies Record<string, FollowEvent>
-
-  const row = (
-    name: string,
-    state: FollowState,
-    after: Record<keyof typeof events, FollowState>
-  ): { name: string; state: FollowState; after: Map<string, FollowState> } => ({
-    name,
-    state,
-    after: new Map(Object.entries(after))
-  })
-  const table = [
-    row('following', FOLLOWING, {
-      'reader opens a': opened('a'),
-      'reader opens c': opened('c'),
-      'reader closes a': FOLLOWING,
-      'reader closes c': FOLLOWING,
-      'reader scrolls away': scrolled,
-      'reader scrolls to the end': FOLLOWING,
-      'application scrolls away': FOLLOWING,
-      'application scrolls to the end': FOLLOWING,
-      'reader reveals the latest': FOLLOWING,
-      'reader navigates': navigated
-    }),
-    row('scrolled away', scrolled, {
-      'reader opens a': scrolled,
-      'reader opens c': scrolled,
-      'reader closes a': scrolled,
-      'reader closes c': scrolled,
-      'reader scrolls away': scrolled,
-      'reader scrolls to the end': FOLLOWING,
-      'application scrolls away': scrolled,
-      'application scrolls to the end': scrolled,
-      'reader reveals the latest': FOLLOWING,
-      'reader navigates': navigated
-    }),
-    row('navigated away', navigated, {
-      'reader opens a': navigated,
-      'reader opens c': navigated,
-      'reader closes a': navigated,
-      'reader closes c': navigated,
-      'reader scrolls away': scrolled,
-      'reader scrolls to the end': FOLLOWING,
-      'application scrolls away': navigated,
-      'application scrolls to the end': navigated,
-      'reader reveals the latest': FOLLOWING,
-      'reader navigates': navigated
-    }),
-    row('opened a', opened('a'), {
-      'reader opens a': opened('a'),
-      'reader opens c': opened('a', 'c'),
-      'reader closes a': FOLLOWING,
-      'reader closes c': opened('a'),
-      'reader scrolls away': scrolled,
-      'reader scrolls to the end': FOLLOWING,
-      'application scrolls away': opened('a'),
-      'application scrolls to the end': opened('a'),
-      'reader reveals the latest': FOLLOWING,
-      'reader navigates': navigated
-    }),
-    row('opened a and b', opened('a', 'b'), {
-      'reader opens a': opened('a', 'b'),
-      'reader opens c': opened('a', 'b', 'c'),
-      'reader closes a': opened('b'),
-      'reader closes c': opened('a', 'b'),
-      'reader scrolls away': scrolled,
-      'reader scrolls to the end': FOLLOWING,
-      'application scrolls away': opened('a', 'b'),
-      'application scrolls to the end': opened('a', 'b'),
-      'reader reveals the latest': FOLLOWING,
-      'reader navigates': navigated
-    })
-  ]
-
-  const cases = table.flatMap(({ name, state, after }) =>
-    Object.entries(events).map(([eventName, event]) => ({
-      name: `${name}: ${eventName}`,
-      state,
-      event,
-      expected: after.get(eventName)
-    }))
+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
   )
-  it.each(cases)('$name', ({ state, event, expected }) => {
-    expect(nextFollowState(state, event)).toEqual(expected)
-  })
 })
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 e7170c9e4cc0..170fdc89c7f2 100644
--- a/src/renderer/src/components/native-chat/native-chat-autoscroll.ts
+++ b/src/renderer/src/components/native-chat/native-chat-autoscroll.ts
@@ -52,68 +52,63 @@ 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)
 }
 
-/** Whether the transcript follows its end, and if not, what the reader did to stop it. */
-export type FollowState =
-  | { kind: 'following' }
-  | { kind: 'detached'; reason: 'scroll' | 'navigation' }
-  /** Stopped only by opening rows, and not scrolled since: closing the last one follows again. */
-  | { kind: 'detached'; reason: 'open'; opens: ReadonlySet<string> }
+/** 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'; deltaY?: number }
+  | { kind: 'scrollbar-press' }
+  | { kind: 'content-press' }
+  | { kind: 'key'; key: string; shift?: boolean }
 
-export type FollowEvent =
-  | { kind: 'open' | 'close'; row: string }
-  | ({ kind: 'scroll' } & Omit<FollowIntent, 'following'>)
-  | { kind: 'reveal-latest' }
-  | { kind: 'navigate' }
+const KEYS_AWAY_FROM_END = new Set(['PageUp', 'Home', 'ArrowUp'])
+const KEYS_TOWARD_END = new Set(['PageDown', 'End', 'ArrowDown'])
 
-export const FOLLOWING: FollowState = { kind: 'following' }
+/** 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 === 'touch-drag' && gesture.deltaY !== undefined) {
+    return 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
+}
 
-export function nextFollowState(state: FollowState, event: FollowEvent): FollowState {
-  switch (event.kind) {
-    case 'open':
-      if (state.kind === 'following') {
-        return { kind: 'detached', reason: 'open', opens: new Set([event.row]) }
-      }
-      return state.reason === 'open' && !state.opens.has(event.row)
-        ? { ...state, opens: new Set([...state.opens, event.row]) }
-        : state
-    case 'close': {
-      // By identity: a row opened before this detach is not one of its opens.
-      if (state.kind === 'following' || state.reason !== 'open' || !state.opens.has(event.row)) {
-        return state
-      }
-      const opens = new Set(state.opens)
-      opens.delete(event.row)
-      return opens.size === 0 ? FOLLOWING : { ...state, opens }
+/** 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
+    case 'touch-drag':
+      return gesture.deltaY === undefined
+        ? awayFromEnd
+        : readerGestureDirection(gesture) < 0 && contentAbove
+    case 'content-press':
+      return awayFromEnd
+    case 'key': {
+      const direction = readerGestureDirection(gesture)
+      return direction < 0 ? contentAbove : direction > 0 && awayFromEnd
     }
-    case 'scroll':
-      if (event.programmatic) {
-        return state
-      }
-      return nextFollowingEnd({ ...event, following: state.kind === 'following' })
-        ? FOLLOWING
-        : { kind: 'detached', reason: 'scroll' }
-    case 'reveal-latest':
-      return FOLLOWING
-    case 'navigate':
-      return { kind: 'detached', reason: 'navigation' }
   }
 }
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 038896fd57e1..a57cf0c13a16 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
@@ -18,7 +18,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[]
@@ -34,6 +37,8 @@ export type NativeChatStructuredComposerTransport = {
   onError: (message: string | null) => void
   /** The host accepted a message, a command it runs itself, or a goal. */
   onSubmitted?: () => void
+  /** Capture this pane and reader position before waiting for acceptance. */
+  holdRevealLatest?: () => () => void
   runtime: 'local' | 'remote'
   /** The session behind this composer; a real user send relinquishes orchestration ownership. */
   sessionId: string
@@ -78,6 +83,8 @@ export type NativeChatComposerProps = {
   answerCommandLocally?: NativeChatLocalCommandAnswer
   /** Anything delivered to the terminal: a message, a command or a session option. */
   onSubmitted?: () => void
+  /** Capture this pane and reader position before waiting for acceptance. */
+  holdRevealLatest?: () => () => 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-disclosure-store.ts b/src/renderer/src/components/native-chat/native-chat-disclosure-store.ts
index 53e4d315feb5..f7514d78baf8 100644
--- a/src/renderer/src/components/native-chat/native-chat-disclosure-store.ts
+++ b/src/renderer/src/components/native-chat/native-chat-disclosure-store.ts
@@ -46,7 +46,7 @@ export function useNativeChatDisclosures(): NativeChatDisclosureStore {
 export type NativeChatDisclosure = {
   open: boolean
   /** A reader's choice: remembered past this row's lifetime when keyed. */
-  setOpen: (next: boolean) => void
+  setOpen: (next: boolean, readerInitiated?: boolean) => void
 }
 
 export function useNativeChatDisclosure(
@@ -64,12 +64,14 @@ export function useNativeChatDisclosure(
     local.key === key && local.initialOpen === initialOpen ? local.open : initialOpen
   const open = isStored ? (store.read(key) ?? localOpen) : localOpen
   const setOpen = useCallback(
-    (next: boolean) => {
+    (next: boolean, readerInitiated = true) => {
       setLocal({ key, initialOpen, open: next })
       if (key !== undefined && write) {
         write(key, next)
       }
-      onToggle?.(row, next)
+      if (readerInitiated) {
+        onToggle?.(row, next)
+      }
     },
     [initialOpen, key, onToggle, row, write]
   )
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..9d853dbd7f49
--- /dev/null
+++ b/src/renderer/src/components/native-chat/native-chat-reader-scroll-input.test.tsx
@@ -0,0 +1,83 @@
+// @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, touch, scrollbar and rail gestures', () => {
+  const h = harness()
+  fireEvent.keyDown(h.root, { key: 'PageUp' })
+  fireEvent.keyDown(h.root, { key: ' ', shiftKey: true })
+  fireEvent.touchStart(h.root, { touches: [{ clientY: 100 }] })
+  fireEvent.touchMove(h.root, { touches: [{ clientY: 130 }] })
+  fireEvent.pointerDown(h.root)
+  h.railWheel(-20)
+  expect(h.onLeaveEnd).toHaveBeenCalledTimes(5)
+})
+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()
+  fireEvent.touchStart(h.root, { touches: [{ clientY: 100 }] })
+  fireEvent.touchMove(h.root, { touches: [{ clientY: 100 }] })
+  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 448c5054ee3a..b5a6c04eb84b 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,31 +24,146 @@ 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' | 'tabIndex' | 'role'
+  'onWheel' | 'onTouchStart' | 'onTouchMove' | 'onKeyDown' | 'onPointerDown' | 'tabIndex' | 'role'
 >
 
-/** Scroller props that call `onReaderScroll` on a wheel, touch drag, scroll key or
- *  scrollbar grab. Focusable, so the scroll keys reach it; a named region once focused. */
-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 {
+  let touchY: number | null = null
+  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 {
     tabIndex: 0,
     role: 'region',
-    onWheel: onReaderScroll,
-    onTouchMove: onReaderScroll,
+    onWheel: (event) => {
+      if (event.ctrlKey || event.deltaY === 0) {
+        return
+      }
+      onReaderScroll()
+      report({ kind: 'wheel', deltaY: event.deltaY, zoom: event.ctrlKey }, event)
+    },
+    onTouchStart: (event) => {
+      touchY = event.touches[0]?.clientY ?? null
+    },
+    onTouchMove: (event) => {
+      const nextY = event.touches[0]?.clientY ?? null
+      const deltaY = touchY !== null && nextY !== null ? touchY - nextY : undefined
+      touchY = nextY
+      if (deltaY === 0) {
+        return
+      }
+      onReaderScroll()
+      report({ kind: 'touch-drag', deltaY }, 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-send-reveal-ratchet.test.ts b/src/renderer/src/components/native-chat/native-chat-send-reveal-ratchet.test.ts
deleted file mode 100644
index d03414687415..000000000000
--- a/src/renderer/src/components/native-chat/native-chat-send-reveal-ratchet.test.ts
+++ /dev/null
@@ -1,26 +0,0 @@
-import { readdirSync, readFileSync } from 'node:fs'
-import path from 'node:path'
-import { expect, it } from 'vitest'
-
-/** Files that send without revealing the latest, each with its reason. */
-const EXEMPT: Readonly<Record<string, string>> = {}
-
-// A send path that skips `onSubmitted` leaves a scrolled-up reader looking at old output.
-it('reveals the latest from every file that sends a native chat message', () => {
-  const dir = import.meta.dirname
-  const senders = readdirSync(dir, { recursive: true, encoding: 'utf8' })
-    .filter((name) => /\.tsx?$/.test(name) && !/\.test\.tsx?$/.test(name))
-    // Comments dropped, so only a real call counts.
-    .map((name) => ({
-      name,
-      source: readFileSync(path.join(dir, name), 'utf8').replace(/\/\/.*$/gm, '')
-    }))
-    .filter(({ source }) => source.includes('emitNativeChatMessageSent('))
-  const silent = senders
-    .filter(({ name, source }) => !(name in EXEMPT) && !/\bonSubmitted\?\.\(\)/.test(source))
-    .map(({ name }) => name)
-
-  // Anti-vacuous: the scan found the send sites.
-  expect(senders.length).toBeGreaterThan(0)
-  expect(silent).toEqual([])
-})
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..8ea2c58251ee 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,15 @@ 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)
   if (command.handled) {
-    return { accepted: command.accepted, error: command.error }
+    return {
+      accepted: command.accepted,
+      error: command.error,
+      revealsTranscript: command.accepted && !command.error && command.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..637b009d2b78
--- /dev/null
+++ b/src/renderer/src/components/native-chat/native-chat-submission-navigation.test.tsx
@@ -0,0 +1,441 @@
+// @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 {
+  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
+      }),
+    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,
+    scroll.untilReaderActs
+  )
+  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('preserves a newer reader scroll-away while a structured option command is awaiting the host', async () => {
+  const host = deferred<boolean>()
+  const hook = renderHook(() => {
+    const transcript = useReviewTranscript()
+    const t = {
+      ...transport(transcript.revealLatest, () => host.promise),
+      holdRevealLatest: transcript.holdRevealLatest
+    }
+    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 }
+  })
+  hook.result.current.scrollToEnd.mockClear()
+  act(() => hook.result.current.send('/model next'))
+  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('preserves a newer reader scroll-away while a goal-mode submit is awaiting the host', 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),
+        holdRevealLatest: transcript.holdRevealLatest,
+        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' })
+  act(() => hook.result.current.submit.send())
+  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('does not reveal the replacement PTY session when an old option send finishes', 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(ptyId)
+      useNativeChatMessageListHandle(
+        reveal.messageListRef,
+        ptyId === 'pty-a' ? revealA : revealB,
+        (action) => action
+      )
+      return useNativeChatSessionOptionCommand({
+        agent: 'codex',
+        disabled: false,
+        resolveTarget: () => ({ ptyId, settings: null }),
+        onSubmitted: reveal.revealLatest,
+        holdRevealLatest: reveal.holdRevealLatest,
+        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()
+  hook.rerender({ ptyId: 'pty-b' })
+  await act(async () => {
+    host.settle(true)
+    await sending
+  })
+  expect(revealA).not.toHaveBeenCalled()
+  expect(revealB).not.toHaveBeenCalled()
+})
+
+it('preserves a newer reader scroll-away while a verified PTY option send is awaiting acceptance', 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,
+      holdRevealLatest: transcript.holdRevealLatest,
+      setHistory: vi.fn()
+    })
+    return { ...transcript, command }
+  })
+  hook.result.current.scrollToEnd.mockClear()
+  let sending: Promise<unknown> = Promise.resolve()
+  await act(async () => {
+    sending = Promise.resolve(hook.result.current.command.dispatch('/model next'))
+  })
+  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()
+})
+
+it('control: a held structured card reveal expires when the reader scrolls away', async () => {
+  const host = deferred<null>()
+  const hook = renderHook(() => {
+    const transcript = useReviewTranscript()
+    const submits = useStructuredNativeChatSubmitReveal(
+      {
+        respond: async () => host.promise,
+        retry: vi.fn(),
+        queuedMessages: {
+          cards: [],
+          pause: null,
+          resuming: false,
+          resume: async () => {},
+          steer: async () => {},
+          remove: async () => {},
+          edit: async () => {},
+          steerNewest: () => false
+        }
+      },
+      vi.fn()
+    )
+    useNativeChatMessageListHandle(
+      submits.messageListRef,
+      transcript.scroll.scrollToBottom,
+      transcript.scroll.untilReaderActs
+    )
+    return { ...transcript, submits }
+  })
+  hook.result.current.scrollToEnd.mockClear()
+  const held = hook.result.current.submits.messageListRef.current?.holdRevealLatest()
+  expect(held).toBeTypeOf('function')
+  readerScrollAway(hook.result.current)
+  act(() => held?.())
+  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 e08a25953403..5fcb076ead87 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
@@ -325,6 +325,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.ts b/src/renderer/src/components/native-chat/use-native-chat-composer-submit.ts
index fd4eedc40d36..1135aad0d7a9 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,13 +85,14 @@ export function useNativeChatComposerSubmit(args: {
       )
       return
     }
+    const reveal = structuredTransport.holdRevealLatest?.() ?? structuredTransport.onSubmitted
     const submitted = readNativeChatComposerDraft(draftScopeKey)
     void threadGoal.setObjective(objective).then((accepted) => {
       if (!accepted) {
         return
       }
       structuredTransport.onError(null)
-      structuredTransport.onSubmitted?.()
+      reveal?.()
       setHistory((previous) => pushHistory(previous, draft))
       if (!clearNativeChatComposerDraftIfUnchanged(draftScopeKey, submitted)) {
         return
diff --git a/src/renderer/src/components/native-chat/use-native-chat-disclosure-position.test.tsx b/src/renderer/src/components/native-chat/use-native-chat-disclosure-position.test.tsx
new file mode 100644
index 000000000000..c9b18cd387af
--- /dev/null
+++ b/src/renderer/src/components/native-chat/use-native-chat-disclosure-position.test.tsx
@@ -0,0 +1,160 @@
+// @vitest-environment happy-dom
+import { act, cleanup, fireEvent, render } from '@testing-library/react'
+import { useRef, useState } from 'react'
+import { afterEach, beforeEach, expect, it, vi } from 'vitest'
+import { useNativeChatTranscriptScroll } from './use-native-chat-transcript-scroll'
+
+beforeEach(() => vi.useFakeTimers())
+afterEach(() => {
+  cleanup()
+  vi.useRealTimers()
+})
+function harness() {
+  const scrollToEnd = vi.fn()
+  const reconcileReaderScroll = vi.fn()
+  let itemCount = 10
+  let visible = true
+  let rectTop = 100
+  let height = 1000
+  let remove = false
+  let heldReveal: (() => void) | undefined
+  const restoreScrollOffset = vi.fn((offset: number) => {
+    root.scrollTop = offset
+  })
+  function Harness() {
+    const scrollRef = useRef<HTMLDivElement>(null)
+    const contentRef = useRef<HTMLDivElement>(null)
+    const [, renderAgain] = useState(0)
+    const scroll = useNativeChatTranscriptScroll({
+      scrollRef,
+      contentRef,
+      itemCount,
+      isWorking: true,
+      showsTailRow: true,
+      isVisible: visible,
+      scrollToEnd,
+      restoreScrollOffset,
+      reconcileReaderScroll,
+      alignToViewportTop: vi.fn(),
+      consumeProgrammaticScroll: () => false
+    })
+    heldReveal = scroll.untilReaderActs(scroll.scrollToBottom)
+    return (
+      <div
+        ref={scrollRef}
+        data-testid="root"
+        onScroll={scroll.onScroll}
+        onClickCapture={scroll.captureDisclosureTarget}
+      >
+        <div ref={contentRef} />
+        {!remove && (
+          <button
+            onClick={() => {
+              scroll.holdDisclosurePosition()
+              renderAgain((n) => n + 1)
+            }}
+          >
+            toggle
+          </button>
+        )}
+        <button onClick={scroll.readerLeavesEnd}>navigate</button>
+        <output>{String(scroll.showJump)}</output>
+      </div>
+    )
+  }
+  const view = render(<Harness />)
+  const root = view.getByTestId('root')
+  Object.defineProperties(root, {
+    clientHeight: { value: 100 },
+    offsetHeight: { value: 100 },
+    scrollHeight: { get: () => height }
+  })
+  root.getBoundingClientRect = () => new DOMRect(0, 0, 100, 200)
+  root.scrollTop = 900
+  const toggle = view.getByText('toggle')
+  toggle.getBoundingClientRect = () => new DOMRect(0, rectTop - (root.scrollTop - 900) * 2, 100, 20)
+  scrollToEnd.mockClear()
+  return {
+    ...view,
+    root,
+    toggle,
+    scrollToEnd,
+    restoreScrollOffset,
+    reconcileReaderScroll,
+    held: () => heldReveal,
+    grow: () => {
+      height += 100
+      itemCount += 1
+      view.rerender(<Harness />)
+    },
+    setTop: (n: number) => {
+      rectTop = n
+    },
+    setHeight: (n: number) => {
+      height = n
+    },
+    hide: () => {
+      visible = false
+      view.rerender(<Harness />)
+    },
+    remove: () => {
+      remove = true
+      view.rerender(<Harness />)
+    }
+  }
+}
+it('preserves the clicked control through measured drift in a zoomed transcript', () => {
+  const h = harness()
+  fireEvent.click(h.toggle)
+  h.setTop(160)
+  h.setHeight(1600)
+  act(() => vi.advanceTimersByTime(40))
+  expect(h.root.scrollTop).toBe(930)
+  expect(h.restoreScrollOffset).toHaveBeenCalledWith(930)
+  expect(h.scrollToEnd).not.toHaveBeenCalled()
+  expect(h.reconcileReaderScroll).toHaveBeenCalledWith(true)
+  expect(h.getByText('true')).toBeTruthy()
+})
+it('ends a hold when its row disappears and re-derives actual tail proximity', () => {
+  const h = harness()
+  fireEvent.click(h.toggle)
+  h.remove()
+  act(() => vi.advanceTimersByTime(40))
+  expect(h.scrollToEnd).not.toHaveBeenCalled()
+  expect(h.getByText('false')).toBeTruthy()
+  // No forgotten row identity prevents following subsequent content.
+  h.grow()
+  expect(h.scrollToEnd).toHaveBeenCalledOnce()
+})
+it('reader navigation takes over a pending disclosure position hold', () => {
+  const h = harness()
+  fireEvent.click(h.toggle)
+  fireEvent.click(h.getByText('navigate'))
+  h.root.scrollTop = 300
+  h.setTop(200)
+  fireEvent.scroll(h.root)
+  act(() => vi.advanceTimersByTime(300))
+  expect(h.root.scrollTop).toBe(300)
+  expect(h.restoreScrollOffset).not.toHaveBeenCalled()
+  expect(h.scrollToEnd).not.toHaveBeenCalled()
+})
+it.each(['hide', 'unmount'] as const)('expires a held acceptance after %s', (action) => {
+  const h = harness()
+  const reveal = h.held()
+  h[action]()
+  act(() => reveal?.())
+  expect(h.scrollToEnd).not.toHaveBeenCalled()
+})
+
+it('settles by geometry when layout frames are suspended past the deadline', () => {
+  vi.stubGlobal(
+    'requestAnimationFrame',
+    vi.fn(() => 999)
+  )
+  const h = harness()
+  fireEvent.click(h.toggle)
+  h.remove()
+  act(() => vi.advanceTimersByTime(251))
+  h.grow()
+  expect(h.scrollToEnd).toHaveBeenCalledOnce()
+})
diff --git a/src/renderer/src/components/native-chat/use-native-chat-disclosure-position.ts b/src/renderer/src/components/native-chat/use-native-chat-disclosure-position.ts
new file mode 100644
index 000000000000..3206401686d8
--- /dev/null
+++ b/src/renderer/src/components/native-chat/use-native-chat-disclosure-position.ts
@@ -0,0 +1,89 @@
+import { useCallback, useEffect, useLayoutEffect, useRef } from 'react'
+
+type PositionHold = { element: HTMLElement | null; top: number; offset: number }
+
+/** Preserve the clicked control through measurement, without tracking expanded rows. */
+export function useNativeChatDisclosurePosition({
+  scrollRef,
+  restoreScrollOffset,
+  onStart,
+  onSettle
+}: {
+  scrollRef: React.RefObject<HTMLDivElement | null>
+  restoreScrollOffset: (offset: number) => void
+  onStart: () => void
+  onSettle: () => void
+}) {
+  const holdRef = useRef<PositionHold | null>(null)
+  const targetRef = useRef<HTMLElement | null>(null)
+  const frameRef = useRef<number | null>(null)
+  const timeoutRef = useRef<ReturnType<typeof setTimeout> | null>(null)
+  const cancel = useCallback(() => {
+    if (frameRef.current !== null) {
+      cancelAnimationFrame(frameRef.current)
+    }
+    if (timeoutRef.current !== null) {
+      clearTimeout(timeoutRef.current)
+    }
+    frameRef.current = null
+    timeoutRef.current = null
+    holdRef.current = null
+  }, [])
+  const preserve = useCallback(() => {
+    const hold = holdRef.current
+    const scroller = scrollRef.current
+    if (!hold || !scroller || scroller.clientHeight <= 0) {
+      return
+    }
+    const rect = scroller.getBoundingClientRect()
+    const zoom =
+      scroller.offsetHeight > 0 && rect.height > 0 ? rect.height / scroller.offsetHeight : 1
+    const drift = hold.element?.isConnected
+      ? (hold.element.getBoundingClientRect().top - hold.top) / zoom
+      : hold.offset - scroller.scrollTop
+    if (Math.abs(drift) >= 0.5) {
+      restoreScrollOffset(scroller.scrollTop + drift)
+    }
+    hold.offset = scroller.scrollTop
+  }, [restoreScrollOffset, scrollRef])
+  const settle = useCallback(() => {
+    preserve()
+    cancel()
+    onSettle()
+  }, [cancel, onSettle, preserve])
+  const captureTarget = useCallback((event: React.MouseEvent<HTMLDivElement>) => {
+    const element =
+      event.target instanceof Element
+        ? event.target.closest<HTMLElement>('button, [role="button"], summary')
+        : null
+    targetRef.current = element
+    queueMicrotask(() => {
+      if (targetRef.current === element) {
+        targetRef.current = null
+      }
+    })
+  }, [])
+  const holdPosition = useCallback(() => {
+    cancel()
+    const scroller = scrollRef.current
+    if (!scroller || scroller.clientHeight <= 0) {
+      return
+    }
+    onStart()
+    const element = targetRef.current
+    holdRef.current = {
+      element: element && scroller.contains(element) ? element : null,
+      top: element?.getBoundingClientRect().top ?? 0,
+      offset: scroller.scrollTop
+    }
+    // Two layout frames cover the commit and virtualizer measurement; hidden renderers have a deadline.
+    frameRef.current = requestAnimationFrame(() => {
+      preserve()
+      frameRef.current = requestAnimationFrame(settle)
+    })
+    timeoutRef.current = setTimeout(settle, 250)
+  }, [cancel, onStart, preserve, scrollRef, settle])
+  useLayoutEffect(preserve)
+  useEffect(() => cancel, [cancel])
+  return { holdRef, holdPosition, captureTarget, preserve, cancel }
+}
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.ts b/src/renderer/src/components/native-chat/use-native-chat-picker-command-dispatch.ts
index 4adbeb94aa6c..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
@@ -71,6 +71,7 @@ export function useNativeChatPickerCommandDispatch(args: {
           answerCommandLocally,
           sessionOptionsSurface,
           onSlashCommand,
+          onSubmitted,
           setHistory,
           setDraft,
           setCaret,
diff --git a/src/renderer/src/components/native-chat/use-native-chat-reader-opens.test.ts b/src/renderer/src/components/native-chat/use-native-chat-reader-opens.test.ts
index a839525a27a2..ac5bf2b3fbaa 100644
--- a/src/renderer/src/components/native-chat/use-native-chat-reader-opens.test.ts
+++ b/src/renderer/src/components/native-chat/use-native-chat-reader-opens.test.ts
@@ -6,26 +6,24 @@ import { useNativeChatReaderOpens } from './use-native-chat-reader-opens'
 
 function harness() {
   const spies = {
-    readerOpened: vi.fn(),
-    readerClosed: vi.fn(),
+    holdDisclosurePosition: vi.fn(),
     abortNavigation: vi.fn(),
     setSectionOpen: vi.fn(),
     setRosterOpen: vi.fn()
   }
   const { result } = renderHook(() => {
-    const [expandedTurnIds, setExpandedTurnIds] = useState<ReadonlySet<string>>(new Set())
+    const [, setExpandedTurnIds] = useState<ReadonlySet<string>>(new Set())
     return useNativeChatReaderOpens({
       subagentDisclosure: {
         setSectionOpen: spies.setSectionOpen,
         setRosterOpen: spies.setRosterOpen
       },
-      expandedTurnIds,
       setExpandedTurnIds,
-      follow: { readerOpened: spies.readerOpened, readerClosed: spies.readerClosed },
+      follow: { holdDisclosurePosition: spies.holdDisclosurePosition },
       abortNavigation: spies.abortNavigation
     })
   })
-  const reacted = (): number => spies.readerOpened.mock.calls.length
+  const reacted = (): number => spies.holdDisclosurePosition.mock.calls.length
   return { result, spies, reacted }
 }
 
@@ -54,14 +52,14 @@ it.each([
     (opens: ReturnType<typeof useNativeChatReaderOpens>) =>
       opens.subagentDisclosure.setRosterOpen('r', true)
   ]
-])('reacts to the reader opening %s', (_kind, row, open) => {
+])('reacts to the reader opening %s', (_kind, _row, open) => {
   const { result, spies } = harness()
   act(() => open(result.current))
-  expect(spies.readerOpened).toHaveBeenCalledExactlyOnceWith(row)
+  expect(spies.holdDisclosurePosition).toHaveBeenCalledOnce()
   expect(spies.abortNavigation).toHaveBeenCalledOnce()
 })
 
-it('reports each close under the identity its open used, without stopping following again', () => {
+it('bounds both opening and closing layout transactions', () => {
   const { result, spies, reacted } = harness()
   act(() => result.current.toggleExpandedTurn('turn-1'))
   expect(reacted()).toBe(1)
@@ -72,13 +70,8 @@ it('reports each close under the identity its open used, without stopping follow
 
   act(() => result.current.disclosures.onToggle?.('run:1', false))
 
-  expect(reacted()).toBe(1)
-  expect(spies.readerClosed.mock.calls).toEqual([
-    ['turn:turn-1'],
-    ['section:a'],
-    ['roster:r'],
-    ['run:1']
-  ])
+  expect(reacted()).toBe(5)
+  expect(spies.abortNavigation).toHaveBeenCalledTimes(5)
   expect(spies.setSectionOpen).toHaveBeenCalledWith('a', false)
   expect(spies.setRosterOpen).toHaveBeenCalledWith('r', false)
 })
diff --git a/src/renderer/src/components/native-chat/use-native-chat-reader-opens.ts b/src/renderer/src/components/native-chat/use-native-chat-reader-opens.ts
index 11db1f9eecb6..56060e5ece1a 100644
--- a/src/renderer/src/components/native-chat/use-native-chat-reader-opens.ts
+++ b/src/renderer/src/components/native-chat/use-native-chat-reader-opens.ts
@@ -1,8 +1,3 @@
-// Every transcript row a reader can open, routed so that opening one stops the
-// transcript following its end, and abandons a history jump still paging: either
-// would slide what they opened off the screen. Each is reported under its own
-// identity, so closing the last row that stopped the following resumes it.
-
 import { useCallback, useMemo, type Dispatch, type SetStateAction } from 'react'
 import {
   useNativeChatDisclosures,
@@ -14,15 +9,13 @@ import type { NativeChatTranscriptScroll } from './use-native-chat-transcript-sc
 
 export function useNativeChatReaderOpens({
   subagentDisclosure,
-  expandedTurnIds,
   setExpandedTurnIds,
   follow,
   abortNavigation
 }: {
   subagentDisclosure: NativeChatSubagentDisclosure
-  expandedTurnIds: ReadonlySet<string>
   setExpandedTurnIds: Dispatch<SetStateAction<ReadonlySet<string>>>
-  follow: Pick<NativeChatTranscriptScroll, 'readerOpened' | 'readerClosed'>
+  follow: Pick<NativeChatTranscriptScroll, 'holdDisclosurePosition'>
   abortNavigation: () => void
 }): {
   disclosures: NativeChatDisclosureStore
@@ -30,19 +23,11 @@ export function useNativeChatReaderOpens({
   toggleExpandedTurn: (turnKey: string) => void
 } {
   const disclosures = useNativeChatDisclosures()
-  // Taken apart: the scroll result is a new object each render, its callbacks are not.
-  const { readerOpened, readerClosed } = follow
-  const readerToggled = useCallback(
-    (row: string, open: boolean) => {
-      if (!open) {
-        readerClosed(row)
-        return
-      }
-      abortNavigation()
-      readerOpened(row)
-    },
-    [abortNavigation, readerClosed, readerOpened]
-  )
+  const { holdDisclosurePosition } = follow
+  const readerToggled = useCallback(() => {
+    abortNavigation()
+    holdDisclosurePosition()
+  }, [abortNavigation, holdDisclosurePosition])
   const readerDisclosures = useMemo(
     () => ({ ...disclosures, onToggle: readerToggled }),
     [disclosures, readerToggled]
@@ -50,11 +35,11 @@ export function useNativeChatReaderOpens({
   const readerSubagentDisclosure = useMemo<NativeChatSubagentDisclosure>(
     () => ({
       setSectionOpen: (agentId, open) => {
-        readerToggled(`section:${agentId}`, open)
+        readerToggled()
         subagentDisclosure.setSectionOpen(agentId, open)
       },
       setRosterOpen: (rosterRowId, open) => {
-        readerToggled(`roster:${rosterRowId}`, open)
+        readerToggled()
         subagentDisclosure.setRosterOpen(rosterRowId, open)
       }
     }),
@@ -62,10 +47,10 @@ export function useNativeChatReaderOpens({
   )
   const toggleExpandedTurn = useCallback(
     (turnKey: string) => {
-      readerToggled(`turn:${turnKey}`, !expandedTurnIds.has(turnKey))
+      readerToggled()
       setExpandedTurnIds((current) => toggleNativeChatExpandedKey(current, turnKey))
     },
-    [expandedTurnIds, readerToggled, setExpandedTurnIds]
+    [readerToggled, setExpandedTurnIds]
   )
   return {
     disclosures: readerDisclosures,
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
index 68557e00524d..c56f02846625 100644
--- 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
@@ -1,6 +1,6 @@
 // How a chat pane tells its transcript that the reader just sent something.
 
-import { useCallback, useImperativeHandle, useRef } from 'react'
+import { useCallback, useImperativeHandle, useLayoutEffect, useRef } from 'react'
 
 export type NativeChatMessageListHandle = {
   /** Bring the latest into view and follow it, wherever the reader had scrolled. */
@@ -9,17 +9,54 @@ export type NativeChatMessageListHandle = {
   holdRevealLatest: () => () => void
 }
 
-export function useNativeChatRevealLatest(): {
+export function useNativeChatRevealLatest(
+  scopeKey = '',
+  isVisible = true
+): {
   messageListRef: React.RefObject<NativeChatMessageListHandle | null>
   revealLatest: () => void
   holdRevealLatest: () => () => void
 } {
   const messageListRef = useRef<NativeChatMessageListHandle>(null)
-  const revealLatest = useCallback(() => messageListRef.current?.revealLatest(), [])
-  const holdRevealLatest = useCallback(
-    () => messageListRef.current?.holdRevealLatest() ?? (() => {}),
-    []
-  )
+  const generationRef = useRef(0)
+  const previousScopeRef = useRef(scopeKey)
+  const visibleRef = useRef(isVisible)
+  useLayoutEffect(() => {
+    if (previousScopeRef.current !== scopeKey || !isVisible) {
+      generationRef.current += 1
+    }
+    previousScopeRef.current = scopeKey
+    visibleRef.current = isVisible
+    return () => {
+      generationRef.current += 1
+    }
+  }, [isVisible, scopeKey])
+  const revealLatest = useCallback(() => {
+    try {
+      messageListRef.current?.revealLatest()
+    } catch (error) {
+      console.error('Could not reveal the submitted chat content', error)
+    }
+  }, [])
+  const holdRevealLatest = useCallback(() => {
+    const origin = messageListRef.current
+    let reveal: (() => void) | undefined
+    try {
+      reveal = origin?.holdRevealLatest()
+    } catch (error) {
+      console.error('Could not prepare chat navigation', error)
+    }
+    const generation = generationRef.current
+    return () => {
+      if (visibleRef.current && generationRef.current === generation) {
+        try {
+          reveal?.()
+        } catch (error) {
+          console.error('Could not reveal the submitted chat content', error)
+        }
+      }
+    }
+  }, [])
   return { messageListRef, revealLatest, holdRevealLatest }
 }
 
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 d8cb27250dff..37e1007f46ba 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
@@ -19,10 +19,19 @@ export function useNativeChatSessionOptionCommand(args: {
   disabled: boolean
   onSlashCommand?: (command: string) => void
   onSubmitted?: () => void
+  holdRevealLatest?: () => () => void
   resolveTarget: () => NativeChatResolvedTarget | null
   setHistory: Dispatch<SetStateAction<HistoryState>>
 }): { dispatch: NativeChatSessionOptionDispatchCommand; isDispatching: boolean } {
-  const { agent, disabled, onSlashCommand, onSubmitted, resolveTarget, setHistory } = args
+  const {
+    agent,
+    disabled,
+    onSlashCommand,
+    onSubmitted,
+    holdRevealLatest,
+    resolveTarget,
+    setHistory
+  } = args
   const mountedRef = useRef(true)
   const activeObserversRef = useRef(new Set<ClaudeModelSwitchConfirmationObserver>())
   const activeSendsRef = useRef(new Set<AbortController>())
@@ -55,6 +64,7 @@ export function useNativeChatSessionOptionCommand(args: {
       if (!target || disabled) {
         throw new Error('No live terminal is available.')
       }
+      const reveal = holdRevealLatest?.() ?? onSubmitted
       const sendController = new AbortController()
       activeSendsRef.current.add(sendController)
       // Why: block composer chat sends for the whole drain+observe+verify window.
@@ -113,7 +123,7 @@ export function useNativeChatSessionOptionCommand(args: {
           agent,
           runtime: nativeChatComposerTargetIsRemote(target.ptyId) ? 'remote' : 'local'
         })
-        onSubmitted?.()
+        reveal?.()
         setHistory((previous) => pushHistory(previous, command))
         const outcome = observer ? await observer.result : undefined
         return { outcome }
@@ -126,7 +136,7 @@ export function useNativeChatSessionOptionCommand(args: {
         }
       }
     },
-    [agent, disabled, onSlashCommand, onSubmitted, resolveTarget, setHistory]
+    [agent, disabled, onSlashCommand, onSubmitted, holdRevealLatest, resolveTarget, setHistory]
   )
 
   return { dispatch, isDispatching }
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 7eefd98a32fc..0f954c50326e 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
@@ -63,17 +63,17 @@ export function useNativeChatStructuredComposerSend({
         structuredTransport.onError('Remove attachments before using a chat-session command.')
         return
       }
+      const reveal = structuredTransport.holdRevealLatest?.() ?? 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 })
-          // An accepted command can still be one chat sessions don't run; nothing landed then.
-          if (!error) {
-            structuredTransport.onSubmitted?.()
+          if (revealsTranscript) {
+            reveal?.()
           }
           // 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,
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 4d136b0abc77..e5314c1b07e7 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,6 +3,7 @@
 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({
@@ -31,11 +32,21 @@ function TranscriptHarness({
     consumeProgrammaticScroll: () => false,
     reconcileReaderScroll: vi.fn()
   })
+  const input = useNativeChatReaderScrollInput(scrollRef, {
+    onReaderScroll: transcript.readerActs,
+    onLeaveEnd: transcript.readerLeavesEnd
+  })
   return (
-    <div ref={scrollRef} data-testid="scroll" onScroll={transcript.onScroll}>
+    <div
+      {...input.scrollerProps}
+      onClickCapture={transcript.captureDisclosureTarget}
+      ref={scrollRef}
+      data-testid="scroll"
+      onScroll={transcript.onScroll}
+    >
       <div ref={contentRef} />
-      <button onClick={() => transcript.readerOpened('row')}>open</button>
-      <button onClick={() => transcript.readerClosed('row')}>close</button>
+      <button onClick={() => transcript.holdDisclosurePosition()}>open</button>
+      <button onClick={() => transcript.holdDisclosurePosition()}>close</button>
     </div>
   )
 }
@@ -70,6 +81,7 @@ describe('native chat transcript visibility', () => {
       }
     })
 
+    fireEvent.wheel(scrollElement, { deltaY: -100 })
     scrollTop = 320
     fireEvent.scroll(scrollElement)
     view.rerender(
@@ -118,6 +130,7 @@ describe('native chat transcript follow', () => {
       }
     })
 
+    fireEvent.wheel(scrollElement, { deltaY: -50 })
     scrollTop = 850
     fireEvent.scroll(scrollElement)
     scrollToEnd.mockClear()
@@ -133,8 +146,7 @@ describe('native chat transcript follow', () => {
     expect(scrollToEnd).toHaveBeenCalled()
   })
 
-  // A close that resizes nothing reaches no observer, so the close itself has to pin.
-  it('pins to the end the moment the reader closes the row that stopped it following', () => {
+  it('does not force a distant reader to the tail on the last close', () => {
     let scrollTop = 900
     const scrollToEnd = vi.fn()
     const view = render(
@@ -161,6 +173,6 @@ describe('native chat transcript follow', () => {
 
     fireEvent.click(view.getByText('close'))
 
-    expect(scrollToEnd).toHaveBeenCalledOnce()
+    expect(scrollToEnd).not.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 a37dbbe5aee7..024b1bc0112d 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
@@ -1,19 +1,3 @@
-// The transcript's scroll behaviour: staying pinned to the bottom while a turn
-// streams, offering the way back when the reader has left, and aligning a row or
-// a card to the top.
-//
-// Split from the list because windowing changed what these have to be careful
-// about, not what they decide: rows resolving their measured height move the
-// content constantly, so "the content changed" and "the reader scrolled" stopped
-// 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 a reader's own
-// act — an unmarked scroll, a navigation, or opening or closing a row — never from
-// delayed geometry alone. A detach remembers which act caused it: one caused only
-// by opening rows ends when the last of those rows closes, wherever the end is by then.
-
 import {
   useCallback,
   useEffect,
@@ -24,12 +8,13 @@ import {
 } from 'react'
 import {
   distanceFromBottom,
-  FOLLOWING,
-  nextFollowState,
+  isNearBottom,
+  NATIVE_CHAT_FOLLOW_REARM_PX,
+  nextFollowingEnd,
   shouldShowJumpToLatest,
-  type FollowEvent,
   type ScrollGeometry
 } from './native-chat-autoscroll'
+import { useNativeChatDisclosurePosition } from './use-native-chat-disclosure-position'
 
 function geometryOf(element: HTMLElement): ScrollGeometry {
   return {
@@ -47,13 +32,11 @@ export type NativeChatTranscriptScroll = {
   showJump: boolean
   onScroll: UIEventHandler<HTMLDivElement>
   scrollToBottom: () => void
-  /** Align an element inside the transcript with the top of the viewport. */
   scrollMessageToTop: (element: HTMLElement) => void
-  /** The reader opened a row to read it: leave it where it is. */
-  readerOpened: (row: string) => void
-  /** The reader closed a row: follow again if only their opens had stopped it. */
-  readerClosed: (row: string) => void
-  /** Wraps an act so it lapses if the reader acts first. */
+  readerLeavesEnd: () => void
+  readerActs: () => void
+  holdDisclosurePosition: () => void
+  captureDisclosureTarget: React.MouseEventHandler<HTMLDivElement>
   untilReaderActs: (act: () => void) => () => void
 }
 
@@ -74,7 +57,6 @@ export function useNativeChatTranscriptScroll({
   contentRef: React.RefObject<HTMLDivElement | null>
   itemCount: number
   isWorking: boolean
-  /** Whether the list draws a row after the transcript (live activity or a wait). */
   showsTailRow: boolean
   isVisible: boolean
   alignToViewportTop: (element: HTMLElement) => void
@@ -84,107 +66,126 @@ export function useNativeChatTranscriptScroll({
   reconcileReaderScroll: (isTakingOver: boolean) => void
 }): NativeChatTranscriptScroll {
   const [showJump, setShowJump] = useState(false)
-  const followRef = useRef(FOLLOWING)
+  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 readerGenerationRef = useRef(0)
+  const readerScrollUntilRef = useRef(0)
+  const mountedRef = useRef(true)
 
-  /** Applies a reader's act; true when the transcript follows its end afterwards. */
-  const readerActsRef = useRef(0)
-  const follow = useCallback((event: FollowEvent): boolean => {
-    if (event.kind !== 'scroll' || !event.programmatic) {
-      readerActsRef.current += 1
+  const syncScrollState = useCallback((): ScrollGeometry | null => {
+    const element = scrollRef.current
+    if (!isVisibleRef.current || !hasMeasurableViewport(element)) {
+      return null
     }
-    followRef.current = nextFollowState(followRef.current, event)
-    return followRef.current.kind === 'following'
-  }, [])
+    const geometry = geometryOf(element)
+    detachedScrollTopRef.current = followingRef.current ? null : geometry.scrollTop
+    setShowJump(shouldShowJumpToLatest(followingRef.current, geometry))
+    return geometry
+  }, [scrollRef])
+
+  const beginDisclosure = useCallback(() => {
+    readerGenerationRef.current += 1
+    readerScrollUntilRef.current = 0
+    followingRef.current = false
+    reconcileReaderScroll(true)
+    syncScrollState()
+  }, [reconcileReaderScroll, syncScrollState])
+  const settleDisclosure = useCallback(() => {
+    const element = scrollRef.current
+    if (isVisibleRef.current && hasMeasurableViewport(element)) {
+      followingRef.current = isNearBottom(geometryOf(element), NATIVE_CHAT_FOLLOW_REARM_PX)
+      syncScrollState()
+    }
+  }, [scrollRef, syncScrollState])
+  const disclosure = useNativeChatDisclosurePosition({
+    scrollRef,
+    restoreScrollOffset,
+    onStart: beginDisclosure,
+    onSettle: settleDisclosure
+  })
+  const { cancel: cancelDisclosure, holdRef, preserve: preserveDisclosure } = disclosure
+
+  const readerActs = useCallback(() => {
+    readerGenerationRef.current += 1
+    readerScrollUntilRef.current = performance.now() + 250
+    if (holdRef.current) {
+      settleDisclosure()
+    }
+    cancelDisclosure()
+  }, [cancelDisclosure, holdRef, settleDisclosure])
+  const readerLeavesEnd = useCallback(() => {
+    readerActs()
+    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()
+  }, [readerActs, reconcileReaderScroll, scrollRef, syncScrollState])
 
-  const syncScrollState = useCallback(
-    (event?: Event): ScrollGeometry | null => {
+  const onScroll = useCallback<UIEventHandler<HTMLDivElement>>(
+    (event) => {
       const element = scrollRef.current
       if (!isVisibleRef.current || !hasMeasurableViewport(element)) {
-        return null
+        return
       }
       const geometry = geometryOf(element)
-      if (event) {
-        const wasFollowing = followRef.current.kind === 'following'
-        const programmatic = consumeProgrammaticScroll(event)
-        const following = follow({
-          kind: 'scroll',
+      const programmatic = consumeProgrammaticScroll(event.nativeEvent)
+      if (!holdRef.current) {
+        followingRef.current = nextFollowingEnd({
+          following: followingRef.current,
           programmatic,
           geometry,
           previousDistanceFromEnd: previousDistanceFromEndRef.current
         })
-        if (!programmatic) {
-          reconcileReaderScroll(wasFollowing && !following)
+        if (performance.now() <= readerScrollUntilRef.current) {
+          reconcileReaderScroll(false)
         }
       }
-      const following = followRef.current.kind === 'following'
-      detachedScrollTopRef.current = following ? null : geometry.scrollTop
-      setShowJump(shouldShowJumpToLatest(following, geometry))
-      return geometry
-    },
-    [consumeProgrammaticScroll, follow, reconcileReaderScroll, scrollRef]
-  )
-
-  const onScroll = useCallback<UIEventHandler<HTMLDivElement>>(
-    (event) => {
-      const geometry = syncScrollState(event.nativeEvent)
-      if (geometry) {
-        previousDistanceFromEndRef.current = distanceFromBottom(geometry)
-      }
+      previousDistanceFromEndRef.current = distanceFromBottom(geometry)
+      syncScrollState()
     },
-    [syncScrollState]
+    [consumeProgrammaticScroll, holdRef, reconcileReaderScroll, scrollRef, syncScrollState]
   )
 
   const scrollToEndWhenMeasurable = useCallback(() => {
-    if (hasMeasurableViewport(scrollRef.current)) {
+    if (isVisibleRef.current && !holdRef.current && hasMeasurableViewport(scrollRef.current)) {
       scrollToEnd()
     }
-  }, [scrollRef, scrollToEnd])
-
+  }, [holdRef, scrollRef, scrollToEnd])
   const scrollToBottom = useCallback(() => {
-    follow({ kind: 'reveal-latest' })
+    readerGenerationRef.current += 1
+    cancelDisclosure()
+    readerScrollUntilRef.current = 0
+    followingRef.current = true
     scrollToEndWhenMeasurable()
     setShowJump(false)
-  }, [follow, scrollToEndWhenMeasurable])
-
+  }, [cancelDisclosure, scrollToEndWhenMeasurable])
   const scrollMessageToTop = useCallback(
     (element: HTMLElement) => {
-      follow({ kind: 'navigate' })
+      readerActs()
+      readerScrollUntilRef.current = 0
+      followingRef.current = false
       alignToViewportTop(element)
     },
-    [alignToViewportTop, follow]
-  )
-
-  const readerOpened = useCallback(
-    (row: string) => {
-      follow({ kind: 'open', row })
-      syncScrollState()
-    },
-    [follow, syncScrollState]
-  )
-
-  // Read at close time: the pin is rebuilt on a reveal, and every row's toggle hangs off this.
-  const scrollToBottomRef = useRef(scrollToBottom)
-  useEffect(() => {
-    scrollToBottomRef.current = scrollToBottom
-  })
-  const readerClosed = useCallback(
-    (row: string) => {
-      const wasFollowing = followRef.current.kind === 'following'
-      if (follow({ kind: 'close', row }) && !wasFollowing) {
-        scrollToBottomRef.current()
-      }
-    },
-    [follow]
+    [alignToViewportTop, readerActs]
   )
-
   const untilReaderActs = useCallback((act: () => void) => {
-    const acts = readerActsRef.current
+    const generation = readerGenerationRef.current
+    let consumed = false
     return () => {
-      if (readerActsRef.current === acts) {
+      if (
+        !consumed &&
+        mountedRef.current &&
+        isVisibleRef.current &&
+        readerGenerationRef.current === generation
+      ) {
+        consumed = true
         act()
       }
     }
@@ -195,52 +196,75 @@ export function useNativeChatTranscriptScroll({
     isVisibleRef.current = isVisible
     previousIsVisibleRef.current = isVisible
     if (!isVisible) {
+      readerGenerationRef.current += 1
+      cancelDisclosure()
       return
     }
-    if (followRef.current.kind !== 'following') {
+    if (!followingRef.current) {
       if (revealed && detachedScrollTopRef.current !== null) {
         restoreScrollOffset(detachedScrollTopRef.current)
       }
+      syncScrollState()
       return
     }
     scrollToEndWhenMeasurable()
   }, [
+    cancelDisclosure,
     isVisible,
     itemCount,
     isWorking,
     restoreScrollOffset,
     showsTailRow,
-    scrollToEndWhenMeasurable
+    scrollToEndWhenMeasurable,
+    syncScrollState
   ])
 
+  useLayoutEffect(() => {
+    mountedRef.current = true
+    return () => {
+      mountedRef.current = false
+      readerGenerationRef.current += 1
+    }
+  }, [])
   useEffect(() => {
     const element = scrollRef.current
     if (!element || typeof ResizeObserver === 'undefined') {
       return
     }
     const observer = new ResizeObserver(() => {
-      if (followRef.current.kind === 'following') {
+      if (!isVisibleRef.current) {
+        return
+      }
+      if (holdRef.current) {
+        preserveDisclosure()
+      } else 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.
     observer.observe(element)
     if (contentRef.current) {
       observer.observe(contentRef.current)
     }
     return () => observer.disconnect()
-  }, [contentRef, scrollRef, scrollToEndWhenMeasurable, syncScrollState])
+  }, [
+    contentRef,
+    holdRef,
+    preserveDisclosure,
+    scrollRef,
+    scrollToEndWhenMeasurable,
+    syncScrollState
+  ])
 
   return {
     showJump,
     onScroll,
     scrollToBottom,
     scrollMessageToTop,
-    readerOpened,
-    readerClosed,
+    readerLeavesEnd,
+    readerActs,
+    holdDisclosurePosition: disclosure.holdPosition,
+    captureDisclosureTarget: disclosure.captureTarget,
     untilReaderActs
   }
 }
diff --git a/src/renderer/src/components/native-chat/use-structured-agent-session.queued-gating.test.tsx b/src/renderer/src/components/native-chat/use-structured-agent-session.queued-gating.test.tsx
index bef56bf7f81e..5559068af7a3 100644
--- a/src/renderer/src/components/native-chat/use-structured-agent-session.queued-gating.test.tsx
+++ b/src/renderer/src/components/native-chat/use-structured-agent-session.queued-gating.test.tsx
@@ -55,7 +55,9 @@ vi.mock('./use-structured-agent-session-outbox', () => ({
     return {
       outbox: outboxEntries,
       error: null,
-      send: vi.fn(),
+      send: (text: string, attachments: readonly { path: string; previewUri: string }[] = []) =>
+        Boolean(text.trim() || attachments.length) &&
+        appendStructuredAgentSessionOutboxMessage('session-1', text, attachments) !== null,
       retry: vi.fn(),
       withdrawUnsent: vi.fn()
     }
@@ -73,6 +75,7 @@ import {
   clearNativeChatDraftCacheForTests,
   readNativeChatDraftCache
 } from './native-chat-draft-cache'
+import { appendStructuredAgentSessionOutboxMessage } from './structured-agent-session-outbox-storage'
 import { useStructuredAgentSession } from './use-structured-agent-session'
 
 const RUNNING_TURN: AgentJournalRenderItem = {
@@ -383,3 +386,31 @@ describe('against a host without the capability', () => {
     ).toHaveLength(0)
   })
 })
+
+it.each([
+  ['queued text', true, true, true, [], 'queued'],
+  ['setting off', true, false, true, [], true],
+  ['idle turn', true, true, false, [], true],
+  ['older host', false, true, true, [], true],
+  ['image send', true, true, true, [{ path: '/tmp/image.png', previewUri: '/tmp/image.png' }], true]
+] as const)(
+  'composer admission derives navigation from its visible projection: %s',
+  (_name, capable, enabled, working, attachments, expected) => {
+    setLocalRuntimeCapabilitiesForTests(
+      capable ? [AGENT_SESSION_QUEUED_MESSAGES_RUNTIME_CAPABILITY] : []
+    )
+    items = working ? [RUNNING_TURN] : []
+    const hook = render(enabled)
+    let admission: unknown
+    act(() => {
+      admission = hook.result.current.sendFromComposer('follow up', attachments)
+    })
+    expect(admission).toBe(expected)
+  }
+)
+
+it('does not report a visible composer send when admission is refused', () => {
+  setLocalRuntimeCapabilitiesForTests([AGENT_SESSION_QUEUED_MESSAGES_RUNTIME_CAPABILITY])
+  const hook = render()
+  expect(hook.result.current.sendFromComposer('')).toBe(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 6d73bc3ce050..272076fe584a 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
@@ -35,6 +35,7 @@ import { useStructuredAgentSessionThreadGoal } from './use-structured-agent-sess
 import { useStructuredAgentSessionContextUsage } from './use-structured-agent-session-context-usage'
 import { useStructuredAgentSessionRailOutline } from './use-structured-agent-session-rail-outline'
 import { useStructuredAgentSessionQueuedMessages } from './use-structured-agent-session-queued-messages'
+import { getStructuredAgentSessionOutbox } from './structured-agent-session-outbox-storage'
 import { outboxOutsideQueuedCards } from './structured-agent-session-queued-cards'
 import { structuredAgentSessionStartFailureFacts } from './structured-agent-session-delivery-notices'
 import { hostStatesTurnScopes } from '../../../../shared/native-chat-turn-membership'
@@ -193,6 +194,9 @@ export function useStructuredAgentSession(args: {
     composerScopeKey,
     mutate
   })
+  const send = (...input: Parameters<typeof outboxController.send>): boolean =>
+    (!commandPending.current || hostStatesTurnScopes(transportState.journalItems)) &&
+    outboxController.send(...input)
   return {
     conversationCommands,
     runConversationCommand: (command: AgentSessionConversationCommand) =>
@@ -234,11 +238,21 @@ export function useStructuredAgentSession(args: {
     submissions: transportState.submissions,
     /** The host's queued cards, which hold their own rejected hand-offs. */
     queuedMessageIds,
-    // A message typed during a command queues behind it on the host.
-    send: (...input: Parameters<typeof outboxController.send>) =>
-      // Legacy: an older host refuses sends while a command runs; removable once those hosts age out.
-      (!commandPending.current || hostStatesTurnScopes(transportState.journalItems)) &&
-      outboxController.send(...input),
+    send,
+    /** Navigation follows the same projection that decides between a bubble and a queued card. */
+    sendFromComposer: (...input: Parameters<typeof outboxController.send>): boolean | 'queued' => {
+      if (!send(...input)) {
+        return false
+      }
+      const current = getStructuredAgentSessionOutbox(sessionId)
+      const admitted = current.at(-1)
+      return admitted &&
+        !outboxOutsideQueuedCards(current, queuedMessageIds, isWorking, queueDelivery).includes(
+          admitted
+        )
+        ? 'queued'
+        : true
+    },
     retry: outboxController.retry,
     isWorking: transportState.isWorking,
     workingStartedAt: transportState.turnTiming.workingStartedAt,
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
index 8196d195210b..30a3e1f39a88 100644
--- 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
@@ -23,6 +23,7 @@ export function useStructuredNativeChatSubmitReveal(
   messageListRef: React.RefObject<NativeChatMessageListHandle | null>
   /** For the composer's transport, which knows when a send was accepted. */
   revealLatest: () => void
+  holdRevealLatest: () => () => void
   retryDelivery: (clientMessageId: string) => void
   retryLaunch: () => void
   respond: StructuredController['respond']
@@ -83,6 +84,7 @@ export function useStructuredNativeChatSubmitReveal(
   return {
     messageListRef,
     revealLatest,
+    holdRevealLatest,
     retryDelivery,
     retryLaunch: revealingRetryLaunch,
     respond: revealingRespond,
diff --git a/src/shared/structured-agent-session-composer.ts b/src/shared/structured-agent-session-composer.ts
index 9b60920ac6bf..fa4d47248254 100644
--- a/src/shared/structured-agent-session-composer.ts
+++ b/src/shared/structured-agent-session-composer.ts
@@ -43,6 +43,8 @@ export type StructuredAgentSessionComposerOptions = {
 }
 
 export type StructuredAgentSessionCommandOutcome = {
+  /** Picker actions produce no transcript content. This is local dispatch policy, never wire state. */
+  revealsTranscript?: boolean
   handled: boolean
   accepted: boolean
   error: string | null
@@ -182,6 +184,7 @@ export async function dispatchStructuredAgentSessionComposerCommand(
     return {
       handled: true,
       accepted: opened,
+      revealsTranscript: false,
       error: opened ? null : `Could not open the ${command.name} picker.`
     }
   }

From 04a12863324ea5eb105d698e7c304e58648c4b8b Mon Sep 17 00:00:00 2001
From: Brennan Benson <79079362+brennanb2025@users.noreply.github.com>
Date: Tue, 6 Oct 2026 00:51:45 -0700
Subject: [PATCH 08/14] fix(native-chat): retain reader takeover until its
 frame ends

Pending reader takeover could keep an earlier end target once a duplicate 250 ms gate expired. Let the existing pending-frame check keep the reader's actual offset until that frame ends.

Move unchanged interactive reveal and approval projection into their existing modules so both view files meet the line limit.

Co-authored-by: Kelvin Amoaba <97001695+AmoabaKelvin@users.noreply.github.com>
---
 .../native-chat/NativeChatResolvedView.tsx    | 40 ++-------
 .../NativeChatStructuredSession.tsx           | 18 +---
 .../native-chat-interactive-prompt.ts         | 22 +++++
 .../use-native-chat-reveal-latest.ts          | 32 ++++++-
 ...use-native-chat-transcript-scroll.test.tsx | 83 ++++++++++++++++++-
 .../use-native-chat-transcript-scroll.ts      |  9 +-
 6 files changed, 144 insertions(+), 60 deletions(-)

diff --git a/src/renderer/src/components/native-chat/NativeChatResolvedView.tsx b/src/renderer/src/components/native-chat/NativeChatResolvedView.tsx
index 474f242ad87e..01f062abd929 100644
--- a/src/renderer/src/components/native-chat/NativeChatResolvedView.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatResolvedView.tsx
@@ -11,19 +11,18 @@ 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 { useNativeChatRevealLatest } from './use-native-chat-reveal-latest'
+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'
 import { useNativeChatCanSend } from './use-native-chat-can-send'
 import { NativeChatInteractiveCard } from './NativeChatInteractiveCard'
 import { useNativeChatInteractivePromptCard } from './use-native-chat-interactive-prompt-card'
-import { hasAskAnswer } from './native-chat-interactive-prompt'
 import { NativeChatEmptyState } from './NativeChatEmptyState'
-import {
-  useNativeChatInteractiveSend,
-  type NativeChatInteractiveSend
-} from './use-native-chat-interactive-send'
+import { useNativeChatInteractiveSend } from './use-native-chat-interactive-send'
 import { shouldClearNativeChatWorkingSuppression } from './native-chat-working-suppression'
 import { resolveNativeChatTerminalTurn } from './native-chat-terminal-turn'
 import { useNativeChatTerminalTurnTiming } from './use-native-chat-terminal-turn-timing'
@@ -121,37 +120,12 @@ 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 { sendAnswer, sendRaw, cancelPending, cancelAsk, cancel } = 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 revealScope = `${agent}:${sessionId}:${targetPtyId}`
   const reveals = useNativeChatRevealLatest(revealScope, isVisible)
   const { messageListRef, revealLatest, holdRevealLatest } = reveals
-  const interactiveSend = 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: (raw) => {
-        if (targetPtyId) {
-          revealLatest()
-        }
-        sendRaw(raw)
-      },
-      cancelPending,
-      cancelAsk,
-      cancel
-    }),
-    [cancel, cancelAsk, cancelPending, revealLatest, sendAnswer, sendRaw, targetPtyId]
-  )
+  const interactiveSend = useNativeChatInteractiveSendReveal(send, targetPtyId, revealLatest)
   const [workingInterrupted, setWorkingInterrupted] = useState(false)
   const previousWorkingEpochRef = useRef<number | null>(null)
   // True while a question card owns the input region, so the composer is hidden.
diff --git a/src/renderer/src/components/native-chat/NativeChatStructuredSession.tsx b/src/renderer/src/components/native-chat/NativeChatStructuredSession.tsx
index 9d6481e49151..b14bc668832d 100644
--- a/src/renderer/src/components/native-chat/NativeChatStructuredSession.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatStructuredSession.tsx
@@ -38,6 +38,7 @@ import { NativeChatThreadGoalBanner } from './NativeChatThreadGoalBanner'
 import { structuredAgentSessionReadFailureNotice } from './structured-agent-session-read-failure-notice'
 import { useStructuredAgentSessionDeliveryNotices } from './use-structured-agent-session-delivery-notices'
 import { pendingPromptsAllUnanswerableHere } from '../../../../shared/agent-session-approval-subject'
+import { nativeChatStructuredApproval } from './native-chat-interactive-prompt'
 
 export function NativeChatStructuredSession(
   props: Omit<NativeChatStructuredViewProps, 'mode'>
@@ -160,22 +161,7 @@ export function NativeChatStructuredSession(
   const promptsUnanswerable = pendingPromptsAllUnanswerableHere(controller.prompts)
   const composerShown = (prompt === null || promptsUnanswerable) && !readFailedFinally
   const approvalBody = prompt?.body.kind === 'approval' ? prompt.body : null
-  const approval = approvalBody
-    ? {
-        title: approvalBody.title,
-        ...(approvalBody.displayName ? { displayName: approvalBody.displayName } : {}),
-        ...(approvalBody.description ? { description: approvalBody.description } : {}),
-        ...(approvalBody.decisionReason ? { decisionReason: approvalBody.decisionReason } : {}),
-        ...(approvalBody.blockedPath ? { blockedPath: approvalBody.blockedPath } : {}),
-        ...(approvalBody.matchedAskRule ? { matchedAskRule: approvalBody.matchedAskRule } : {}),
-        ...(approvalBody.subject ? { subject: approvalBody.subject } : {}),
-        ...(approvalBody.detail ? { detail: approvalBody.detail } : {}),
-        options: approvalBody.options.map((option) => ({
-          label: option.label,
-          send: option.id
-        }))
-      }
-    : null
+  const approval = nativeChatStructuredApproval(approvalBody)
   const cancelPrompt = () => {
     if (controller.turnId && prompt) {
       void controller.cancel(controller.turnId, {
diff --git a/src/renderer/src/components/native-chat/native-chat-interactive-prompt.ts b/src/renderer/src/components/native-chat/native-chat-interactive-prompt.ts
index 6454dd8257b8..5a626d4f6ceb 100644
--- a/src/renderer/src/components/native-chat/native-chat-interactive-prompt.ts
+++ b/src/renderer/src/components/native-chat/native-chat-interactive-prompt.ts
@@ -1,6 +1,7 @@
 import { nativeChatApprovalAcceptKey } from '../../../../shared/native-chat-agent-support'
 import { translate } from '@/i18n/i18n'
 import type {
+  AgentJournalApprovalItem,
   AgentJournalApprovalMatchedAskRule,
   AgentJournalApprovalSubject
 } from '../../../../shared/agent-session-journal-types'
@@ -51,6 +52,27 @@ export type InteractivePromptCard =
   | { kind: 'approval'; approval: ChatApproval }
   | null
 
+export function nativeChatStructuredApproval(
+  approvalBody: AgentJournalApprovalItem | null
+): ChatApproval | null {
+  return approvalBody
+    ? {
+        title: approvalBody.title,
+        ...(approvalBody.displayName ? { displayName: approvalBody.displayName } : {}),
+        ...(approvalBody.description ? { description: approvalBody.description } : {}),
+        ...(approvalBody.decisionReason ? { decisionReason: approvalBody.decisionReason } : {}),
+        ...(approvalBody.blockedPath ? { blockedPath: approvalBody.blockedPath } : {}),
+        ...(approvalBody.matchedAskRule ? { matchedAskRule: approvalBody.matchedAskRule } : {}),
+        ...(approvalBody.subject ? { subject: approvalBody.subject } : {}),
+        ...(approvalBody.detail ? { detail: approvalBody.detail } : {}),
+        options: approvalBody.options.map((option) => ({
+          label: option.label,
+          send: option.id
+        }))
+      }
+    : null
+}
+
 const ESCAPE = String.fromCharCode(27)
 
 /** Parse the desktop-only approval envelope; question parsing stays cross-platform. */
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
index c56f02846625..786d9c0e1f4a 100644
--- 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
@@ -1,6 +1,36 @@
 // How a chat pane tells its transcript that the reader just sent something.
 
-import { useCallback, useImperativeHandle, useLayoutEffect, useRef } from 'react'
+import { useCallback, useImperativeHandle, useLayoutEffect, useMemo, useRef } from 'react'
+import { hasAskAnswer } from './native-chat-interactive-prompt'
+import type { NativeChatInteractiveSend } from './use-native-chat-interactive-send'
+
+export function useNativeChatInteractiveSendReveal(
+  { sendAnswer, sendRaw, 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: (raw) => {
+        if (targetPtyId) {
+          revealLatest()
+        }
+        sendRaw(raw)
+      },
+      cancelPending,
+      cancelAsk,
+      cancel
+    }),
+    [cancel, cancelAsk, cancelPending, revealLatest, sendAnswer, sendRaw, targetPtyId]
+  )
+}
 
 export type NativeChatMessageListHandle = {
   /** Bring the latest into view and follow it, wherever the reader had scrolled. */
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 e5314c1b07e7..b2d464f29095 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
@@ -10,11 +10,13 @@ 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)
@@ -30,7 +32,7 @@ function TranscriptHarness({
     scrollToEnd,
     restoreScrollOffset,
     consumeProgrammaticScroll: () => false,
-    reconcileReaderScroll: vi.fn()
+    reconcileReaderScroll
   })
   const input = useNativeChatReaderScrollInput(scrollRef, {
     onReaderScroll: transcript.readerActs,
@@ -51,7 +53,84 @@ function TranscriptHarness({
   )
 }
 
-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', () => {
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 4a2d0f40764e..afdbcfdb1a20 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
@@ -72,7 +72,6 @@ export function useNativeChatTranscriptScroll({
   const previousIsVisibleRef = useRef(isVisible)
   const previousDistanceFromEndRef = useRef(Number.POSITIVE_INFINITY)
   const readerGenerationRef = useRef(0)
-  const readerScrollUntilRef = useRef(0)
   const mountedRef = useRef(true)
 
   const syncScrollState = useCallback((): ScrollGeometry | null => {
@@ -88,7 +87,6 @@ export function useNativeChatTranscriptScroll({
 
   const beginDisclosure = useCallback(() => {
     readerGenerationRef.current += 1
-    readerScrollUntilRef.current = 0
     followingRef.current = false
     reconcileReaderScroll(true)
     syncScrollState()
@@ -110,7 +108,6 @@ export function useNativeChatTranscriptScroll({
 
   const readerActs = useCallback(() => {
     readerGenerationRef.current += 1
-    readerScrollUntilRef.current = performance.now() + 250
     if (holdRef.current) {
       settleDisclosure()
     }
@@ -143,9 +140,7 @@ export function useNativeChatTranscriptScroll({
           geometry,
           previousDistanceFromEnd: previousDistanceFromEndRef.current
         })
-        if (performance.now() <= readerScrollUntilRef.current) {
-          reconcileReaderScroll(false)
-        }
+        reconcileReaderScroll(false)
       }
       previousDistanceFromEndRef.current = distanceFromBottom(geometry)
       syncScrollState()
@@ -161,7 +156,6 @@ export function useNativeChatTranscriptScroll({
   const scrollToBottom = useCallback(() => {
     readerGenerationRef.current += 1
     cancelDisclosure()
-    readerScrollUntilRef.current = 0
     followingRef.current = true
     scrollToEndWhenMeasurable()
     setShowJump(false)
@@ -169,7 +163,6 @@ export function useNativeChatTranscriptScroll({
   const scrollMessageToTop = useCallback(
     (element: HTMLElement) => {
       readerActs()
-      readerScrollUntilRef.current = 0
       followingRef.current = false
       alignToViewportTop(element)
     },

From 37a53728fa7ce1bffbef994a312138fec2f3ec85 Mon Sep 17 00:00:00 2001
From: Brennan Benson <79079362+brennanb2025@users.noreply.github.com>
Date: Tue, 6 Oct 2026 12:50:43 -0700
Subject: [PATCH 09/14] fix(native-chat): only a scroll gesture stops
 following; sends reveal at the press

Opening or closing a row used to stop the transcript from following the
newest output. A reader at the live end who expanded a tool run then lost
the stream. Sends that wait on the host (answers, commands, goals, option
changes) only brought the latest into view after the host replied, so the
reader watched nothing happen at the press.

Now following stops only on a reader gesture: an upward wheel or scroll key
when there is content above, a scrollbar press, a touch drag once it has
carried the view off the end, or a press on content while already away from
the end. Opening, closing, layout changes and the app's own scrolls never
stop it, and returning to the end resumes it. Every local send reveals the
latest at the press. A message that waits as a queued card, a message from
another device, and Stop leave a reader who scrolled up where they are.
Queue Resume still reveals only after the host lifts the pause, and only in
the pane that pressed it while that pane is shown.

Removes the disclosure position hold, the reader-opens wiring, the held
reveal and its reader generation tracking. The queued-card decision moves
into the outbox send so the session hook stays under the line limit. Also
restores the transcript label import and the approval card's verified send
that the merge with main dropped.
---
 .../native-chat/NativeChatComposer.tsx        |   2 -
 .../native-chat/NativeChatDiffCard.tsx        |   2 +-
 ...ChatMessageList.rail-history-jump.test.tsx |  23 +-
 ...ChatMessageList.reader-navigation.test.tsx | 238 ++++--------------
 .../native-chat/NativeChatMessageList.tsx     |  85 ++++---
 ...iveChatResolvedView.reveal-latest.test.tsx |  27 +-
 .../native-chat/NativeChatResolvedView.tsx    |  10 +-
 ...tiveChatStructuredSession.test-harness.tsx |   6 +-
 .../NativeChatStructuredSession.test.tsx      |  15 +-
 .../NativeChatStructuredSession.tsx           |   6 +-
 ...tiveChatStructuredSessionDelivery.test.tsx |   1 -
 .../NativeChatSubagentRun.test.tsx            |  26 +-
 .../native-chat/NativeChatSubagentRun.tsx     |  10 +-
 .../native-chat/native-chat-autoscroll.ts     |   9 +-
 .../native-chat/native-chat-composer-types.ts |   8 +-
 .../native-chat-disclosure-store.ts           |  16 +-
 .../native-chat-reader-scroll-input.test.tsx  |  16 +-
 .../native-chat-reader-scroll-input.ts        |  14 +-
 ...ative-chat-structured-composer-dispatch.ts |   7 +-
 ...native-chat-submission-navigation.test.tsx |  85 ++++---
 .../use-native-chat-composer-submit.test.tsx  |   3 +-
 .../use-native-chat-composer-submit.ts        |   3 +-
 ...e-native-chat-disclosure-position.test.tsx | 160 ------------
 .../use-native-chat-disclosure-position.ts    |  89 -------
 .../use-native-chat-reader-opens.test.ts      |  77 ------
 .../use-native-chat-reader-opens.ts           |  60 -----
 .../use-native-chat-reveal-latest.ts          |  81 +++---
 .../use-native-chat-session-option-command.ts |  16 +-
 ...ive-chat-structured-composer-send.test.tsx |   9 +-
 ...se-native-chat-structured-composer-send.ts |  10 +-
 ...use-native-chat-transcript-scroll.test.tsx |  39 ++-
 .../use-native-chat-transcript-scroll.ts      | 155 ++++--------
 ...d-agent-session-command-send-gate.test.tsx |   2 +-
 ...ent-session-outbox.queue-delivery.test.tsx |  29 +++
 .../use-structured-agent-session-outbox.ts    |  23 +-
 ...nt-session-queued-messages.resume.test.tsx |  30 +--
 ...tured-agent-session.queued-gating.test.tsx |  33 +--
 .../use-structured-agent-session.ts           |  33 +--
 ...ructured-native-chat-submit-reveal.test.ts |   6 +-
 ...se-structured-native-chat-submit-reveal.ts |  30 +--
 .../structured-agent-session-composer.ts      |  13 +-
 41 files changed, 401 insertions(+), 1106 deletions(-)
 delete mode 100644 src/renderer/src/components/native-chat/use-native-chat-disclosure-position.test.tsx
 delete mode 100644 src/renderer/src/components/native-chat/use-native-chat-disclosure-position.ts
 delete mode 100644 src/renderer/src/components/native-chat/use-native-chat-reader-opens.test.ts
 delete mode 100644 src/renderer/src/components/native-chat/use-native-chat-reader-opens.ts

diff --git a/src/renderer/src/components/native-chat/NativeChatComposer.tsx b/src/renderer/src/components/native-chat/NativeChatComposer.tsx
index 3debb69a8f5d..887a9cd7aaf4 100644
--- a/src/renderer/src/components/native-chat/NativeChatComposer.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatComposer.tsx
@@ -65,7 +65,6 @@ const NativeChatComposerPane = forwardRef<NativeChatComposerHandle, NativeChatCo
       onOptimisticSendCanceled,
       onSlashCommand,
       onSubmitted,
-      holdRevealLatest,
       answerCommandLocally,
       onSwitchToTerminal,
       readTerminalScreen,
@@ -226,7 +225,6 @@ const NativeChatComposerPane = forwardRef<NativeChatComposerHandle, NativeChatCo
         disabled,
         onSlashCommand,
         onSubmitted,
-        holdRevealLatest,
         resolveTarget,
         setHistory
       })
diff --git a/src/renderer/src/components/native-chat/NativeChatDiffCard.tsx b/src/renderer/src/components/native-chat/NativeChatDiffCard.tsx
index 5919a56be1a5..1d9f7321b82d 100644
--- a/src/renderer/src/components/native-chat/NativeChatDiffCard.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatDiffCard.tsx
@@ -131,7 +131,7 @@ export function NativeChatDiffCard({
   const cardRef = useRef<HTMLDivElement>(null)
   useLayoutEffect(() => {
     if (revealSignal && cardRef.current) {
-      setExpanded(true, false)
+      setExpanded(true)
       // Reported from the card, not the row: a turn that touched four files must
       // land on the one that was asked for, and only the card knows where it is.
       onReveal?.(cardRef.current)
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 3bb75925cd8a..492269cc82ea 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
@@ -3,7 +3,7 @@
 import '@testing-library/jest-dom/vitest'
 
 import { act, cleanup, fireEvent, render, screen } from '@testing-library/react'
-import { createRef, useCallback, useMemo, useState } from 'react'
+import { useCallback, useMemo, useState } from 'react'
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 import type {
   AgentJournalItemBody,
@@ -11,7 +11,6 @@ import type {
 } from '../../../../shared/agent-session-journal-types'
 import type { NativeChatMessage } from '../../../../shared/native-chat-types'
 import { projectStructuredItemsToNativeChat } from '../../../../shared/structured-agent-session-projection'
-import type { NativeChatMessageListHandle } from './use-native-chat-reveal-latest'
 import { NativeChatMessageList } from './NativeChatMessageList'
 import type { NativeChatRailOutlineEntry } from './native-chat-message-rail-items'
 import type { NativeChatOlderPageResult } from './native-chat-pagination'
@@ -71,12 +70,10 @@ 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,
-  handle
+  holdPage
 }: {
   /** Awaited before a page lands, to keep it in flight. */
   holdPage?: () => Promise<void>
-  handle?: React.RefObject<NativeChatMessageListHandle | null>
 }): React.JSX.Element {
   const [loaded, setLoaded] = useState(PAGE)
   const loadEarlier = useCallback(async (): Promise<NativeChatOlderPageResult> => {
@@ -98,7 +95,6 @@ function PagedTranscript({
   )
   return (
     <NativeChatMessageList
-      ref={handle}
       session={{ ...session(messages), hasMore: loaded < TOTAL, loadEarlier }}
       railOutline={railOutline}
       isWorking={false}
@@ -351,21 +347,6 @@ describe('jumping from the rail while following the end', () => {
     await frame()
   }
 
-  it('a delayed accepted answer cannot cancel a newer unloaded rail selection', async () => {
-    const pages = holdFirstPage()
-    const handle = createRef<NativeChatMessageListHandle>()
-    render(<PagedTranscript holdPage={pages.holdPage} handle={handle} />)
-    await settle(10)
-    const acceptance = handle.current?.holdRevealLatest()
-    await pickUnloadedWhilePaging('prompt-5')
-    expect(pages.asked()).toBe(1)
-    act(() => acceptance?.())
-    expect(screen.getByRole('button', { name: 'prompt-5' }).getAttribute('aria-busy')).toBe('true')
-    pages.release()
-    await settle(60)
-    expect(Math.abs(rowOffsetFromViewportTop('prompt-5'))).toBeLessThanOrEqual(2)
-  })
-
   it('keeps the list open with the pick marked busy until its history lands', async () => {
     const pages = holdFirstPage()
     render(<PagedTranscript holdPage={pages.holdPage} />)
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
index 15a292b4c826..91ef38b065a9 100644
--- a/src/renderer/src/components/native-chat/NativeChatMessageList.reader-navigation.test.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatMessageList.reader-navigation.test.tsx
@@ -163,120 +163,59 @@ describe('reader navigation', () => {
     expect(screen.queryByRole('button', { name: 'Jump to latest' })).toBeNull()
   })
 
-  it('drops a reveal held for a slow send once the reader scrolls away again', () => {
-    const handle = createRef<NativeChatMessageListHandle>()
-    const { container } = render(
-      <NativeChatMessageList
-        ref={handle}
-        session={session(transcript)}
-        isWorking
-        expandSignal={false}
-      />
-    )
-    paint(container)
-    scrollTranscript(container, 1000)
-    paint(container)
-    const lapsed = handle.current?.holdRevealLatest()
-    scrollTranscript(container, 600)
+  it('stops following when the reader pages up from the focused transcript', () => {
+    const { container, rerender } = render(liveList(transcript))
     paint(container)
-    const scrollTop = scrollRoot(container).scrollTop
-    act(() => lapsed?.())
+    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(scrollRoot(container).scrollTop).toBe(scrollTop)
 
-    // Anti-vacuous: one the reader leaves alone still lands on the end.
-    const kept = handle.current?.holdRevealLatest()
-    act(() => kept?.())
-    paint(container)
-    expect(distanceFromBottom(container)).toBe(0)
+    expect(scroller.scrollTop).toBe(pagedTo)
+    expect(offersJumpToLatest()).toBe(true)
   })
 
-  it('leaves a tool run the reader opens where it is while the turn streams on', () => {
-    const toolIndex = TRANSCRIPT_LENGTH
-    const withTool: NativeChatMessage[] = [
-      ...transcript,
-      {
-        id: `message-${toolIndex}`,
-        role: 'assistant',
-        blocks: [
-          { type: 'tool-call', name: 'shell', input: { command: 'pwd' }, state: 'completed' },
-          { type: 'tool-result', output: '/repo' }
-        ],
-        timestamp: toolIndex + 1,
-        source: 'transcript'
-      }
-    ]
-    const view = (messages: NativeChatMessage[]) => (
-      <NativeChatMessageList session={session(messages)} isWorking expandSignal={false} />
-    )
-    const { container, rerender } = render(view(withTool))
+  it('leaves a reader who scrolled up in place when a message arrives from another device', () => {
+    const { container, rerender } = render(liveList(transcript))
     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
+    scrollTranscript(container, 1000)
+    paint(container)
+    const readingAt = scrollRoot(container).scrollTop
 
-    const toggle = screen.getAllByRole('button', { expanded: false }).at(-1)
-    const toolRow = toggle?.closest<HTMLElement>('[data-index]')
-    if (!toggle || !toolRow) {
-      throw new Error('the tool run has no mounted toggle')
-    }
-    fireEvent.click(toggle)
-    expect(toggle).toHaveAttribute('aria-expanded', 'true')
-    // The run opens taller, and the turn keeps streaming below it.
-    const heights = Array.from({ length: Number(toolRow.dataset.index) + 1 }, () => ROW_PX)
-    heights[Number(toolRow.dataset.index)] = ROW_PX * 6
-    layout.measuredRowHeights = heights
+    const delivered = [...transcript, userMessage(TRANSCRIPT_LENGTH, 'sent from the phone')]
+    rerender(liveList(delivered))
     paint(container)
-    rerender(view([...withTool, marker(toolIndex + 1), marker(toolIndex + 2)]))
+    rerender(liveList([...delivered, marker(TRANSCRIPT_LENGTH + 1)]))
     paint(container)
 
-    expect(scrollRoot(container).scrollTop).toBe(scrollTopBeforeOpen)
-    expect(distanceFromBottom(container)).toBeGreaterThan(0)
+    expect(scrollRoot(container).scrollTop).toBe(readingAt)
+    expect(offersJumpToLatest()).toBe(true)
   })
 
-  it('follows the end again once the reader closes what they opened there', () => {
+  it('keeps following when the reader opens a tool run at the live end', () => {
     const toolIndex = TRANSCRIPT_LENGTH
-    const withTool: NativeChatMessage[] = [
-      ...transcript,
-      {
-        id: `message-${toolIndex}`,
-        role: 'assistant',
-        blocks: [
-          { type: 'tool-call', name: 'shell', input: { command: 'pwd' }, state: 'completed' },
-          { type: 'tool-result', output: '/repo' }
-        ],
-        timestamp: toolIndex + 1,
-        source: 'transcript'
-      }
-    ]
-    const view = (messages: NativeChatMessage[]) => (
-      <NativeChatMessageList session={session(messages)} isWorking expandSignal={false} />
-    )
-    const { container, rerender } = render(view(withTool))
-    paint(container)
-    const toggle = screen.getAllByRole('button', { expanded: false }).at(-1)
-    const toolRow = toggle?.closest<HTMLElement>('[data-index]')
-    if (!toggle || !toolRow) {
-      throw new Error('the tool run has no mounted toggle')
-    }
-    fireEvent.click(toggle)
-    const heights = Array.from({ length: Number(toolRow.dataset.index) + 1 }, () => ROW_PX)
-    heights[Number(toolRow.dataset.index)] = ROW_PX * 6
-    layout.measuredRowHeights = heights
-    paint(container)
-    // Anti-vacuous: the open run pushed the end away, and the reader was left where they were.
-    expect(distanceFromBottom(container)).toBeGreaterThan(0)
-
-    // Closing lands exactly on the end: no offset moves, so no scroll event reports it.
-    fireEvent.click(toggle)
-    layout.measuredRowHeights = []
+    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)
-    rerender(view([...withTool, marker(toolIndex + 1), marker(toolIndex + 2)]))
+    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(screen.getByText(`marker-${toolIndex + 2}`)).toBeInTheDocument()
+    expect(offersJumpToLatest()).toBe(false)
   })
 
   describe('closing what the reader opened', () => {
@@ -284,29 +223,6 @@ describe('reader navigation', () => {
     const withTool = [...transcript, toolMessage(toolIndex)]
     const streamedOn = [...withTool, marker(toolIndex + 1), marker(toolIndex + 2)]
 
-    it('closing the last open run preserves history when the tail is still distant', () => {
-      const { container, rerender } = render(liveList(withTool))
-      paint(container)
-      const [run] = closedRuns(1)
-      toggleRun(container, run.toggle, [run.rowIndex])
-      rerender(liveList(streamedOn))
-      paint(container)
-      // Anti-vacuous: left behind, well outside the band a scroll would re-arm in.
-      expect(distanceFromBottom(container)).toBeGreaterThan(ROW_PX * 5)
-      expect(offersJumpToLatest()).toBe(true)
-
-      const beforeClose = scrollRoot(container).scrollTop
-      toggleRun(container, run.toggle, [])
-      expect(scrollRoot(container).scrollTop).toBe(beforeClose)
-      expect(distanceFromBottom(container)).toBeGreaterThan(0)
-      expect(offersJumpToLatest()).toBe(true)
-      rerender(liveList([...streamedOn, marker(toolIndex + 3)]))
-      paint(container)
-
-      expect(scrollRoot(container).scrollTop).toBe(beforeClose)
-      expect(distanceFromBottom(container)).toBeGreaterThan(0)
-    })
-
     it('stays where the reader scrolled to while it was open', () => {
       const { container, rerender } = render(liveList(withTool))
       paint(container)
@@ -324,27 +240,6 @@ describe('reader navigation', () => {
       expect(offersJumpToLatest()).toBe(true)
     })
 
-    it('derives following from geometry rather than counting two open runs', () => {
-      const twoTools = [...withTool, marker(toolIndex + 1), toolMessage(toolIndex + 2)]
-      const { container, rerender } = render(liveList(twoTools))
-      paint(container)
-      const [first, second] = closedRuns(2)
-      // Anti-vacuous: two different rows.
-      expect(first.rowIndex).not.toBe(second.rowIndex)
-      toggleRun(container, first.toggle, [first.rowIndex])
-      toggleRun(container, second.toggle, [first.rowIndex, second.rowIndex])
-      const scrollTopWhileOpen = scrollRoot(container).scrollTop
-
-      toggleRun(container, first.toggle, [second.rowIndex])
-      rerender(liveList([...twoTools, marker(toolIndex + 3)]))
-      paint(container)
-      expect(scrollRoot(container).scrollTop).toBe(scrollTopWhileOpen)
-      expect(distanceFromBottom(container)).toBeGreaterThan(0)
-
-      toggleRun(container, second.toggle, [])
-      expect(distanceFromBottom(container)).toBeGreaterThan(0)
-    })
-
     it('leaves a reader who had already scrolled away where they are', () => {
       const { container, rerender } = render(liveList(withTool))
       paint(container)
@@ -363,50 +258,7 @@ describe('reader navigation', () => {
     })
   })
 
-  it('keeps a run the reader left open in place when its output settles shorter', () => {
-    const toolIndex = TRANSCRIPT_LENGTH
-    const withTool: NativeChatMessage[] = [
-      ...transcript,
-      {
-        id: `message-${toolIndex}`,
-        role: 'assistant',
-        blocks: [
-          { type: 'tool-call', name: 'shell', input: { command: 'pwd' }, state: 'completed' },
-          { type: 'tool-result', output: '/repo' }
-        ],
-        timestamp: toolIndex + 1,
-        source: 'transcript'
-      }
-    ]
-    const view = (messages: NativeChatMessage[]) => (
-      <NativeChatMessageList session={session(messages)} isWorking expandSignal={false} />
-    )
-    const { container, rerender } = render(view(withTool))
-    paint(container)
-    const scrollTopBeforeOpen = scrollRoot(container).scrollTop
-    const toggle = screen.getAllByRole('button', { expanded: false }).at(-1)
-    const toolRow = toggle?.closest<HTMLElement>('[data-index]')
-    if (!toggle || !toolRow) {
-      throw new Error('the tool run has no mounted toggle')
-    }
-    fireEvent.click(toggle)
-    const heights = Array.from({ length: Number(toolRow.dataset.index) + 1 }, () => ROW_PX)
-    heights[Number(toolRow.dataset.index)] = ROW_PX * 6
-    layout.measuredRowHeights = heights
-    paint(container)
-
-    // Still open, but now within rounding distance of the end, with no offset moved.
-    layout.measuredRowHeights = heights.with(Number(toolRow.dataset.index), ROW_PX + 2)
-    paint(container)
-    expect(toggle).toHaveAttribute('aria-expanded', 'true')
-    expect(distanceFromBottom(container)).toBe(2)
-    rerender(view([...withTool, marker(toolIndex + 1), marker(toolIndex + 2)]))
-    paint(container)
-
-    expect(scrollRoot(container).scrollTop).toBe(scrollTopBeforeOpen)
-  })
-
-  it('replaces a pending numeric tail pin before a disclosure inserts earlier rows', () => {
+  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)),
@@ -432,23 +284,21 @@ describe('reader navigation', () => {
     )
     paint(container)
     const scroller = scrollRoot(container)
-    const toggle = screen.getByRole('button', { name: 'Toggle turn details' })
     const window = container.querySelector<HTMLElement>('[data-native-chat-window]')
     const beforeSlots = window?.querySelectorAll('[data-index]').length ?? 0
-    toggle.getBoundingClientRect = () => new DOMRect(0, -scroller.scrollTop, 100, 20)
     // A pin created outside the painted frames is still waiting to reconcile by numeric index.
     layout.belowTranscriptPx += 20
     deliverResizes()
-    const before = scroller.scrollTop
-    expect(before).toBeGreaterThan(0)
-    fireEvent.click(toggle)
-    const expandedSlots = window?.querySelectorAll('[data-index]').length ?? 0
-    expect(expandedSlots).toBeGreaterThan(beforeSlots)
+    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)
-    expect(scroller.scrollTop).toBe(before)
-    expect(distanceFromBottom(container)).toBeGreaterThan(0)
     act(() => vi.advanceTimersByTime(160))
-    expect(scroller.scrollTop).toBe(before)
+    paint(container)
+
+    expect(distanceFromBottom(container)).toBe(0)
+    expect(screen.getByText('marker-11')).toBeInTheDocument()
   })
 
   it.each([false, true])(
diff --git a/src/renderer/src/components/native-chat/NativeChatMessageList.tsx b/src/renderer/src/components/native-chat/NativeChatMessageList.tsx
index 4e8a9455fae4..abbcbb6e3e1e 100644
--- a/src/renderer/src/components/native-chat/NativeChatMessageList.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatMessageList.tsx
@@ -6,6 +6,7 @@ import { NativeChatJumpToLatest } from './NativeChatJumpToLatest'
 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'
@@ -17,7 +18,10 @@ import { NativeChatAwaitingInputRow } from './NativeChatAwaitingInputRow'
 import type { RuntimeFileOperationArgs } from '@/runtime/runtime-file-client'
 import type { NativeChatTurnActivity } from '../../../../shared/native-chat-turn-activity'
 import { NativeChatTurnActivityLine } from './NativeChatTurnActivityLine'
-import { NativeChatDisclosureContext } from './native-chat-disclosure-store'
+import {
+  NativeChatDisclosureContext,
+  useNativeChatDisclosures
+} from './native-chat-disclosure-store'
 import {
   NativeChatTranscriptItems,
   NativeChatWaitingTranscriptItems
@@ -31,6 +35,7 @@ import {
 import { useNativeChatTranscriptSlots } from './use-native-chat-transcript-slots'
 import { useNativeChatTranscriptWindow } from './use-native-chat-transcript-window'
 import { useNativeChatSubagentSections } from './use-native-chat-subagent-sections'
+import { toggleNativeChatExpandedKey } from './native-chat-expanded-keys'
 import { useNativeChatTurnMembership } from './use-native-chat-turn-membership'
 import { useNativeChatTranscriptScroll } from './use-native-chat-transcript-scroll'
 import { useNativeChatOlderHistoryAutoload } from './use-native-chat-older-history-autoload'
@@ -43,7 +48,6 @@ import type {
 } from './native-chat-message-rail-items'
 import { useNativeChatRailHistoryJump } from './use-native-chat-rail-history-jump'
 import { useNativeChatReaderScrollInput } from './native-chat-reader-scroll-input'
-import { useNativeChatReaderOpens } from './use-native-chat-reader-opens'
 import { useNativeChatMessageListHandle } from './use-native-chat-reveal-latest'
 
 import type {
@@ -60,7 +64,7 @@ import { useNativeChatTurnDiffs } from './use-native-chat-turn-diffs'
  *  `unshown`: it cannot (the prompt is only in the agent's terminal). */
 export type NativeChatAwaitingInput = 'shown' | 'unshown'
 
-type TranscriptNavigation =
+type NativeChatNavigationRequest =
   | { kind: 'diff'; target: NativeChatDiffReveal }
   | { kind: 'rail'; messageId: string; requestId: number }
 
@@ -111,7 +115,9 @@ export function NativeChatMessageList({
   turnActivity?: NativeChatTurnActivity | null
   runtimeContext?: RuntimeFileOperationArgs | null
 }): React.JSX.Element {
-  const [navigationRequest, setNavigationRequest] = useState<TranscriptNavigation | null>(null)
+  const [navigationRequest, setNavigationRequest] = useState<NativeChatNavigationRequest | null>(
+    null
+  )
   const navigationSequence = useRef(0)
   const revealedDiff = navigationRequest?.kind === 'diff' ? navigationRequest.target : null
   const railJump = navigationRequest?.kind === 'rail' ? navigationRequest : null
@@ -122,6 +128,10 @@ export function NativeChatMessageList({
   const scrollRef = useRef<HTMLDivElement | null>(null)
   const contentRef = useRef<HTMLDivElement | null>(null)
   const [expandedTurnIds, setExpandedTurnIds] = useState<ReadonlySet<string>>(new Set())
+  const disclosures = useNativeChatDisclosures()
+  const toggleExpandedTurn = useCallback((turnKey: string) => {
+    setExpandedTurnIds((current) => toggleNativeChatExpandedKey(current, turnKey))
+  }, [])
 
   const { hasMore, loadingEarlier, loadEarlier } = session
   // No paging from a pending or errored read: the lane would no-op, and its recovery
@@ -212,19 +222,20 @@ export function NativeChatMessageList({
     // mutually exclusive things to be doing.
     revealIndex: nativeChatSlotIndexOf(slots, railJump?.messageId ?? revealedDiff?.messageId)
   })
-  const { scrollToBottom, scrollMessageToTop, ...follow } = useNativeChatTranscriptScroll({
-    scrollRef,
-    contentRef,
-    itemCount: slots.length,
-    isWorking,
-    showsTailRow: tailRow !== null,
-    isVisible,
-    alignToViewportTop: transcriptWindow.alignToViewportTop,
-    scrollToEnd: transcriptWindow.scrollToEnd,
-    restoreScrollOffset: transcriptWindow.restoreScrollOffset,
-    consumeProgrammaticScroll: transcriptWindow.consumeProgrammaticScroll,
-    reconcileReaderScroll: transcriptWindow.reconcileReaderScroll
-  })
+  const { showJump, onScroll, scrollToBottom, scrollMessageToTop, readerLeavesEnd } =
+    useNativeChatTranscriptScroll({
+      scrollRef,
+      contentRef,
+      itemCount: slots.length,
+      isWorking,
+      showsTailRow: tailRow !== null,
+      isVisible,
+      alignToViewportTop: transcriptWindow.alignToViewportTop,
+      scrollToEnd: transcriptWindow.scrollToEnd,
+      restoreScrollOffset: transcriptWindow.restoreScrollOffset,
+      consumeProgrammaticScroll: transcriptWindow.consumeProgrammaticScroll,
+      reconcileReaderScroll: transcriptWindow.reconcileReaderScroll
+    })
   const olderHistory = useNativeChatOlderHistoryAutoload({
     scrollRef,
     historyKey: `${session.agent}:${session.sessionId ?? ''}:${session.olderHistoryGeneration}`,
@@ -255,18 +266,7 @@ export function NativeChatMessageList({
     loadEarlier,
     jumpToLoaded: requestRailJump
   })
-  const { readerActs, readerLeavesEnd } = follow
-  const { start: startHistoryJump, abort: abortHistoryJump } = railHistoryJump
-  const beginNavigation = useCallback(() => {
-    abortHistoryJump()
-    readerActs()
-  }, [abortHistoryJump, readerActs])
-  const readerOpens = useNativeChatReaderOpens({
-    subagentDisclosure,
-    setExpandedTurnIds,
-    follow,
-    abortNavigation: beginNavigation
-  })
+  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(
@@ -301,12 +301,20 @@ export function NativeChatMessageList({
     beginNavigation()
     scrollToBottom()
   }, [beginNavigation, scrollToBottom])
-  useNativeChatMessageListHandle(ref, jumpToLatest, follow.untilReaderActs)
+  useNativeChatMessageListHandle(ref, jumpToLatest)
   const readerScrollInput = useNativeChatReaderScrollInput(scrollRef, {
     onReaderScroll: beginNavigation,
     onLeaveEnd: readerLeavesEnd
   })
-  // Service each pinned request once; a streaming render must not restart its scroll.
+  // 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
+  // token snaps the reader straight back down.
+  //
+  // Serviced once per request, then released. `slots` takes a new identity on
+  // every render, so an effect that merely depended on it would re-scroll to this
+  // row forever; and a request left standing would keep its pin, which outranks
+  // the diff reveal that shares it.
   useLayoutEffect(() => {
     if (railJump === null || servicedRailJumpRef.current === railJump.requestId) {
       return
@@ -330,8 +338,8 @@ export function NativeChatMessageList({
       allowFileUriLinks,
       runtimeContext,
       onLinkClick,
-      onToggleExpandedTurn: readerOpens.toggleExpandedTurn,
-      subagentDisclosure: readerOpens.subagentDisclosure,
+      onToggleExpandedTurn: toggleExpandedTurn,
+      subagentDisclosure,
       onScrollMessageToTop: scrollMessageToTop,
       onRevealDiff: revealDiff
     }),
@@ -346,20 +354,19 @@ export function NativeChatMessageList({
       runtimeContext,
       scrollMessageToTop,
       taskListPredecessors,
-      readerOpens.subagentDisclosure,
-      readerOpens.toggleExpandedTurn
+      subagentDisclosure,
+      toggleExpandedTurn
     ]
   )
 
   return (
-    <NativeChatDisclosureContext.Provider value={readerOpens.disclosures}>
+    <NativeChatDisclosureContext.Provider value={disclosures}>
       <div className="relative flex min-h-0 flex-1 flex-col bg-chat-canvas">
         <div className="relative min-h-0 flex-1">
           <div
             ref={scrollRef}
-            onScroll={follow.onScroll}
+            onScroll={onScroll}
             {...readerScrollInput.scrollerProps}
-            onClickCapture={follow.captureDisclosureTarget}
             // Named so measurement can find the scroll root without depending on
             // which utility class happens to make it scroll.
             data-native-chat-scroll
@@ -406,7 +413,7 @@ export function NativeChatMessageList({
             onReaderScroll={readerScrollInput.railWheel}
             pendingId={railHistoryJump.pendingId}
           />
-          <NativeChatJumpToLatest visible={follow.showJump} onJump={jumpToLatest} />
+          <NativeChatJumpToLatest visible={showJump} onJump={jumpToLatest} />
         </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/NativeChatResolvedView.reveal-latest.test.tsx b/src/renderer/src/components/native-chat/NativeChatResolvedView.reveal-latest.test.tsx
index 1c9c3329c09b..e1e708a6beb2 100644
--- a/src/renderer/src/components/native-chat/NativeChatResolvedView.reveal-latest.test.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatResolvedView.reveal-latest.test.tsx
@@ -24,10 +24,7 @@ vi.mock('./use-native-chat-retained-session', () => ({
 }))
 vi.mock('./NativeChatMessageList', () => ({
   NativeChatMessageList: (props: { ref?: React.Ref<NativeChatMessageListHandle> }) => {
-    useImperativeHandle(props.ref, () => ({
-      revealLatest: stubs.revealLatest,
-      holdRevealLatest: () => stubs.revealLatest
-    }))
+    useImperativeHandle(props.ref, () => ({ revealLatest: stubs.revealLatest }))
     return null
   }
 }))
@@ -35,11 +32,16 @@ vi.mock('./use-native-chat-interactive-send', () => ({
   useNativeChatInteractiveSend: (): NativeChatInteractiveSend => ({
     sendAnswer: () => ({ settleAfterMs: 0, waitsForVerifiedDelivery: false }),
     sendRaw: () => {},
+    sendRawVerified: async () => true,
     cancelPending: () => {},
-    cancelAsk: () => {},
+    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
@@ -53,6 +55,10 @@ vi.mock('./NativeChatComposer', () => ({
   }
 }))
 
+const prompt: AskPrompt = {
+  questions: [{ question: 'Indent with?', multiSelect: false, options: [{ label: 'Tabs' }] }]
+}
+
 const { NativeChatResolvedView } = await import('./NativeChatResolvedView')
 
 afterEach(() => {
@@ -62,10 +68,6 @@ afterEach(() => {
   stubs.cardSend = null
 })
 
-const prompt: AskPrompt = {
-  questions: [{ question: 'Indent with?', multiSelect: false, options: [{ label: 'Tabs' }] }]
-}
-
 describe('NativeChatResolvedView sends', () => {
   it('brings the latest into view for a composer send and a prompt answer, not a Stop', () => {
     stubs.session = {
@@ -105,15 +107,16 @@ describe('NativeChatResolvedView sends', () => {
 
     stubs.composer?.onSubmitted?.()
     expect(stubs.revealLatest).toHaveBeenCalledOnce()
-    // A question answer and an approval option, then Stop: only the answers are sends.
+    // 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)
-    stubs.cardSend?.sendRaw('1')
+    void stubs.cardSend?.sendRawVerified('1')
     expect(stubs.revealLatest).toHaveBeenCalledTimes(3)
     stubs.cardSend?.cancel()
+    void stubs.cardSend?.cancelAsk()
     expect(stubs.revealLatest).toHaveBeenCalledTimes(3)
   })
 
@@ -132,7 +135,7 @@ describe('NativeChatResolvedView sends', () => {
       />
     )
     stubs.cardSend?.sendAnswer(prompt, [{ indices: [0] }])
-    stubs.cardSend?.sendRaw('1')
+    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 292e4b2372d8..dc98e60d11b2 100644
--- a/src/renderer/src/components/native-chat/NativeChatResolvedView.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatResolvedView.tsx
@@ -122,9 +122,7 @@ export function NativeChatResolvedView({
   // stop (Stop sends ESC, the agent-TUI interrupt key).
   const send = useNativeChatInteractiveSend(terminalTabId, paneKey, targetPtyId, agent)
   // Every send this pane makes brings the latest into view, wherever the reader had scrolled.
-  const revealScope = `${agent}:${sessionId}:${targetPtyId}`
-  const reveals = useNativeChatRevealLatest(revealScope, isVisible)
-  const { messageListRef, revealLatest, holdRevealLatest } = reveals
+  const { messageListRef, revealLatest } = useNativeChatRevealLatest()
   const interactiveSend = useNativeChatInteractiveSendReveal(send, targetPtyId, revealLatest)
   const [workingInterrupted, setWorkingInterrupted] = useState(false)
   const previousWorkingEpochRef = useRef<number | null>(null)
@@ -152,7 +150,9 @@ export function NativeChatResolvedView({
     }
   })
 
-  // Keep the optimistic echo until its real transcript turn arrives.
+  // Optimistic "queued" sends (mobile parity): a composer send is echoed
+  // immediately and pruned once its real user turn lands in the transcript, so
+  // the message never vanishes between send and transcript catch-up.
   const commandMarkerScope = useMemo(
     () => ({ paneKey, agent, sessionId }),
     [paneKey, agent, sessionId]
@@ -386,7 +386,6 @@ export function NativeChatResolvedView({
           <NativeChatEmptyState kind="empty" agent={agent} />
         ) : (
           <NativeChatMessageList
-            key={`${agent}:${sessionId}`}
             ref={messageListRef}
             session={sessionWithPending}
             isVisible={isVisible}
@@ -437,7 +436,6 @@ export function NativeChatResolvedView({
           optimisticSendOutcome={delivery}
           onSlashCommand={onSlashCommand}
           onSubmitted={revealLatest}
-          holdRevealLatest={holdRevealLatest}
           answerCommandLocally={answerLocally}
           onSwitchToTerminal={onSwitchToTerminal}
           readTerminalScreen={readTerminalScreen}
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 81ca742e5900..9eaf836b633d 100644
--- a/src/renderer/src/components/native-chat/NativeChatStructuredSession.test-harness.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatStructuredSession.test-harness.tsx
@@ -237,7 +237,6 @@ export function createStructuredSessionMocks() {
             failedHere: outbox.failedHere,
             submissions: mocks.submissions,
             send: outbox.send,
-            sendFromComposer: outbox.send,
             retry: outbox.retry,
             isWorking: mocks.isWorking,
             backgroundTasks: {
@@ -323,10 +322,7 @@ export function createStructuredSessionMocks() {
     nativeChatMessageList: () => ({
       NativeChatMessageList: (props: typeof mocks.messageListProps) => {
         mocks.messageListProps = props
-        useImperativeHandle(props?.ref, () => ({
-          revealLatest: mocks.revealLatest,
-          holdRevealLatest: () => mocks.revealLatest
-        }))
+        useImperativeHandle(props?.ref, () => ({ revealLatest: mocks.revealLatest }))
         return <DeliveryNoticesMock notices={props?.deliveryNotices} />
       }
     }),
diff --git a/src/renderer/src/components/native-chat/NativeChatStructuredSession.test.tsx b/src/renderer/src/components/native-chat/NativeChatStructuredSession.test.tsx
index 7acc8c12ef7a..564e5555d1ed 100644
--- a/src/renderer/src/components/native-chat/NativeChatStructuredSession.test.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatStructuredSession.test.tsx
@@ -724,7 +724,7 @@ describe('NativeChatStructuredSession', () => {
   })
 
   // The reader may have scrolled far up; what they just did has to come into view.
-  it('brings the latest into view for the submits this pane makes, and not for refused ones', async () => {
+  it('brings the latest into view at the press for the submits this pane makes', async () => {
     mocks.promptItems = legacySingleQuestionPromptItems
     const { rerender } = render(
       <NativeChatStructuredSession
@@ -736,16 +736,11 @@ describe('NativeChatStructuredSession', () => {
         agent="claude"
       />
     )
-    // Refused by the host: nothing was answered, so the reader is left where they are.
-    mocks.respond.mockResolvedValueOnce(null)
+    // An answer reveals as it is pressed, before the host decides on it.
+    mocks.respond.mockReturnValueOnce(new Promise(() => {}))
     mocks.questionCardProps?.onAnswer([{ indices: [1], other: '' }])
-    await new Promise<void>((resolve) => setTimeout(resolve, 0))
     expect(mocks.respond).toHaveBeenCalledOnce()
-    expect(mocks.revealLatest).not.toHaveBeenCalled()
-
-    mocks.respond.mockResolvedValueOnce({ itemId: 'question-1', revision: 2 })
-    mocks.questionCardProps?.onAnswer([{ indices: [1], other: '' }])
-    await waitFor(() => expect(mocks.revealLatest).toHaveBeenCalledOnce())
+    expect(mocks.revealLatest).toHaveBeenCalledOnce()
 
     mocks.promptItems = []
     rerender(
@@ -769,7 +764,7 @@ describe('NativeChatStructuredSession', () => {
     expect(steerQueued()).toBe(false)
     expect(mocks.revealLatest).not.toHaveBeenCalled()
 
-    // The composer reports only sends its transport accepted.
+    // The composer's sends reveal through its transport.
     onSubmitted()
     expect(mocks.revealLatest).toHaveBeenCalledOnce()
     mocks.queuedSteerNewest.mockReturnValue(true)
diff --git a/src/renderer/src/components/native-chat/NativeChatStructuredSession.tsx b/src/renderer/src/components/native-chat/NativeChatStructuredSession.tsx
index dbe8ef946bef..9e63218f6fb3 100644
--- a/src/renderer/src/components/native-chat/NativeChatStructuredSession.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatStructuredSession.tsx
@@ -123,7 +123,7 @@ export function NativeChatStructuredSession(
     [controller, historyPhase, props.agent, props.sessionId]
   )
   const submits = useStructuredNativeChatSubmitReveal(controller, provisionalLaunch.retry)
-  const { retryDelivery, revealLatest, holdRevealLatest } = submits
+  const { retryDelivery, revealLatest } = submits
   const agentLabel = structuredAgentLabel(props.agent)
   const deliveryNotices = useStructuredAgentSessionDeliveryNotices({
     outbox: controller.outbox,
@@ -190,7 +190,7 @@ export function NativeChatStructuredSession(
       ): boolean | 'queued' => {
         let admission: boolean | 'queued' = false
         const accepted = sendThroughRelaunch(() => {
-          admission = controller.sendFromComposer(
+          admission = controller.send(
             text,
             attachments.map((attachment) => ({
               path: attachment.path,
@@ -224,7 +224,6 @@ export function NativeChatStructuredSession(
       worktreeId: ownerWorktreeId ?? undefined,
       onError: setComposerError,
       onSubmitted: revealLatest,
-      holdRevealLatest,
       runtime: (props.target.kind === 'local' ? 'local' : 'remote') as 'local' | 'remote',
       sessionId: props.sessionId,
       runtimeEnvironmentId:
@@ -238,7 +237,6 @@ export function NativeChatStructuredSession(
     props.sessionId,
     props.target,
     revealLatest,
-    holdRevealLatest,
     sendThroughRelaunch
   ])
 
diff --git a/src/renderer/src/components/native-chat/NativeChatStructuredSessionDelivery.test.tsx b/src/renderer/src/components/native-chat/NativeChatStructuredSessionDelivery.test.tsx
index c2ef48ea686b..d36cc874b530 100644
--- a/src/renderer/src/components/native-chat/NativeChatStructuredSessionDelivery.test.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatStructuredSessionDelivery.test.tsx
@@ -86,7 +86,6 @@ vi.mock('./use-structured-agent-session', async () => {
         failedHere: outbox.failedHere,
         submissions: mocks.submissions,
         send: outbox.send,
-        sendFromComposer: outbox.send,
         retry: outbox.retry,
         isWorking: false,
         isMonitoringBackgroundTasks: mocks.monitoringBackgroundTasks,
diff --git a/src/renderer/src/components/native-chat/NativeChatSubagentRun.test.tsx b/src/renderer/src/components/native-chat/NativeChatSubagentRun.test.tsx
index 6dc028c154e2..ddbb96347e3a 100644
--- a/src/renderer/src/components/native-chat/NativeChatSubagentRun.test.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatSubagentRun.test.tsx
@@ -3,14 +3,13 @@
 import '@testing-library/jest-dom/vitest'
 
 import { cleanup, fireEvent, render, screen } from '@testing-library/react'
-import { afterEach, describe, expect, it, vi } from 'vitest'
+import { afterEach, describe, expect, it } from 'vitest'
 import type {
   NativeChatSubagentEntry,
   NativeChatSubagentGroupBlock
 } from '../../../../shared/native-chat-types'
 import { NativeChatSubagentRun } from './NativeChatSubagentRun'
 import { NativeChatToolRun } from './NativeChatToolRun'
-import { NativeChatDisclosureContext } from './native-chat-disclosure-store'
 
 afterEach(cleanup)
 
@@ -336,26 +335,3 @@ describe('NativeChatToolRun with a spawn group', () => {
     expect(screen.getByRole('button', { name: /search/, expanded: true })).toBeInTheDocument()
   })
 })
-
-const onToggle = vi.fn()
-const TRANSCRIPT_DISCLOSURES = { read: () => undefined, write: vi.fn(), onToggle }
-
-// Without a held open state the run keeps its own, and the transcript still hears the reader toggle it.
-it('reports opening and closing an unheld run to the transcript', () => {
-  onToggle.mockClear()
-  render(
-    <NativeChatDisclosureContext.Provider value={TRANSCRIPT_DISCLOSURES}>
-      <NativeChatSubagentRun block={group([{ id: 'a', label: 'read', state: 'working' }])} />
-    </NativeChatDisclosureContext.Provider>
-  )
-  const toggle = screen.getByRole('button')
-
-  fireEvent.click(toggle)
-  expect(toggle).toHaveAttribute('aria-expanded', 'true')
-  expect(onToggle.mock.calls).toEqual([[expect.any(String), true]])
-  fireEvent.click(toggle)
-  // The close names the row the open did, so the transcript can match them.
-  const [[openedRow], [closedRow, closedOpen]] = onToggle.mock.calls
-  expect(closedOpen).toBe(false)
-  expect(closedRow).toBe(openedRow)
-})
diff --git a/src/renderer/src/components/native-chat/NativeChatSubagentRun.tsx b/src/renderer/src/components/native-chat/NativeChatSubagentRun.tsx
index 4f82698a44e2..a5d9b2a28376 100644
--- a/src/renderer/src/components/native-chat/NativeChatSubagentRun.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatSubagentRun.tsx
@@ -1,5 +1,4 @@
-import { useMemo } from 'react'
-import { useNativeChatDisclosure } from './native-chat-disclosure-store'
+import { useMemo, useState } from 'react'
 import { Bot, ChevronRight } from 'lucide-react'
 import { cn } from '@/lib/utils'
 import { translate } from '@/i18n/i18n'
@@ -245,10 +244,9 @@ export function NativeChatSubagentRun({
   sections?: ReadonlyMap<string, boolean>
   onSetSectionOpen?: (agentId: string, open: boolean) => void
 }): React.JSX.Element | null {
-  // Unkeyed, but still a reader's open the transcript hears about.
-  const local = useNativeChatDisclosure(undefined, false)
-  const open = heldOpen ?? local.open
-  const setOpen = onSetOpen ?? local.setOpen
+  const [localOpen, setLocalOpen] = useState(false)
+  const open = heldOpen ?? localOpen
+  const setOpen = onSetOpen ?? setLocalOpen
   const agents = block.agents
   const summary = useMemo(() => summarizeSubagentGroup(agents), [agents])
   if (summary.total === 0) {
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 170fdc89c7f2..ab07cc590a7f 100644
--- a/src/renderer/src/components/native-chat/native-chat-autoscroll.ts
+++ b/src/renderer/src/components/native-chat/native-chat-autoscroll.ts
@@ -66,7 +66,7 @@ export function nextFollowingEnd(intent: FollowIntent): boolean {
 /** 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'; deltaY?: number }
+  | { kind: 'touch-drag' }
   | { kind: 'scrollbar-press' }
   | { kind: 'content-press' }
   | { kind: 'key'; key: string; shift?: boolean }
@@ -79,9 +79,6 @@ 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 === 'touch-drag' && gesture.deltaY !== undefined) {
-    return gesture.deltaY === 0 ? 0 : gesture.deltaY < 0 ? -1 : 1
-  }
   if (gesture.kind === 'key') {
     if (gesture.key === ' ') {
       return gesture.shift ? -1 : 1
@@ -100,10 +97,8 @@ export function readerGestureLeavesEnd(gesture: ReaderGesture, geometry: ScrollG
       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':
-      return gesture.deltaY === undefined
-        ? awayFromEnd
-        : readerGestureDirection(gesture) < 0 && contentAbove
     case 'content-press':
       return awayFromEnd
     case 'key': {
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 37b198be321f..46af699626d9 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
@@ -35,10 +35,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
-  /** The host accepted a message, a command it runs itself, or a goal. */
+  /** A local send: brings the latest into view at the press, not when the host answers. */
   onSubmitted?: () => void
-  /** Capture this pane and reader position before waiting for acceptance. */
-  holdRevealLatest?: () => () => void
   runtime: 'local' | 'remote'
   /** The session behind this composer; a real user send relinquishes orchestration ownership. */
   sessionId: string
@@ -83,10 +81,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 delivered to the terminal: a message, a command or a session option. */
+  /** Anything sent to the terminal: a message, a command or a session option. */
   onSubmitted?: () => void
-  /** Capture this pane and reader position before waiting for acceptance. */
-  holdRevealLatest?: () => () => 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-disclosure-store.ts b/src/renderer/src/components/native-chat/native-chat-disclosure-store.ts
index f7514d78baf8..956ae3b0ca1a 100644
--- a/src/renderer/src/components/native-chat/native-chat-disclosure-store.ts
+++ b/src/renderer/src/components/native-chat/native-chat-disclosure-store.ts
@@ -7,13 +7,11 @@
 // the reader's back. Rows read through this store when the transcript provides
 // one, and fall back to their own state when they are rendered standalone.
 
-import { createContext, useCallback, useContext, useId, useMemo, useState } from 'react'
+import { createContext, useCallback, useContext, useMemo, useState } from 'react'
 
 export type NativeChatDisclosureStore = {
   read: (key: string) => boolean | undefined
   write: (key: string, open: boolean) => void
-  /** Told whenever the reader opens or closes a row, keyed or not, and which one. */
-  onToggle?: (row: string, open: boolean) => void
 }
 
 export const NativeChatDisclosureContext = createContext<NativeChatDisclosureStore | null>(null)
@@ -46,7 +44,7 @@ export function useNativeChatDisclosures(): NativeChatDisclosureStore {
 export type NativeChatDisclosure = {
   open: boolean
   /** A reader's choice: remembered past this row's lifetime when keyed. */
-  setOpen: (next: boolean, readerInitiated?: boolean) => void
+  setOpen: (next: boolean) => void
 }
 
 export function useNativeChatDisclosure(
@@ -56,24 +54,18 @@ export function useNativeChatDisclosure(
   const store = useContext(NativeChatDisclosureContext)
   const [local, setLocal] = useState({ key, initialOpen, open: initialOpen })
   const write = store?.write
-  const onToggle = store?.onToggle
-  const unkeyedRow = useId()
-  const row = key ?? unkeyedRow
   const isStored = key !== undefined && store !== null
   const localOpen =
     local.key === key && local.initialOpen === initialOpen ? local.open : initialOpen
   const open = isStored ? (store.read(key) ?? localOpen) : localOpen
   const setOpen = useCallback(
-    (next: boolean, readerInitiated = true) => {
+    (next: boolean) => {
       setLocal({ key, initialOpen, open: next })
       if (key !== undefined && write) {
         write(key, next)
       }
-      if (readerInitiated) {
-        onToggle?.(row, next)
-      }
     },
-    [initialOpen, key, onToggle, row, write]
+    [initialOpen, key, write]
   )
   return { open, setOpen }
 }
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
index 9d853dbd7f49..66ec19bad30d 100644
--- 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
@@ -43,15 +43,21 @@ it('leaves transcript following with the nested scroller until it chains upward'
   fireEvent.wheel(h.getByTestId('text'), { deltaY: -10 })
   expect(h.onLeaveEnd).not.toHaveBeenCalled()
 })
-it('hands the transcript to upward keyboard, touch, scrollbar and rail gestures', () => {
+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.touchStart(h.root, { touches: [{ clientY: 100 }] })
-  fireEvent.touchMove(h.root, { touches: [{ clientY: 130 }] })
   fireEvent.pointerDown(h.root)
   h.railWheel(-20)
-  expect(h.onLeaveEnd).toHaveBeenCalledTimes(5)
+  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()
@@ -76,8 +82,6 @@ it('keeps following on downward gestures at the tail, zoom and editing keys', ()
   expect(h.getByTestId('input').closest('input, textarea, select')).not.toBeNull()
   fireEvent.keyDown(h.getByTestId('input'), { key: 'ArrowUp' })
   expect(h.onLeaveEnd, 'editable key').not.toHaveBeenCalled()
-  fireEvent.touchStart(h.root, { touches: [{ clientY: 100 }] })
-  fireEvent.touchMove(h.root, { touches: [{ clientY: 100 }] })
   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 b5a6c04eb84b..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
@@ -72,7 +72,7 @@ type ReaderScrollCallbacks = {
 
 export type NativeChatReaderScrollInputHandlers = Pick<
   React.HTMLAttributes<HTMLDivElement>,
-  'onWheel' | 'onTouchStart' | 'onTouchMove' | 'onKeyDown' | 'onPointerDown' | 'tabIndex' | 'role'
+  'onWheel' | 'onTouchMove' | 'onKeyDown' | 'onPointerDown' | 'tabIndex' | 'role'
 >
 
 /** Invalidate pending navigation on input, and detach only when the transcript can move away. */
@@ -80,7 +80,6 @@ export function nativeChatReaderScrollInputHandlers({
   onReaderScroll,
   onLeaveEnd
 }: ReaderScrollCallbacks): NativeChatReaderScrollInputHandlers {
-  let touchY: number | null = null
   const report = (gesture: ReaderGesture, event: React.SyntheticEvent<HTMLDivElement>): void => {
     const transcript = event.currentTarget
     if (
@@ -100,18 +99,9 @@ export function nativeChatReaderScrollInputHandlers({
       onReaderScroll()
       report({ kind: 'wheel', deltaY: event.deltaY, zoom: event.ctrlKey }, event)
     },
-    onTouchStart: (event) => {
-      touchY = event.touches[0]?.clientY ?? null
-    },
     onTouchMove: (event) => {
-      const nextY = event.touches[0]?.clientY ?? null
-      const deltaY = touchY !== null && nextY !== null ? touchY - nextY : undefined
-      touchY = nextY
-      if (deltaY === 0) {
-        return
-      }
       onReaderScroll()
-      report({ kind: 'touch-drag', deltaY }, event)
+      report({ kind: 'touch-drag' }, event)
     },
     onKeyDown: (event) => {
       if (!READER_SCROLL_KEYS.has(event.key) || isEditableTarget(event.target)) {
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 8ea2c58251ee..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
@@ -7,12 +7,9 @@ export async function dispatchNativeChatStructuredComposerText(
   attachments: readonly NativeChatComposerImageAttachment[] = []
 ): 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,
-      revealsTranscript: command.accepted && !command.error && command.revealsTranscript !== false
-    }
+    return { accepted: command.accepted, error: command.error, revealsTranscript: false }
   }
   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
index d781cbf4e603..1596863f2a39 100644
--- 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
@@ -16,6 +16,7 @@ import {
 } 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
@@ -87,7 +88,9 @@ function transport(
         agent: 'codex',
         snapshot: options,
         invokeAction: async () => true,
-        setOption
+        setOption,
+        conversationCommands: ['compact'],
+        runConversationCommand: async () => ({ accepted: await setOption(), error: null })
       }),
     optionsSurface: {
       getSnapshot: () => options,
@@ -126,11 +129,7 @@ function useReviewTranscript() {
     reconcileReaderScroll: vi.fn()
   })
   const reveal = useNativeChatRevealLatest()
-  useNativeChatMessageListHandle(
-    reveal.messageListRef,
-    scroll.scrollToBottom,
-    scroll.untilReaderActs
-  )
+  useNativeChatMessageListHandle(reveal.messageListRef, scroll.scrollToBottom)
   return { ...reveal, scroll, scrollToEnd, element: scrollRef.current }
 }
 
@@ -144,14 +143,11 @@ function readerScrollAway(transcript: ReturnType<typeof useReviewTranscript>) {
   surface.unmount()
 }
 
-it('preserves a newer reader scroll-away while a structured option command is awaiting the host', async () => {
+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),
-      holdRevealLatest: transcript.holdRevealLatest
-    }
+    const t = transport(transcript.revealLatest, () => host.promise)
     const send = useNativeChatStructuredComposerSend({
       agent: 'codex',
       draftScopeKey: 'send-r1-delay',
@@ -165,8 +161,11 @@ it('preserves a newer reader scroll-away while a structured option command is aw
     })
     return { ...transcript, send }
   })
+  readerScrollAway(hook.result.current)
   hook.result.current.scrollToEnd.mockClear()
-  act(() => hook.result.current.send('/model next'))
+  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()
@@ -174,7 +173,7 @@ it('preserves a newer reader scroll-away while a structured option command is aw
   expect(hook.result.current.scrollToEnd).not.toHaveBeenCalled()
 })
 
-it('preserves a newer reader scroll-away while a goal-mode submit is awaiting the host', async () => {
+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')
@@ -183,7 +182,6 @@ it('preserves a newer reader scroll-away while a goal-mode submit is awaiting th
       const transcript = useReviewTranscript()
       const t = {
         ...transport(transcript.revealLatest, async () => true),
-        holdRevealLatest: transcript.holdRevealLatest,
         threadGoal: { setObjective: () => host.promise }
       }
       const submit = useNativeChatComposerSubmit({
@@ -207,7 +205,10 @@ it('preserves a newer reader scroll-away while a goal-mode submit is awaiting th
   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()
@@ -292,25 +293,20 @@ it('reveals the new transcript answer for a picked locally answered /context', (
   expect(args.onSubmitted).toHaveBeenCalledOnce()
 })
 
-it('does not reveal the replacement PTY session when an old option send finishes', async () => {
+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(ptyId)
-      useNativeChatMessageListHandle(
-        reveal.messageListRef,
-        ptyId === 'pty-a' ? revealA : revealB,
-        (action) => action
-      )
+      const reveal = useNativeChatRevealLatest()
+      useNativeChatMessageListHandle(reveal.messageListRef, ptyId === 'pty-a' ? revealA : revealB)
       return useNativeChatSessionOptionCommand({
         agent: 'codex',
         disabled: false,
         resolveTarget: () => ({ ptyId, settings: null }),
         onSubmitted: reveal.revealLatest,
-        holdRevealLatest: reveal.holdRevealLatest,
         setHistory: vi.fn()
       })
     },
@@ -321,16 +317,17 @@ it('does not reveal the replacement PTY session when an old option send finishes
     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).not.toHaveBeenCalled()
+  expect(revealA).toHaveBeenCalledOnce()
   expect(revealB).not.toHaveBeenCalled()
 })
 
-it('preserves a newer reader scroll-away while a verified PTY option send is awaiting acceptance', async () => {
+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(() => {
@@ -340,16 +337,17 @@ it('preserves a newer reader scroll-away while a verified PTY option send is awa
       disabled: false,
       resolveTarget: () => ({ ptyId: 'pty-a', settings: null }),
       onSubmitted: transcript.revealLatest,
-      holdRevealLatest: transcript.holdRevealLatest,
       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()
@@ -382,7 +380,21 @@ it('control: a refused structured message does not reveal', async () => {
   expect(onSubmitted).not.toHaveBeenCalled()
 })
 
-it('control: a held structured card reveal expires when the reader scrolls away', async () => {
+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()
@@ -391,6 +403,7 @@ it('control: a held structured card reveal expires when the reader scrolls away'
         respond: async () => host.promise,
         retry: vi.fn(),
         queuedMessages: {
+          queueCapable: true,
           cards: [],
           pause: null,
           resuming: false,
@@ -403,18 +416,22 @@ it('control: a held structured card reveal expires when the reader scrolls away'
       },
       vi.fn()
     )
-    useNativeChatMessageListHandle(
-      submits.messageListRef,
-      transcript.scroll.scrollToBottom,
-      transcript.scroll.untilReaderActs
-    )
+    useNativeChatMessageListHandle(submits.messageListRef, transcript.scroll.scrollToBottom)
     return { ...transcript, submits }
   })
+  readerScrollAway(hook.result.current)
   hook.result.current.scrollToEnd.mockClear()
-  const held = hook.result.current.submits.messageListRef.current?.holdRevealLatest()
-  expect(held).toBeTypeOf('function')
+  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)
-  act(() => held?.())
+  hook.result.current.scrollToEnd.mockClear()
+  await act(async () => {
+    host.settle(null)
+    await answering
+  })
   expect(hook.result.current.scrollToEnd).not.toHaveBeenCalled()
 })
 
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 a1d5bea082f5..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
@@ -136,7 +136,8 @@ describe('composer goal mode', () => {
     await act(async () => hook.result.current.send())
 
     expect(setObjective).toHaveBeenCalledOnce()
-    expect(onSubmitted).not.toHaveBeenCalled()
+    // 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 1135aad0d7a9..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,14 +85,13 @@ export function useNativeChatComposerSubmit(args: {
       )
       return
     }
-    const reveal = structuredTransport.holdRevealLatest?.() ?? structuredTransport.onSubmitted
+    structuredTransport.onSubmitted?.()
     const submitted = readNativeChatComposerDraft(draftScopeKey)
     void threadGoal.setObjective(objective).then((accepted) => {
       if (!accepted) {
         return
       }
       structuredTransport.onError(null)
-      reveal?.()
       setHistory((previous) => pushHistory(previous, draft))
       if (!clearNativeChatComposerDraftIfUnchanged(draftScopeKey, submitted)) {
         return
diff --git a/src/renderer/src/components/native-chat/use-native-chat-disclosure-position.test.tsx b/src/renderer/src/components/native-chat/use-native-chat-disclosure-position.test.tsx
deleted file mode 100644
index c9b18cd387af..000000000000
--- a/src/renderer/src/components/native-chat/use-native-chat-disclosure-position.test.tsx
+++ /dev/null
@@ -1,160 +0,0 @@
-// @vitest-environment happy-dom
-import { act, cleanup, fireEvent, render } from '@testing-library/react'
-import { useRef, useState } from 'react'
-import { afterEach, beforeEach, expect, it, vi } from 'vitest'
-import { useNativeChatTranscriptScroll } from './use-native-chat-transcript-scroll'
-
-beforeEach(() => vi.useFakeTimers())
-afterEach(() => {
-  cleanup()
-  vi.useRealTimers()
-})
-function harness() {
-  const scrollToEnd = vi.fn()
-  const reconcileReaderScroll = vi.fn()
-  let itemCount = 10
-  let visible = true
-  let rectTop = 100
-  let height = 1000
-  let remove = false
-  let heldReveal: (() => void) | undefined
-  const restoreScrollOffset = vi.fn((offset: number) => {
-    root.scrollTop = offset
-  })
-  function Harness() {
-    const scrollRef = useRef<HTMLDivElement>(null)
-    const contentRef = useRef<HTMLDivElement>(null)
-    const [, renderAgain] = useState(0)
-    const scroll = useNativeChatTranscriptScroll({
-      scrollRef,
-      contentRef,
-      itemCount,
-      isWorking: true,
-      showsTailRow: true,
-      isVisible: visible,
-      scrollToEnd,
-      restoreScrollOffset,
-      reconcileReaderScroll,
-      alignToViewportTop: vi.fn(),
-      consumeProgrammaticScroll: () => false
-    })
-    heldReveal = scroll.untilReaderActs(scroll.scrollToBottom)
-    return (
-      <div
-        ref={scrollRef}
-        data-testid="root"
-        onScroll={scroll.onScroll}
-        onClickCapture={scroll.captureDisclosureTarget}
-      >
-        <div ref={contentRef} />
-        {!remove && (
-          <button
-            onClick={() => {
-              scroll.holdDisclosurePosition()
-              renderAgain((n) => n + 1)
-            }}
-          >
-            toggle
-          </button>
-        )}
-        <button onClick={scroll.readerLeavesEnd}>navigate</button>
-        <output>{String(scroll.showJump)}</output>
-      </div>
-    )
-  }
-  const view = render(<Harness />)
-  const root = view.getByTestId('root')
-  Object.defineProperties(root, {
-    clientHeight: { value: 100 },
-    offsetHeight: { value: 100 },
-    scrollHeight: { get: () => height }
-  })
-  root.getBoundingClientRect = () => new DOMRect(0, 0, 100, 200)
-  root.scrollTop = 900
-  const toggle = view.getByText('toggle')
-  toggle.getBoundingClientRect = () => new DOMRect(0, rectTop - (root.scrollTop - 900) * 2, 100, 20)
-  scrollToEnd.mockClear()
-  return {
-    ...view,
-    root,
-    toggle,
-    scrollToEnd,
-    restoreScrollOffset,
-    reconcileReaderScroll,
-    held: () => heldReveal,
-    grow: () => {
-      height += 100
-      itemCount += 1
-      view.rerender(<Harness />)
-    },
-    setTop: (n: number) => {
-      rectTop = n
-    },
-    setHeight: (n: number) => {
-      height = n
-    },
-    hide: () => {
-      visible = false
-      view.rerender(<Harness />)
-    },
-    remove: () => {
-      remove = true
-      view.rerender(<Harness />)
-    }
-  }
-}
-it('preserves the clicked control through measured drift in a zoomed transcript', () => {
-  const h = harness()
-  fireEvent.click(h.toggle)
-  h.setTop(160)
-  h.setHeight(1600)
-  act(() => vi.advanceTimersByTime(40))
-  expect(h.root.scrollTop).toBe(930)
-  expect(h.restoreScrollOffset).toHaveBeenCalledWith(930)
-  expect(h.scrollToEnd).not.toHaveBeenCalled()
-  expect(h.reconcileReaderScroll).toHaveBeenCalledWith(true)
-  expect(h.getByText('true')).toBeTruthy()
-})
-it('ends a hold when its row disappears and re-derives actual tail proximity', () => {
-  const h = harness()
-  fireEvent.click(h.toggle)
-  h.remove()
-  act(() => vi.advanceTimersByTime(40))
-  expect(h.scrollToEnd).not.toHaveBeenCalled()
-  expect(h.getByText('false')).toBeTruthy()
-  // No forgotten row identity prevents following subsequent content.
-  h.grow()
-  expect(h.scrollToEnd).toHaveBeenCalledOnce()
-})
-it('reader navigation takes over a pending disclosure position hold', () => {
-  const h = harness()
-  fireEvent.click(h.toggle)
-  fireEvent.click(h.getByText('navigate'))
-  h.root.scrollTop = 300
-  h.setTop(200)
-  fireEvent.scroll(h.root)
-  act(() => vi.advanceTimersByTime(300))
-  expect(h.root.scrollTop).toBe(300)
-  expect(h.restoreScrollOffset).not.toHaveBeenCalled()
-  expect(h.scrollToEnd).not.toHaveBeenCalled()
-})
-it.each(['hide', 'unmount'] as const)('expires a held acceptance after %s', (action) => {
-  const h = harness()
-  const reveal = h.held()
-  h[action]()
-  act(() => reveal?.())
-  expect(h.scrollToEnd).not.toHaveBeenCalled()
-})
-
-it('settles by geometry when layout frames are suspended past the deadline', () => {
-  vi.stubGlobal(
-    'requestAnimationFrame',
-    vi.fn(() => 999)
-  )
-  const h = harness()
-  fireEvent.click(h.toggle)
-  h.remove()
-  act(() => vi.advanceTimersByTime(251))
-  h.grow()
-  expect(h.scrollToEnd).toHaveBeenCalledOnce()
-})
diff --git a/src/renderer/src/components/native-chat/use-native-chat-disclosure-position.ts b/src/renderer/src/components/native-chat/use-native-chat-disclosure-position.ts
deleted file mode 100644
index 3206401686d8..000000000000
--- a/src/renderer/src/components/native-chat/use-native-chat-disclosure-position.ts
+++ /dev/null
@@ -1,89 +0,0 @@
-import { useCallback, useEffect, useLayoutEffect, useRef } from 'react'
-
-type PositionHold = { element: HTMLElement | null; top: number; offset: number }
-
-/** Preserve the clicked control through measurement, without tracking expanded rows. */
-export function useNativeChatDisclosurePosition({
-  scrollRef,
-  restoreScrollOffset,
-  onStart,
-  onSettle
-}: {
-  scrollRef: React.RefObject<HTMLDivElement | null>
-  restoreScrollOffset: (offset: number) => void
-  onStart: () => void
-  onSettle: () => void
-}) {
-  const holdRef = useRef<PositionHold | null>(null)
-  const targetRef = useRef<HTMLElement | null>(null)
-  const frameRef = useRef<number | null>(null)
-  const timeoutRef = useRef<ReturnType<typeof setTimeout> | null>(null)
-  const cancel = useCallback(() => {
-    if (frameRef.current !== null) {
-      cancelAnimationFrame(frameRef.current)
-    }
-    if (timeoutRef.current !== null) {
-      clearTimeout(timeoutRef.current)
-    }
-    frameRef.current = null
-    timeoutRef.current = null
-    holdRef.current = null
-  }, [])
-  const preserve = useCallback(() => {
-    const hold = holdRef.current
-    const scroller = scrollRef.current
-    if (!hold || !scroller || scroller.clientHeight <= 0) {
-      return
-    }
-    const rect = scroller.getBoundingClientRect()
-    const zoom =
-      scroller.offsetHeight > 0 && rect.height > 0 ? rect.height / scroller.offsetHeight : 1
-    const drift = hold.element?.isConnected
-      ? (hold.element.getBoundingClientRect().top - hold.top) / zoom
-      : hold.offset - scroller.scrollTop
-    if (Math.abs(drift) >= 0.5) {
-      restoreScrollOffset(scroller.scrollTop + drift)
-    }
-    hold.offset = scroller.scrollTop
-  }, [restoreScrollOffset, scrollRef])
-  const settle = useCallback(() => {
-    preserve()
-    cancel()
-    onSettle()
-  }, [cancel, onSettle, preserve])
-  const captureTarget = useCallback((event: React.MouseEvent<HTMLDivElement>) => {
-    const element =
-      event.target instanceof Element
-        ? event.target.closest<HTMLElement>('button, [role="button"], summary')
-        : null
-    targetRef.current = element
-    queueMicrotask(() => {
-      if (targetRef.current === element) {
-        targetRef.current = null
-      }
-    })
-  }, [])
-  const holdPosition = useCallback(() => {
-    cancel()
-    const scroller = scrollRef.current
-    if (!scroller || scroller.clientHeight <= 0) {
-      return
-    }
-    onStart()
-    const element = targetRef.current
-    holdRef.current = {
-      element: element && scroller.contains(element) ? element : null,
-      top: element?.getBoundingClientRect().top ?? 0,
-      offset: scroller.scrollTop
-    }
-    // Two layout frames cover the commit and virtualizer measurement; hidden renderers have a deadline.
-    frameRef.current = requestAnimationFrame(() => {
-      preserve()
-      frameRef.current = requestAnimationFrame(settle)
-    })
-    timeoutRef.current = setTimeout(settle, 250)
-  }, [cancel, onStart, preserve, scrollRef, settle])
-  useLayoutEffect(preserve)
-  useEffect(() => cancel, [cancel])
-  return { holdRef, holdPosition, captureTarget, preserve, cancel }
-}
diff --git a/src/renderer/src/components/native-chat/use-native-chat-reader-opens.test.ts b/src/renderer/src/components/native-chat/use-native-chat-reader-opens.test.ts
deleted file mode 100644
index ac5bf2b3fbaa..000000000000
--- a/src/renderer/src/components/native-chat/use-native-chat-reader-opens.test.ts
+++ /dev/null
@@ -1,77 +0,0 @@
-// @vitest-environment happy-dom
-import { act, renderHook } from '@testing-library/react'
-import { useState } from 'react'
-import { expect, it, vi } from 'vitest'
-import { useNativeChatReaderOpens } from './use-native-chat-reader-opens'
-
-function harness() {
-  const spies = {
-    holdDisclosurePosition: vi.fn(),
-    abortNavigation: vi.fn(),
-    setSectionOpen: vi.fn(),
-    setRosterOpen: vi.fn()
-  }
-  const { result } = renderHook(() => {
-    const [, setExpandedTurnIds] = useState<ReadonlySet<string>>(new Set())
-    return useNativeChatReaderOpens({
-      subagentDisclosure: {
-        setSectionOpen: spies.setSectionOpen,
-        setRosterOpen: spies.setRosterOpen
-      },
-      setExpandedTurnIds,
-      follow: { holdDisclosurePosition: spies.holdDisclosurePosition },
-      abortNavigation: spies.abortNavigation
-    })
-  })
-  const reacted = (): number => spies.holdDisclosurePosition.mock.calls.length
-  return { result, spies, reacted }
-}
-
-// Each way a reader opens a row reports it under its own identity and abandons a history jump still paging.
-it.each([
-  [
-    'a disclosure',
-    'run:1',
-    (opens: ReturnType<typeof useNativeChatReaderOpens>) =>
-      opens.disclosures.onToggle?.('run:1', true)
-  ],
-  [
-    'a folded turn',
-    'turn:turn-1',
-    (opens: ReturnType<typeof useNativeChatReaderOpens>) => opens.toggleExpandedTurn('turn-1')
-  ],
-  [
-    'a subagent section',
-    'section:a',
-    (opens: ReturnType<typeof useNativeChatReaderOpens>) =>
-      opens.subagentDisclosure.setSectionOpen('a', true)
-  ],
-  [
-    'a subagent roster',
-    'roster:r',
-    (opens: ReturnType<typeof useNativeChatReaderOpens>) =>
-      opens.subagentDisclosure.setRosterOpen('r', true)
-  ]
-])('reacts to the reader opening %s', (_kind, _row, open) => {
-  const { result, spies } = harness()
-  act(() => open(result.current))
-  expect(spies.holdDisclosurePosition).toHaveBeenCalledOnce()
-  expect(spies.abortNavigation).toHaveBeenCalledOnce()
-})
-
-it('bounds both opening and closing layout transactions', () => {
-  const { result, spies, reacted } = harness()
-  act(() => result.current.toggleExpandedTurn('turn-1'))
-  expect(reacted()).toBe(1)
-
-  act(() => result.current.toggleExpandedTurn('turn-1'))
-  act(() => result.current.subagentDisclosure.setSectionOpen('a', false))
-  act(() => result.current.subagentDisclosure.setRosterOpen('r', false))
-
-  act(() => result.current.disclosures.onToggle?.('run:1', false))
-
-  expect(reacted()).toBe(5)
-  expect(spies.abortNavigation).toHaveBeenCalledTimes(5)
-  expect(spies.setSectionOpen).toHaveBeenCalledWith('a', false)
-  expect(spies.setRosterOpen).toHaveBeenCalledWith('r', false)
-})
diff --git a/src/renderer/src/components/native-chat/use-native-chat-reader-opens.ts b/src/renderer/src/components/native-chat/use-native-chat-reader-opens.ts
deleted file mode 100644
index 56060e5ece1a..000000000000
--- a/src/renderer/src/components/native-chat/use-native-chat-reader-opens.ts
+++ /dev/null
@@ -1,60 +0,0 @@
-import { useCallback, useMemo, type Dispatch, type SetStateAction } from 'react'
-import {
-  useNativeChatDisclosures,
-  type NativeChatDisclosureStore
-} from './native-chat-disclosure-store'
-import { toggleNativeChatExpandedKey } from './native-chat-expanded-keys'
-import type { NativeChatSubagentDisclosure } from './native-chat-subagent-sections'
-import type { NativeChatTranscriptScroll } from './use-native-chat-transcript-scroll'
-
-export function useNativeChatReaderOpens({
-  subagentDisclosure,
-  setExpandedTurnIds,
-  follow,
-  abortNavigation
-}: {
-  subagentDisclosure: NativeChatSubagentDisclosure
-  setExpandedTurnIds: Dispatch<SetStateAction<ReadonlySet<string>>>
-  follow: Pick<NativeChatTranscriptScroll, 'holdDisclosurePosition'>
-  abortNavigation: () => void
-}): {
-  disclosures: NativeChatDisclosureStore
-  subagentDisclosure: NativeChatSubagentDisclosure
-  toggleExpandedTurn: (turnKey: string) => void
-} {
-  const disclosures = useNativeChatDisclosures()
-  const { holdDisclosurePosition } = follow
-  const readerToggled = useCallback(() => {
-    abortNavigation()
-    holdDisclosurePosition()
-  }, [abortNavigation, holdDisclosurePosition])
-  const readerDisclosures = useMemo(
-    () => ({ ...disclosures, onToggle: readerToggled }),
-    [disclosures, readerToggled]
-  )
-  const readerSubagentDisclosure = useMemo<NativeChatSubagentDisclosure>(
-    () => ({
-      setSectionOpen: (agentId, open) => {
-        readerToggled()
-        subagentDisclosure.setSectionOpen(agentId, open)
-      },
-      setRosterOpen: (rosterRowId, open) => {
-        readerToggled()
-        subagentDisclosure.setRosterOpen(rosterRowId, open)
-      }
-    }),
-    [readerToggled, subagentDisclosure]
-  )
-  const toggleExpandedTurn = useCallback(
-    (turnKey: string) => {
-      readerToggled()
-      setExpandedTurnIds((current) => toggleNativeChatExpandedKey(current, turnKey))
-    },
-    [readerToggled, setExpandedTurnIds]
-  )
-  return {
-    disclosures: readerDisclosures,
-    subagentDisclosure: readerSubagentDisclosure,
-    toggleExpandedTurn
-  }
-}
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
index 786d9c0e1f4a..974391df225a 100644
--- 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
@@ -1,11 +1,19 @@
 // How a chat pane tells its transcript that the reader just sent something.
 
-import { useCallback, useImperativeHandle, useLayoutEffect, useMemo, useRef } from 'react'
+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, cancelPending, cancelAsk, cancel }: NativeChatInteractiveSend,
+  {
+    sendAnswer,
+    sendRaw,
+    sendRawVerified,
+    cancelPending,
+    cancelAsk,
+    cancel
+  }: NativeChatInteractiveSend,
   targetPtyId: string | null,
   revealLatest: () => void
 ): NativeChatInteractiveSend {
@@ -18,87 +26,56 @@ export function useNativeChatInteractiveSendReveal(
         }
         return sendAnswer(prompt, selections, onDeliverySettled)
       },
-      sendRaw: (raw) => {
+      sendRaw,
+      sendRawVerified: (raw) => {
         if (targetPtyId) {
           revealLatest()
         }
-        sendRaw(raw)
+        return sendRawVerified(raw)
       },
       cancelPending,
       cancelAsk,
       cancel
     }),
-    [cancel, cancelAsk, cancelPending, revealLatest, sendAnswer, sendRaw, targetPtyId]
+    [
+      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
-  /** For a send whose outcome arrives later: a reveal that lapses if the reader acts first. */
-  holdRevealLatest: () => () => void
 }
 
-export function useNativeChatRevealLatest(
-  scopeKey = '',
-  isVisible = true
-): {
+/** This pane's own transcript; an unmounted pane's reveal reaches nothing. */
+export function useNativeChatRevealLatest(): {
   messageListRef: React.RefObject<NativeChatMessageListHandle | null>
   revealLatest: () => void
-  holdRevealLatest: () => () => void
 } {
   const messageListRef = useRef<NativeChatMessageListHandle>(null)
-  const generationRef = useRef(0)
-  const previousScopeRef = useRef(scopeKey)
-  const visibleRef = useRef(isVisible)
-  useLayoutEffect(() => {
-    if (previousScopeRef.current !== scopeKey || !isVisible) {
-      generationRef.current += 1
-    }
-    previousScopeRef.current = scopeKey
-    visibleRef.current = isVisible
-    return () => {
-      generationRef.current += 1
-    }
-  }, [isVisible, scopeKey])
   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)
     }
   }, [])
-  const holdRevealLatest = useCallback(() => {
-    const origin = messageListRef.current
-    let reveal: (() => void) | undefined
-    try {
-      reveal = origin?.holdRevealLatest()
-    } catch (error) {
-      console.error('Could not prepare chat navigation', error)
-    }
-    const generation = generationRef.current
-    return () => {
-      if (visibleRef.current && generationRef.current === generation) {
-        try {
-          reveal?.()
-        } catch (error) {
-          console.error('Could not reveal the submitted chat content', error)
-        }
-      }
-    }
-  }, [])
-  return { messageListRef, revealLatest, holdRevealLatest }
+  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,
-  untilReaderActs: (act: () => void) => () => void
+  revealLatest: () => void
 ): void {
-  useImperativeHandle(
-    ref,
-    () => ({ revealLatest, holdRevealLatest: () => untilReaderActs(revealLatest) }),
-    [revealLatest, untilReaderActs]
-  )
+  useImperativeHandle(ref, () => ({ revealLatest }), [revealLatest])
 }
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 37e1007f46ba..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
@@ -19,19 +19,10 @@ export function useNativeChatSessionOptionCommand(args: {
   disabled: boolean
   onSlashCommand?: (command: string) => void
   onSubmitted?: () => void
-  holdRevealLatest?: () => () => void
   resolveTarget: () => NativeChatResolvedTarget | null
   setHistory: Dispatch<SetStateAction<HistoryState>>
 }): { dispatch: NativeChatSessionOptionDispatchCommand; isDispatching: boolean } {
-  const {
-    agent,
-    disabled,
-    onSlashCommand,
-    onSubmitted,
-    holdRevealLatest,
-    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>())
@@ -64,7 +55,7 @@ export function useNativeChatSessionOptionCommand(args: {
       if (!target || disabled) {
         throw new Error('No live terminal is available.')
       }
-      const reveal = holdRevealLatest?.() ?? onSubmitted
+      onSubmitted?.()
       const sendController = new AbortController()
       activeSendsRef.current.add(sendController)
       // Why: block composer chat sends for the whole drain+observe+verify window.
@@ -123,7 +114,6 @@ export function useNativeChatSessionOptionCommand(args: {
           agent,
           runtime: nativeChatComposerTargetIsRemote(target.ptyId) ? 'remote' : 'local'
         })
-        reveal?.()
         setHistory((previous) => pushHistory(previous, command))
         const outcome = observer ? await observer.result : undefined
         return { outcome }
@@ -136,7 +126,7 @@ export function useNativeChatSessionOptionCommand(args: {
         }
       }
     },
-    [agent, disabled, onSlashCommand, onSubmitted, holdRevealLatest, 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 dc1421cb932e..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
@@ -100,13 +100,14 @@ describe('attachment guard follows what the host claims', () => {
   })
 })
 
-// The pane brings the latest into view on this: a command the chat ran itself counts, a refusal does not.
-describe('reports only an accepted send as submitted', () => {
-  it('reports a host-run command, then not a message the transport refused', async () => {
+// 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', [])
-    await vi.waitFor(() => expect(onSubmitted).toHaveBeenCalledOnce())
+    expect(onSubmitted).toHaveBeenCalledOnce()
 
     vi.mocked(structuredTransport.send).mockReturnValue(false)
     send('hello', [])
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 0f954c50326e..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,7 +64,10 @@ export function useNativeChatStructuredComposerSend({
         structuredTransport.onError('Remove attachments before using a chat-session command.')
         return
       }
-      const reveal = structuredTransport.holdRevealLatest?.() ?? structuredTransport.onSubmitted
+      // 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, revealsTranscript }) => {
@@ -73,7 +77,7 @@ export function useNativeChatStructuredComposerSend({
           }
           emitNativeChatMessageSent({ agent, runtime: structuredTransport.runtime })
           if (revealsTranscript) {
-            reveal?.()
+            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,
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 b2d464f29095..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
@@ -35,20 +35,17 @@ function TranscriptHarness({
     reconcileReaderScroll
   })
   const input = useNativeChatReaderScrollInput(scrollRef, {
-    onReaderScroll: transcript.readerActs,
+    onReaderScroll: () => {},
     onLeaveEnd: transcript.readerLeavesEnd
   })
   return (
     <div
       {...input.scrollerProps}
-      onClickCapture={transcript.captureDisclosureTarget}
       ref={scrollRef}
       data-testid="scroll"
       onScroll={transcript.onScroll}
     >
       <div ref={contentRef} />
-      <button onClick={() => transcript.holdDisclosurePosition()}>open</button>
-      <button onClick={() => transcript.holdDisclosurePosition()}>close</button>
     </div>
   )
 }
@@ -225,33 +222,27 @@ describe('native chat transcript follow', () => {
     expect(scrollToEnd).toHaveBeenCalled()
   })
 
-  it('does not force a distant reader to the tail on the last close', () => {
+  // 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 view = render(
-      <TranscriptHarness isVisible restoreScrollOffset={vi.fn()} scrollToEnd={scrollToEnd} />
-    )
-    Object.defineProperties(view.getByTestId('scroll'), {
+    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: () => 1_400 },
+      scrollHeight: { configurable: true, get: () => scrollHeight },
       scrollTop: { configurable: true, get: () => scrollTop, set: (value) => (scrollTop = value) }
     })
 
-    fireEvent.click(view.getByText('open'))
+    scrollHeight = 700
+    scrollTop = 600
+    scrollHeight = 900
+    fireEvent.scroll(scrollElement)
     scrollToEnd.mockClear()
-    view.rerender(
-      <TranscriptHarness
-        isVisible
-        restoreScrollOffset={vi.fn()}
-        scrollToEnd={scrollToEnd}
-        itemCount={101}
-      />
-    )
-    // Anti-vacuous: opening stopped the following, 400px from the end.
-    expect(scrollToEnd).not.toHaveBeenCalled()
-
-    fireEvent.click(view.getByText('close'))
+    view.rerender(<TranscriptHarness {...props} itemCount={101} />)
 
-    expect(scrollToEnd).not.toHaveBeenCalled()
+    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 afdbcfdb1a20..b2be67a4214a 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
@@ -1,3 +1,17 @@
+// The transcript's scroll behaviour: staying pinned to the bottom while a turn
+// streams, offering the way back when the reader has left, and aligning a row or
+// a card to the top.
+//
+// Split from the list because windowing changed what these have to be careful
+// about, not what they decide: rows resolving their measured height move the
+// content constantly, so "the content changed" and "the reader scrolled" stopped
+// 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. 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,
   useEffect,
@@ -14,7 +28,6 @@ import {
   shouldShowJumpToLatest,
   type ScrollGeometry
 } from './native-chat-autoscroll'
-import { useNativeChatDisclosurePosition } from './use-native-chat-disclosure-position'
 
 function geometryOf(element: HTMLElement): ScrollGeometry {
   return {
@@ -32,12 +45,10 @@ export type NativeChatTranscriptScroll = {
   showJump: boolean
   onScroll: UIEventHandler<HTMLDivElement>
   scrollToBottom: () => 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
-  readerActs: () => void
-  holdDisclosurePosition: () => void
-  captureDisclosureTarget: React.MouseEventHandler<HTMLDivElement>
-  untilReaderActs: (act: () => void) => () => void
 }
 
 export function useNativeChatTranscriptScroll({
@@ -57,6 +68,7 @@ export function useNativeChatTranscriptScroll({
   contentRef: React.RefObject<HTMLDivElement | null>
   itemCount: number
   isWorking: boolean
+  /** Whether the list draws a row after the transcript (live activity or a wait). */
   showsTailRow: boolean
   isVisible: boolean
   alignToViewportTop: (element: HTMLElement) => void
@@ -71,8 +83,6 @@ export function useNativeChatTranscriptScroll({
   const isVisibleRef = useRef(isVisible)
   const previousIsVisibleRef = useRef(isVisible)
   const previousDistanceFromEndRef = useRef(Number.POSITIVE_INFINITY)
-  const readerGenerationRef = useRef(0)
-  const mountedRef = useRef(true)
 
   const syncScrollState = useCallback((): ScrollGeometry | null => {
     const element = scrollRef.current
@@ -85,36 +95,7 @@ export function useNativeChatTranscriptScroll({
     return geometry
   }, [scrollRef])
 
-  const beginDisclosure = useCallback(() => {
-    readerGenerationRef.current += 1
-    followingRef.current = false
-    reconcileReaderScroll(true)
-    syncScrollState()
-  }, [reconcileReaderScroll, syncScrollState])
-  const settleDisclosure = useCallback(() => {
-    const element = scrollRef.current
-    if (isVisibleRef.current && hasMeasurableViewport(element)) {
-      followingRef.current = isNearBottom(geometryOf(element), NATIVE_CHAT_FOLLOW_REARM_PX)
-      syncScrollState()
-    }
-  }, [scrollRef, syncScrollState])
-  const disclosure = useNativeChatDisclosurePosition({
-    scrollRef,
-    restoreScrollOffset,
-    onStart: beginDisclosure,
-    onSettle: settleDisclosure
-  })
-  const { cancel: cancelDisclosure, holdRef, preserve: preserveDisclosure } = disclosure
-
-  const readerActs = useCallback(() => {
-    readerGenerationRef.current += 1
-    if (holdRef.current) {
-      settleDisclosure()
-    }
-    cancelDisclosure()
-  }, [cancelDisclosure, holdRef, settleDisclosure])
   const readerLeavesEnd = useCallback(() => {
-    readerActs()
     followingRef.current = false
     const element = scrollRef.current
     if (element) {
@@ -123,7 +104,7 @@ export function useNativeChatTranscriptScroll({
     // Replace a pending virtualizer target before the browser applies the gesture.
     reconcileReaderScroll(true)
     syncScrollState()
-  }, [readerActs, reconcileReaderScroll, scrollRef, syncScrollState])
+  }, [reconcileReaderScroll, scrollRef, syncScrollState])
 
   const onScroll = useCallback<UIEventHandler<HTMLDivElement>>(
     (event) => {
@@ -132,65 +113,48 @@ export function useNativeChatTranscriptScroll({
         return
       }
       const geometry = geometryOf(element)
-      const programmatic = consumeProgrammaticScroll(event.nativeEvent)
-      if (!holdRef.current) {
-        followingRef.current = nextFollowingEnd({
-          following: followingRef.current,
-          programmatic,
-          geometry,
-          previousDistanceFromEnd: previousDistanceFromEndRef.current
-        })
-        reconcileReaderScroll(false)
-      }
+      followingRef.current = nextFollowingEnd({
+        following: followingRef.current,
+        programmatic: consumeProgrammaticScroll(event.nativeEvent),
+        geometry,
+        previousDistanceFromEnd: previousDistanceFromEndRef.current
+      })
+      reconcileReaderScroll(false)
       previousDistanceFromEndRef.current = distanceFromBottom(geometry)
       syncScrollState()
     },
-    [consumeProgrammaticScroll, holdRef, reconcileReaderScroll, scrollRef, syncScrollState]
+    [consumeProgrammaticScroll, reconcileReaderScroll, scrollRef, syncScrollState]
   )
 
   const scrollToEndWhenMeasurable = useCallback(() => {
-    if (isVisibleRef.current && !holdRef.current && hasMeasurableViewport(scrollRef.current)) {
+    if (isVisibleRef.current && hasMeasurableViewport(scrollRef.current)) {
       scrollToEnd()
     }
-  }, [holdRef, scrollRef, scrollToEnd])
+  }, [scrollRef, scrollToEnd])
+
   const scrollToBottom = useCallback(() => {
-    readerGenerationRef.current += 1
-    cancelDisclosure()
+    // 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)
-  }, [cancelDisclosure, scrollToEndWhenMeasurable])
+  }, [scrollToEndWhenMeasurable])
+
   const scrollMessageToTop = useCallback(
     (element: HTMLElement) => {
-      readerActs()
       followingRef.current = false
       alignToViewportTop(element)
     },
-    [alignToViewportTop, readerActs]
+    [alignToViewportTop]
   )
-  const untilReaderActs = useCallback((act: () => void) => {
-    const generation = readerGenerationRef.current
-    let consumed = false
-    return () => {
-      if (
-        !consumed &&
-        mountedRef.current &&
-        isVisibleRef.current &&
-        readerGenerationRef.current === generation
-      ) {
-        consumed = true
-        act()
-      }
-    }
-  }, [])
 
   useLayoutEffect(() => {
     const revealed = isVisible && !previousIsVisibleRef.current
     isVisibleRef.current = isVisible
     previousIsVisibleRef.current = isVisible
     if (!isVisible) {
-      readerGenerationRef.current += 1
-      cancelDisclosure()
       return
     }
     if (!followingRef.current) {
@@ -198,32 +162,27 @@ export function useNativeChatTranscriptScroll({
         if (detachedScrollTopRef.current !== null) {
           restoreScrollOffset(detachedScrollTopRef.current)
         }
-        settleDisclosure()
-      } else {
-        syncScrollState()
+        // 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()
   }, [
-    cancelDisclosure,
     isVisible,
     itemCount,
     isWorking,
     restoreScrollOffset,
+    scrollRef,
     showsTailRow,
     scrollToEndWhenMeasurable,
-    settleDisclosure,
     syncScrollState
   ])
 
-  useLayoutEffect(() => {
-    mountedRef.current = true
-    return () => {
-      mountedRef.current = false
-      readerGenerationRef.current += 1
-    }
-  }, [])
   useEffect(() => {
     const element = scrollRef.current
     if (!element || typeof ResizeObserver === 'undefined') {
@@ -233,36 +192,20 @@ export function useNativeChatTranscriptScroll({
       if (!isVisibleRef.current) {
         return
       }
-      if (holdRef.current) {
-        preserveDisclosure()
-      } else if (followingRef.current) {
+      // Growth, an opened row included, keeps a following reader at the end.
+      if (followingRef.current) {
         scrollToEndWhenMeasurable()
       }
       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.
     observer.observe(element)
     if (contentRef.current) {
       observer.observe(contentRef.current)
     }
     return () => observer.disconnect()
-  }, [
-    contentRef,
-    holdRef,
-    preserveDisclosure,
-    scrollRef,
-    scrollToEndWhenMeasurable,
-    syncScrollState
-  ])
+  }, [contentRef, scrollRef, scrollToEndWhenMeasurable, syncScrollState])
 
-  return {
-    showJump,
-    onScroll,
-    scrollToBottom,
-    scrollMessageToTop,
-    readerLeavesEnd,
-    readerActs,
-    holdDisclosurePosition: disclosure.holdPosition,
-    captureDisclosureTarget: disclosure.captureTarget,
-    untilReaderActs
-  }
+  return { showJump, onScroll, scrollToBottom, scrollMessageToTop, readerLeavesEnd }
 }
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 46f2f482e523..d657a9bb9211 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,10 +78,13 @@ 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
 }) {
   const {
     composerScopeKey,
     fence,
+    isWorking = false,
     journalItems,
     queueDelivery = NO_QUEUE_DELIVERY,
     queuedMessageIds,
@@ -265,8 +269,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
       }
@@ -276,9 +284,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
     },
-    [sessionId]
+    [isWorking, queueDelivery, queuedMessageIds, 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 3f6bbbd4e27d..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
@@ -173,11 +173,7 @@ function renderRevealingController(sessionId = 'session-1', fence: number | null
         consumeProgrammaticScroll: () => false,
         reconcileReaderScroll: vi.fn()
       })
-      useNativeChatMessageListHandle(
-        submits.messageListRef,
-        scroll.scrollToBottom,
-        scroll.untilReaderActs
-      )
+      useNativeChatMessageListHandle(submits.messageListRef, scroll.scrollToBottom)
       return { submits, scroll, scrollToEnd }
     },
     { initialProps: { isVisible: true } }
@@ -223,7 +219,7 @@ describe('Resume transcript navigation through the real mutation and queue contr
     }
   )
 
-  it('reveals only the originating reader after success and ignores a duplicate press', async () => {
+  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()
@@ -235,9 +231,6 @@ describe('Resume transcript navigation through the real mutation and queue contr
     })
     expect(origin.result.current.scrollToEnd).not.toHaveBeenCalled()
     expect(mocks.call).toHaveBeenCalledTimes(1)
-    // A different current handle must not retarget the completion captured at press.
-    origin.result.current.submits.messageListRef.current =
-      other.result.current.submits.messageListRef.current
     await act(async () => {
       answer.resolve(resumedResult())
       expect(await pending).toBe(true)
@@ -246,32 +239,29 @@ describe('Resume transcript navigation through the real mutation and queue contr
     expect(other.result.current.scrollToEnd).not.toHaveBeenCalled()
   })
 
-  it.each(['scroll', 'hide', 'session', 'unmount'] as const)(
-    'a newer %s invalidates an acknowledged Resume reveal',
+  // 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 === 'scroll') {
-        act(() => origin.result.current.scroll.readerLeavesEnd())
-      } else if (action === 'hide') {
+      if (action === 'hide') {
         origin.rerender({ isVisible: false })
-        origin.rerender({ isVisible: true })
       } else {
         origin.unmount()
       }
-      const replacement = action === 'session' ? renderRevealingController('session-2') : null
-      replacement?.result.current.scrollToEnd.mockClear()
       await act(async () => {
         answer.resolve(resumedResult())
         await pending
       })
-      expect(scrollToEnd).not.toHaveBeenCalled()
-      if (replacement) {
-        expect(replacement.result.current.scrollToEnd).not.toHaveBeenCalled()
+      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-gating.test.tsx b/src/renderer/src/components/native-chat/use-structured-agent-session.queued-gating.test.tsx
index 5559068af7a3..bef56bf7f81e 100644
--- a/src/renderer/src/components/native-chat/use-structured-agent-session.queued-gating.test.tsx
+++ b/src/renderer/src/components/native-chat/use-structured-agent-session.queued-gating.test.tsx
@@ -55,9 +55,7 @@ vi.mock('./use-structured-agent-session-outbox', () => ({
     return {
       outbox: outboxEntries,
       error: null,
-      send: (text: string, attachments: readonly { path: string; previewUri: string }[] = []) =>
-        Boolean(text.trim() || attachments.length) &&
-        appendStructuredAgentSessionOutboxMessage('session-1', text, attachments) !== null,
+      send: vi.fn(),
       retry: vi.fn(),
       withdrawUnsent: vi.fn()
     }
@@ -75,7 +73,6 @@ import {
   clearNativeChatDraftCacheForTests,
   readNativeChatDraftCache
 } from './native-chat-draft-cache'
-import { appendStructuredAgentSessionOutboxMessage } from './structured-agent-session-outbox-storage'
 import { useStructuredAgentSession } from './use-structured-agent-session'
 
 const RUNNING_TURN: AgentJournalRenderItem = {
@@ -386,31 +383,3 @@ describe('against a host without the capability', () => {
     ).toHaveLength(0)
   })
 })
-
-it.each([
-  ['queued text', true, true, true, [], 'queued'],
-  ['setting off', true, false, true, [], true],
-  ['idle turn', true, true, false, [], true],
-  ['older host', false, true, true, [], true],
-  ['image send', true, true, true, [{ path: '/tmp/image.png', previewUri: '/tmp/image.png' }], true]
-] as const)(
-  'composer admission derives navigation from its visible projection: %s',
-  (_name, capable, enabled, working, attachments, expected) => {
-    setLocalRuntimeCapabilitiesForTests(
-      capable ? [AGENT_SESSION_QUEUED_MESSAGES_RUNTIME_CAPABILITY] : []
-    )
-    items = working ? [RUNNING_TURN] : []
-    const hook = render(enabled)
-    let admission: unknown
-    act(() => {
-      admission = hook.result.current.sendFromComposer('follow up', attachments)
-    })
-    expect(admission).toBe(expected)
-  }
-)
-
-it('does not report a visible composer send when admission is refused', () => {
-  setLocalRuntimeCapabilitiesForTests([AGENT_SESSION_QUEUED_MESSAGES_RUNTIME_CAPABILITY])
-  const hook = render()
-  expect(hook.result.current.sendFromComposer('')).toBe(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 79702f6bc6e3..cae072f1417e 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
@@ -35,7 +35,6 @@ import { useStructuredAgentSessionThreadGoal } from './use-structured-agent-sess
 import { useStructuredAgentSessionContextUsage } from './use-structured-agent-session-context-usage'
 import { useStructuredAgentSessionRailOutline } from './use-structured-agent-session-rail-outline'
 import { useStructuredAgentSessionQueuedMessages } from './use-structured-agent-session-queued-messages'
-import { getStructuredAgentSessionOutbox } from './structured-agent-session-outbox-storage'
 import { outboxOutsideQueuedCards } from './structured-agent-session-queued-cards'
 import { structuredAgentSessionStartFailureFacts } from './structured-agent-session-delivery-notices'
 import { hostStatesTurnScopes } from '../../../../shared/native-chat-turn-membership'
@@ -139,7 +138,8 @@ export function useStructuredAgentSession(args: {
     journalItems: transportState.journalItems,
     composerScopeKey,
     queueDelivery,
-    queuedMessageIds
+    queuedMessageIds,
+    isWorking: transportState.isWorking
   })
 
   const threadGoal = useStructuredAgentSessionThreadGoal({
@@ -215,12 +215,6 @@ export function useStructuredAgentSession(args: {
     composerScopeKey,
     mutate
   })
-  // A message typed during a command queues behind it on the host.
-  const send = (...input: Parameters<typeof outboxController.send>): boolean =>
-    // Legacy: an older host refuses sends while a command runs; removable once those hosts age out.
-    (!commandPending.current || hostStatesTurnScopes(transportState.journalItems)) &&
-    rewind.admitsSend() &&
-    outboxController.send(...input)
   return {
     epoch: state.epoch,
     rewind,
@@ -259,23 +253,12 @@ export function useStructuredAgentSession(args: {
     failedHere: outboxController.failedHere,
     /** The journal's rows for sent messages, which carry a rejected message's whole fact. */
     submissions: transportState.submissions,
-    /** The host's queued cards, which hold their own rejected hand-offs. */
-    queuedMessageIds,
-    send,
-    /** Navigation follows the same projection that decides between a bubble and a queued card. */
-    sendFromComposer: (...input: Parameters<typeof outboxController.send>): boolean | 'queued' => {
-      if (!send(...input)) {
-        return false
-      }
-      const current = getStructuredAgentSessionOutbox(sessionId)
-      const admitted = current.at(-1)
-      return admitted &&
-        !outboxOutsideQueuedCards(current, queuedMessageIds, isWorking, queueDelivery).includes(
-          admitted
-        )
-        ? 'queued'
-        : true
-    },
+    // A message typed during a command queues behind it on the host.
+    send: (...input: Parameters<typeof outboxController.send>) =>
+      // Legacy: an older host refuses sends while a command runs; removable once those hosts age out.
+      (!commandPending.current || hostStatesTurnScopes(transportState.journalItems)) &&
+      rewind.admitsSend() &&
+      outboxController.send(...input),
     retry: rewind.unlessBlocked(outboxController.retry),
     isWorking: transportState.isWorking,
     workingStartedAt: transportState.turnTiming.workingStartedAt,
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
index be241f078d07..fa169df9f85d 100644
--- 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
@@ -9,6 +9,7 @@ it('reveals before Retry, but waits for a successful queue Resume', async () =>
     respond: vi.fn(async () => null),
     retry: vi.fn(() => order.push('retry')),
     queuedMessages: {
+      queueCapable: true,
       cards: [],
       pause: null,
       resuming: false,
@@ -24,10 +25,7 @@ it('reveals before Retry, but waits for a successful queue Resume', async () =>
   }
   const retryLaunch = (): number => order.push('launch')
   const { result } = renderHook(() => useStructuredNativeChatSubmitReveal(controller, retryLaunch))
-  result.current.messageListRef.current = {
-    revealLatest: () => order.push('reveal'),
-    holdRevealLatest: () => () => order.push('reveal')
-  }
+  result.current.messageListRef.current = { revealLatest: () => order.push('reveal') }
 
   act(() => result.current.retryDelivery('client-1'))
   act(() => result.current.retryLaunch())
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
index 710a6b6e73b0..6b93ad94c51d 100644
--- 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
@@ -1,5 +1,5 @@
-// Local actions reveal this pane. Answers and Resume wait for host acceptance,
-// preserving any newer reader navigation; passive host delivery never reveals it.
+// 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 {
@@ -17,15 +17,14 @@ export function useStructuredNativeChatSubmitReveal(
   retryLaunch: () => void
 ): {
   messageListRef: React.RefObject<NativeChatMessageListHandle | null>
-  /** For the composer's transport, which knows when a send was accepted. */
+  /** For the composer, which reveals as it sends. */
   revealLatest: () => void
-  holdRevealLatest: () => () => void
   retryDelivery: (clientMessageId: string) => void
   retryLaunch: () => void
   respond: StructuredController['respond']
   queuedMessages: StructuredAgentSessionQueuedMessagesController
 } {
-  const { messageListRef, revealLatest, holdRevealLatest } = useNativeChatRevealLatest()
+  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)
@@ -44,17 +43,11 @@ export function useStructuredNativeChatSubmitReveal(
     retryLaunch()
   }, [retryLaunch, revealLatest])
   const revealingRespond = useCallback<StructuredController['respond']>(
-    async (...args) => {
-      // Held from the click: a reader who scrolls away while the host decides stays there.
-      const reveal = holdRevealLatest()
-      const result = await respond(...args)
-      // Null is a refused or failed answer: nothing was sent, so the reader stays put.
-      if (result !== null) {
-        reveal()
-      }
-      return result
+    (...args) => {
+      revealLatest()
+      return respond(...args)
     },
-    [holdRevealLatest, respond]
+    [respond, revealLatest]
   )
   const revealingQueue = useMemo<StructuredAgentSessionQueuedMessagesController>(
     () => ({
@@ -63,11 +56,11 @@ export function useStructuredNativeChatSubmitReveal(
         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 reveal = holdRevealLatest()
         const resumed = await queuedMessages.resume()
         if (resumed) {
-          reveal()
+          revealLatest()
         }
         return resumed
       },
@@ -79,12 +72,11 @@ export function useStructuredNativeChatSubmitReveal(
         return steered
       }
     }),
-    [holdRevealLatest, queuedMessages, revealLatest]
+    [queuedMessages, revealLatest]
   )
   return {
     messageListRef,
     revealLatest,
-    holdRevealLatest,
     retryDelivery,
     retryLaunch: revealingRetryLaunch,
     respond: revealingRespond,
diff --git a/src/shared/structured-agent-session-composer.ts b/src/shared/structured-agent-session-composer.ts
index fa4d47248254..0673d62dd26b 100644
--- a/src/shared/structured-agent-session-composer.ts
+++ b/src/shared/structured-agent-session-composer.ts
@@ -43,8 +43,6 @@ export type StructuredAgentSessionComposerOptions = {
 }
 
 export type StructuredAgentSessionCommandOutcome = {
-  /** Picker actions produce no transcript content. This is local dispatch policy, never wire state. */
-  revealsTranscript?: boolean
   handled: boolean
   accepted: boolean
   error: string | null
@@ -112,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)
@@ -184,7 +192,6 @@ export async function dispatchStructuredAgentSessionComposerCommand(
     return {
       handled: true,
       accepted: opened,
-      revealsTranscript: false,
       error: opened ? null : `Could not open the ${command.name} picker.`
     }
   }

From d862a821692aedc0bf614d9023b48766f5aef5f0 Mon Sep 17 00:00:00 2001
From: Brennan Benson <79079362+brennanb2025@users.noreply.github.com>
Date: Tue, 6 Oct 2026 12:51:47 -0700
Subject: [PATCH 10/14] chore: leave an unrelated fixture as main has it

---
 .../runtime/__fixtures__/claude-ready-task-wakeup.meta.json   | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/main/runtime/__fixtures__/claude-ready-task-wakeup.meta.json b/src/main/runtime/__fixtures__/claude-ready-task-wakeup.meta.json
index 2a2bfcc398c5..5d0c9b7bfc8f 100644
--- a/src/main/runtime/__fixtures__/claude-ready-task-wakeup.meta.json
+++ b/src/main/runtime/__fixtures__/claude-ready-task-wakeup.meta.json
@@ -1,7 +1,9 @@
 {
   "capturedAt": "2026-10-06T04:06:33.762Z",
   "platform": "darwin",
-  "command": ["claude"],
+  "command": [
+    "claude"
+  ],
   "cols": 120,
   "rows": 40,
   "note": "Claude Code 2.1.291; native ready-title capture in existing workspace; no prompt submitted",

From 5667d907622974ccbb680de83938201f17c6bc54 Mon Sep 17 00:00:00 2001
From: Brennan Benson <79079362+brennanb2025@users.noreply.github.com>
Date: Tue, 6 Oct 2026 12:54:18 -0700
Subject: [PATCH 11/14] refactor(native-chat): share the terminal send paths'
 common options in the composer

---
 .../native-chat/NativeChatComposer.tsx        | 42 +++++++------------
 1 file changed, 16 insertions(+), 26 deletions(-)

diff --git a/src/renderer/src/components/native-chat/NativeChatComposer.tsx b/src/renderer/src/components/native-chat/NativeChatComposer.tsx
index ed3890595de3..e4e9e97659a5 100644
--- a/src/renderer/src/components/native-chat/NativeChatComposer.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatComposer.tsx
@@ -257,24 +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,
@@ -282,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,
@@ -306,22 +310,8 @@ const NativeChatComposerPane = forwardRef<NativeChatComposerHandle, NativeChatCo
     })
 
     const dispatchPtyPickerCommand = useNativeChatPickerCommandDispatch({
-      agent,
-      disabled,
-      isDispatchingSessionOption,
-      resolveTarget,
-      onSlashCommand,
-      onSubmitted,
-      answerCommandLocally,
-      sessionOptionsSurface: ptySessionOptionsSurface,
-      trackPendingSend,
-      setHistory,
-      setDraft,
-      setCaret,
-      setActiveSuggestion,
-      clearSkillOrigin,
-      clearImageAttachments,
-      setNotice
+      ...ptyCommandRouting,
+      setActiveSuggestion
     })
     const dispatchPickerCommand = useCallback(
       (command: Parameters<typeof dispatchPtyPickerCommand>[0]) =>

From 0b033265ac610c50bd501b5cdaf9e88ba652408b Mon Sep 17 00:00:00 2001
From: Brennan Benson <79079362+brennanb2025@users.noreply.github.com>
Date: Tue, 6 Oct 2026 12:56:12 -0700
Subject: [PATCH 12/14] test(native-chat): drop a field the main merge declared
 twice

---
 .../native-chat/NativeChatStructuredSession.test-harness.tsx     | 1 -
 1 file changed, 1 deletion(-)

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 62b04663408a..50fb40590945 100644
--- a/src/renderer/src/components/native-chat/NativeChatStructuredSession.test-harness.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatStructuredSession.test-harness.tsx
@@ -146,7 +146,6 @@ export function createStructuredSessionMocks() {
       afterStop?: 'queue' | 'send'
       steerQueued?: () => boolean
       onStop?: () => void
-      steerQueued?: () => boolean
     }>(),
     approvalCardProps: initialApprovalCardProps,
     questionCardProps: null as NativeChatQuestionCardProps | null,

From a699e539863bcfce22fbdfe0afa78bfd29e4cb8d Mon Sep 17 00:00:00 2001
From: Brennan Benson <79079362+brennanb2025@users.noreply.github.com>
Date: Tue, 6 Oct 2026 12:57:18 -0700
Subject: [PATCH 13/14] test(native-chat): the pane's steer still steers the
 queue, and also reveals

---
 .../native-chat/NativeChatStructuredSession.stopping.test.tsx | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

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()
   })

From 938056d2fae5bf9182c56e4144311a6631d4e3f9 Mon Sep 17 00:00:00 2001
From: Brennan Benson <79079362+brennanb2025@users.noreply.github.com>
Date: Tue, 6 Oct 2026 13:09:15 -0700
Subject: [PATCH 14/14] feat(native-chat): a Jump to top button beside Jump to
 latest

Reaching the start of a long conversation meant scrolling up again and again
while older messages loaded in pages. Now, while the reader is scrolled away
from the end and the start of the conversation is out of view, a round
up-arrow button labelled "Jump to top" sits beside "Jump to latest". Pressing
it loads any older history still unloaded, with a spinner on the button
meanwhile, then lands on the first message. Scrolling the transcript, sending
a message, or starting another jump (a rail pick, a diff reveal, "Jump to
latest") cancels it.

The walk to the start reuses the rail's existing "page older history until the
target loads" loop, with the start of the conversation as a target that has no
slot to wait for. "Jump to latest" keeps its look; only its positioning moved
to the list, which now lays the two buttons out together with "Jump to latest"
still centered.

Co-authored-by: Kelvin Amoaba <97001695+AmoabaKelvin@users.noreply.github.com>
---
 .../native-chat/NativeChatJumpToLatest.tsx    |   4 +-
 .../native-chat/NativeChatJumpToTop.test.tsx  |  45 +++++++
 .../native-chat/NativeChatJumpToTop.tsx       |  49 ++++++++
 ...eChatMessageList.growth-windowing.test.tsx |   3 +-
 ...MessageList.interrupted-turn-fold.test.tsx |   3 +-
 ...iveChatMessageList.live-reasoning.test.tsx |   3 +-
 ...essageList.message-rail-windowing.test.tsx |   3 +-
 ...tiveChatMessageList.older-history.test.tsx |   3 +-
 ...atMessageList.provider-retry-runs.test.tsx |   3 +-
 ...ChatMessageList.queued-turn-order.test.tsx |   3 +-
 ...ChatMessageList.rail-history-jump.test.tsx | 110 +++++++++++++++++-
 ...ChatMessageList.reader-navigation.test.tsx |  22 +++-
 ...ChatMessageList.stopping-turn-bar.test.tsx |   3 +-
 ...hatMessageList.stream-render.perf.test.tsx |   3 +-
 ...ChatMessageList.subagent-sections.test.tsx |   3 +-
 ...eChatMessageList.task-list-frames.test.tsx |   3 +-
 .../NativeChatMessageList.test.tsx            |   3 +-
 ...eChatMessageList.tool-stream-cost.test.tsx |   3 +-
 .../native-chat/NativeChatMessageList.tsx     |  39 ++++---
 .../NativeChatMessageList.turn-fold.test.tsx  |   3 +-
 ...ativeChatMessageList.turn-history.test.tsx |   3 +-
 ...iveChatMessageList.turn-indicator.test.tsx |   3 +-
 ...veChatMessageList.turn-membership.test.tsx |   3 +-
 ...NativeChatMessageList.turn-timing.test.tsx |   3 +-
 ...hatMessageList.unloaded-live-turn.test.tsx |   3 +-
 ...iveChatMessageList.unsent-message.test.tsx |   3 +-
 .../NativeChatMessageList.windowing.test.tsx  |   3 +-
 .../native-chat-app-root-test-render.tsx      |  12 ++
 .../use-native-chat-rail-history-jump.test.ts |  76 +++++++++++-
 .../use-native-chat-rail-history-jump.ts      |  69 +++++++----
 .../use-native-chat-transcript-scroll.ts      |  22 +++-
 src/renderer/src/i18n/locales/en.json         |   1 +
 src/renderer/src/i18n/locales/es.json         |   1 +
 src/renderer/src/i18n/locales/fr.json         |   1 +
 src/renderer/src/i18n/locales/ja.json         |   1 +
 src/renderer/src/i18n/locales/ko.json         |   1 +
 src/renderer/src/i18n/locales/zh.json         |   1 +
 37 files changed, 449 insertions(+), 68 deletions(-)
 create mode 100644 src/renderer/src/components/native-chat/NativeChatJumpToTop.test.tsx
 create mode 100644 src/renderer/src/components/native-chat/NativeChatJumpToTop.tsx
 create mode 100644 src/renderer/src/components/native-chat/native-chat-app-root-test-render.tsx

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 e83f5a7ce31b..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'
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 7fc08a3036b5..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,
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 492269cc82ea..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}
@@ -452,6 +461,99 @@ describe('jumping from the rail while following the end', () => {
     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)',
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
index 91ef38b065a9..08e1b29a9a60 100644
--- a/src/renderer/src/components/native-chat/NativeChatMessageList.reader-navigation.test.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatMessageList.reader-navigation.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 { createRef } from 'react'
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 import type { NativeChatMessage } from '../../../../shared/native-chat-types'
@@ -20,7 +21,8 @@ import {
   session,
   stubLayout,
   stubResizeObserver,
-  TRANSCRIPT_LENGTH
+  TRANSCRIPT_LENGTH,
+  VIEWPORT_PX
 } from './native-chat-windowing-test-harness'
 
 afterEach(cleanup)
@@ -329,6 +331,22 @@ describe('reader navigation', () => {
     }
   )
 
+  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))
 
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 6c9058213ba7..50ad2e110ed9 100644
--- a/src/renderer/src/components/native-chat/NativeChatMessageList.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatMessageList.tsx
@@ -3,6 +3,7 @@ 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'
@@ -226,20 +227,23 @@ export function NativeChatMessageList({
     // mutually exclusive things to be doing.
     revealIndex: nativeChatSlotIndexOf(slots, railJump?.messageId ?? revealedDiff?.messageId)
   })
+  const transcriptScroll = useNativeChatTranscriptScroll({
+    scrollRef,
+    contentRef,
+    itemCount: slots.length,
+    isWorking,
+    showsTailRow: tailRow !== null,
+    isVisible,
+    alignToViewportTop: transcriptWindow.alignToViewportTop,
+    scrollToEnd: transcriptWindow.scrollToEnd,
+    restoreScrollOffset: transcriptWindow.restoreScrollOffset,
+    consumeProgrammaticScroll: transcriptWindow.consumeProgrammaticScroll,
+    reconcileReaderScroll: transcriptWindow.reconcileReaderScroll
+  })
   const { showJump, onScroll, scrollToBottom, scrollMessageToTop, readerLeavesEnd } =
-    useNativeChatTranscriptScroll({
-      scrollRef,
-      contentRef,
-      itemCount: slots.length,
-      isWorking,
-      showsTailRow: tailRow !== null,
-      isVisible,
-      alignToViewportTop: transcriptWindow.alignToViewportTop,
-      scrollToEnd: transcriptWindow.scrollToEnd,
-      restoreScrollOffset: transcriptWindow.restoreScrollOffset,
-      consumeProgrammaticScroll: transcriptWindow.consumeProgrammaticScroll,
-      reconcileReaderScroll: transcriptWindow.reconcileReaderScroll
-    })
+    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}`,
@@ -268,7 +272,8 @@ export function NativeChatMessageList({
     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
@@ -417,7 +422,11 @@ export function NativeChatMessageList({
             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/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/use-native-chat-rail-history-jump.test.ts b/src/renderer/src/components/native-chat/use-native-chat-rail-history-jump.test.ts
index 40502c656d12..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
@@ -89,7 +89,8 @@ function createLane({
   const useLaneRailJump = (
     jumpToLoaded: (item: NativeChatRailItem) => void,
     sessionKey = 'session-1',
-    isVisible = true
+    isVisible = true,
+    jumpToStart: () => void = () => {}
   ) => {
     const current = useSyncExternalStore(lane.subscribe, lane.getSnapshot)
     const items = useMemo<NativeChatRailItem[]>(() => {
@@ -106,7 +107,8 @@ function createLane({
       sessionKey,
       isVisible,
       loadEarlier: lane.loadEarlier,
-      jumpToLoaded
+      jumpToLoaded,
+      jumpToStart
     })
   }
   return { lane, useLaneRailJump }
@@ -329,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 c065a7d8f4fc..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
@@ -28,7 +32,8 @@ export function useNativeChatRailHistoryJump({
   sessionKey,
   isVisible,
   loadEarlier,
-  jumpToLoaded
+  jumpToLoaded,
+  jumpToStart
 }: {
   items: readonly NativeChatRailItem[]
   /** A change abandons the jump: its target belongs to the previous session. */
@@ -37,20 +42,24 @@ export function useNativeChatRailHistoryJump({
   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) {
@@ -74,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)
@@ -108,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, 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-transcript-scroll.ts b/src/renderer/src/components/native-chat/use-native-chat-transcript-scroll.ts
index b2be67a4214a..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
@@ -43,8 +43,11 @@ 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. */
@@ -78,6 +81,7 @@ 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)
@@ -92,6 +96,7 @@ export function useNativeChatTranscriptScroll({
     const geometry = geometryOf(element)
     detachedScrollTopRef.current = followingRef.current ? null : geometry.scrollTop
     setShowJump(shouldShowJumpToLatest(followingRef.current, geometry))
+    setAwayFromTop(geometry.scrollTop > geometry.clientHeight)
     return geometry
   }, [scrollRef])
 
@@ -142,6 +147,13 @@ export function useNativeChatTranscriptScroll({
     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
@@ -207,5 +219,13 @@ export function useNativeChatTranscriptScroll({
     return () => observer.disconnect()
   }, [contentRef, scrollRef, scrollToEndWhenMeasurable, syncScrollState])
 
-  return { showJump, onScroll, scrollToBottom, scrollMessageToTop, readerLeavesEnd }
+  return {
+    showJump,
+    awayFromTop,
+    onScroll,
+    scrollToBottom,
+    scrollToTop,
+    scrollMessageToTop,
+    readerLeavesEnd
+  }
 }
diff --git a/src/renderer/src/i18n/locales/en.json b/src/renderer/src/i18n/locales/en.json
index 067776e4d254..d6bb49d1fd7d 100644
--- a/src/renderer/src/i18n/locales/en.json
+++ b/src/renderer/src/i18n/locales/en.json
@@ -18151,6 +18151,7 @@
         "groupTasks": "Tasks"
       },
       "jumpToLatest": "Jump to latest",
+      "jumpToTop": "Jump to top",
       "transcriptLabel": "Conversation",
       "toggle": {
         "showTerminal": "Show terminal",
diff --git a/src/renderer/src/i18n/locales/es.json b/src/renderer/src/i18n/locales/es.json
index cf05ce0b0e48..455cb67e09b9 100644
--- a/src/renderer/src/i18n/locales/es.json
+++ b/src/renderer/src/i18n/locales/es.json
@@ -17842,6 +17842,7 @@
         "toggleDetails": "Alternar detalles del turno"
       },
       "jumpToLatest": "Saltar a lo último",
+      "jumpToTop": "Ir al principio",
       "transcriptLabel": "Conversación",
       "toggle": {
         "showTerminal": "Mostrar terminal",
diff --git a/src/renderer/src/i18n/locales/fr.json b/src/renderer/src/i18n/locales/fr.json
index 59ddffc5f7cc..7988599b8afe 100644
--- a/src/renderer/src/i18n/locales/fr.json
+++ b/src/renderer/src/i18n/locales/fr.json
@@ -17941,6 +17941,7 @@
         "toggleDetails": "Basculer les détails du tour"
       },
       "jumpToLatest": "Aller au dernier message",
+      "jumpToTop": "Remonter en haut",
       "transcriptLabel": "Conversation",
       "toggle": {
         "showTerminal": "Afficher le terminal",
diff --git a/src/renderer/src/i18n/locales/ja.json b/src/renderer/src/i18n/locales/ja.json
index 6681d0142060..3ea2cb014889 100644
--- a/src/renderer/src/i18n/locales/ja.json
+++ b/src/renderer/src/i18n/locales/ja.json
@@ -17877,6 +17877,7 @@
         "toggleDetails": "ターンの詳細を切り替えます"
       },
       "jumpToLatest": "最新にジャンプ",
+      "jumpToTop": "先頭へジャンプ",
       "transcriptLabel": "会話",
       "toggle": {
         "showTerminal": "ターミナルを表示",
diff --git a/src/renderer/src/i18n/locales/ko.json b/src/renderer/src/i18n/locales/ko.json
index 03d06b41e66a..536d957376fa 100644
--- a/src/renderer/src/i18n/locales/ko.json
+++ b/src/renderer/src/i18n/locales/ko.json
@@ -17877,6 +17877,7 @@
         "toggleDetails": "턴 세부정보 전환"
       },
       "jumpToLatest": "최신으로 이동",
+      "jumpToTop": "맨 위로 이동",
       "transcriptLabel": "대화",
       "toggle": {
         "showTerminal": "terminal 표시",
diff --git a/src/renderer/src/i18n/locales/zh.json b/src/renderer/src/i18n/locales/zh.json
index b6c41c2333a7..b7f462842d10 100644
--- a/src/renderer/src/i18n/locales/zh.json
+++ b/src/renderer/src/i18n/locales/zh.json
@@ -17842,6 +17842,7 @@
         "toggleDetails": "切换回合详情"
       },
       "jumpToLatest": "跳到最新消息",
+      "jumpToTop": "跳转到顶部",
       "transcriptLabel": "对话",
       "toggle": {
         "showTerminal": "显示终端",