From fb4f744721ba6f927923754fc69a2add5c2d53df Mon Sep 17 00:00:00 2001
From: Merge Sim <sim@local>
Date: Mon, 7 Sep 2026 00:17:22 -0700
Subject: [PATCH 01/22] feat(native-chat): confirm destructive conversation
 rewind from user messages

---
 .../native-chat/NativeChatMessageList.tsx     |   6 +-
 .../native-chat/NativeChatMessageRow.tsx      |  13 +-
 .../NativeChatRewindAction.test.tsx           |  65 +++++
 .../native-chat/NativeChatRewindAction.tsx    |  33 +++
 ...NativeChatStructuredSession.epoch.test.tsx |  86 +++++++
 .../NativeChatStructuredSession.test.tsx      |   8 +
 .../NativeChatStructuredSession.tsx           |  42 +++-
 .../native-chat/native-chat-rewind-copy.ts    |  66 +++++
 .../use-native-chat-rewind.test.tsx           | 238 ++++++++++++++++++
 .../native-chat/use-native-chat-rewind.ts     | 193 ++++++++++++++
 .../use-structured-agent-session-mutation.ts  | 104 ++++++++
 .../use-structured-agent-session-read.ts      |   1 +
 .../use-structured-agent-session.test.tsx     | 118 ++++++++-
 .../use-structured-agent-session.ts           | 131 ++++------
 src/renderer/src/i18n/locales/en.json         |  22 +-
 15 files changed, 1036 insertions(+), 90 deletions(-)
 create mode 100644 src/renderer/src/components/native-chat/NativeChatRewindAction.test.tsx
 create mode 100644 src/renderer/src/components/native-chat/NativeChatRewindAction.tsx
 create mode 100644 src/renderer/src/components/native-chat/NativeChatStructuredSession.epoch.test.tsx
 create mode 100644 src/renderer/src/components/native-chat/native-chat-rewind-copy.ts
 create mode 100644 src/renderer/src/components/native-chat/use-native-chat-rewind.test.tsx
 create mode 100644 src/renderer/src/components/native-chat/use-native-chat-rewind.ts
 create mode 100644 src/renderer/src/components/native-chat/use-structured-agent-session-mutation.ts

diff --git a/src/renderer/src/components/native-chat/NativeChatMessageList.tsx b/src/renderer/src/components/native-chat/NativeChatMessageList.tsx
index b406f0c3e502..9a422d7607af 100644
--- a/src/renderer/src/components/native-chat/NativeChatMessageList.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatMessageList.tsx
@@ -1,3 +1,4 @@
+import type { NativeChatRewindSurface } from './use-native-chat-rewind'
 import { Fragment, useCallback, useEffect, useLayoutEffect, useMemo, useRef, useState } from 'react'
 import { ArrowDown } from 'lucide-react'
 import type { CommentMarkdownLinkClickHandler } from '@/components/sidebar/CommentMarkdown'
@@ -35,7 +36,8 @@ export function NativeChatMessageList({
   failedDeliveryMessageIds,
   showTurnStatus = true,
   turnActivity,
-  runtimeContext
+  runtimeContext,
+  rewind
 }: {
   session: NativeChatLiveSession
   isWorking: boolean
@@ -50,6 +52,7 @@ export function NativeChatMessageList({
   /** Turn timing and disclosure are available on structured agent sessions. */
   showTurnStatus?: boolean
   turnActivity?: NativeChatTurnActivity | null
+  rewind?: NativeChatRewindSurface
   runtimeContext?: RuntimeFileOperationArgs | null
 }): React.JSX.Element {
   const scrollRef = useRef<HTMLDivElement | null>(null)
@@ -231,6 +234,7 @@ export function NativeChatMessageList({
               <Fragment key={message.id}>
                 <MessageRow
                   message={message}
+                  rewind={message.role === 'user' ? rewind : undefined}
                   expandSignal={expandSignal}
                   // A missing transcript lifecycle is not evidence that the turn
                   // ended. Structured sessions and legacy live hooks still expose
diff --git a/src/renderer/src/components/native-chat/NativeChatMessageRow.tsx b/src/renderer/src/components/native-chat/NativeChatMessageRow.tsx
index 07ea51b5a626..9d0452666621 100644
--- a/src/renderer/src/components/native-chat/NativeChatMessageRow.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatMessageRow.tsx
@@ -1,3 +1,5 @@
+import { NativeChatRewindAction } from './NativeChatRewindAction'
+import type { NativeChatRewindSurface } from './use-native-chat-rewind'
 import { memo, useCallback, useMemo, useRef } from 'react'
 import CommentMarkdown, {
   type CommentMarkdownLinkClickHandler
@@ -30,7 +32,8 @@ export const MessageRow = memo(function MessageRow({
   deliveryFailed = false,
   activityExpandOverride,
   structuredActivityUi = true,
-  runtimeContext
+  runtimeContext,
+  rewind
 }: {
   message: NativeChatMessage
   expandSignal: boolean
@@ -42,6 +45,7 @@ export const MessageRow = memo(function MessageRow({
   deliveryFailed?: boolean
   activityExpandOverride?: boolean
   structuredActivityUi?: boolean
+  rewind?: NativeChatRewindSurface
   runtimeContext?: RuntimeFileOperationArgs | null
 }): React.JSX.Element | null {
   const rowRef = useRef<HTMLDivElement | null>(null)
@@ -83,7 +87,7 @@ export const MessageRow = memo(function MessageRow({
 
   if (isUser) {
     return (
-      <div ref={rowRef} className="flex flex-col items-end gap-0.5">
+      <div ref={rowRef} className="group relative flex flex-col items-end gap-0.5">
         {/* User turns get a distinct muted fill (not the card/canvas color) so
             the prompt reads apart from the assistant's body copy. */}
         <div className="max-w-[85%] rounded-lg rounded-tr-sm bg-muted px-3.5 py-2.5 text-sm text-foreground">
@@ -110,6 +114,11 @@ export const MessageRow = memo(function MessageRow({
             />
           )}
         </div>
+        {rewind ? (
+          <div className="pointer-events-none flex items-center gap-1 select-none opacity-0 transition-opacity group-hover:pointer-events-auto group-hover:opacity-100 group-focus-within:pointer-events-auto group-focus-within:opacity-100">
+            <NativeChatRewindAction itemId={message.id} rewind={rewind} />
+          </div>
+        ) : null}
         {deliveryFailed ? (
           <div className="max-w-[85%] text-[11px] text-destructive/80">
             {translate(
diff --git a/src/renderer/src/components/native-chat/NativeChatRewindAction.test.tsx b/src/renderer/src/components/native-chat/NativeChatRewindAction.test.tsx
new file mode 100644
index 000000000000..11773ef0e99d
--- /dev/null
+++ b/src/renderer/src/components/native-chat/NativeChatRewindAction.test.tsx
@@ -0,0 +1,65 @@
+// @vitest-environment happy-dom
+import '@testing-library/jest-dom/vitest'
+import { cleanup, fireEvent, render, screen } from '@testing-library/react'
+import { afterEach, describe, expect, it, vi } from 'vitest'
+import { MessageRow } from './NativeChatMessageRow'
+import type { NativeChatMessage } from '../../../../shared/native-chat-types'
+
+afterEach(cleanup)
+function row(
+  role: NativeChatMessage['role'],
+  disabledReason: string | null = null,
+  enabled = true
+) {
+  const request = vi.fn()
+  render(
+    <MessageRow
+      message={{
+        id: 'user-1',
+        role,
+        timestamp: 1,
+        source: 'transcript',
+        blocks: [{ type: 'text', text: 'Prompt' }]
+      }}
+      expandSignal={false}
+      onScrollMessageToTop={vi.fn()}
+      rewind={enabled ? { request, disabledReason } : undefined}
+    />
+  )
+  return request
+}
+describe('user-row rewind affordance', () => {
+  it('is keyboard reachable and calls the selected user item from the hover strip', () => {
+    const request = row('user')
+    const button = screen.getByRole('button', { name: 'Revert to here' })
+    button.focus()
+    expect(button).toHaveFocus()
+    expect(button.parentElement).toHaveClass(
+      'group-hover:opacity-100',
+      'group-focus-within:opacity-100'
+    )
+    fireEvent.click(button)
+    expect(request).toHaveBeenCalledWith('user-1')
+  })
+  it('exposes the disabled reason to keyboard users and cannot invoke rewind', () => {
+    const request = row('user', 'This older Codex conversation does not support rewinding.')
+    const button = screen.getByRole('button', { name: 'Revert to here' })
+    expect(button).toHaveAttribute('aria-disabled', 'true')
+    expect(button).toHaveAttribute(
+      'aria-description',
+      'This older Codex conversation does not support rewinding.'
+    )
+    button.focus()
+    expect(button).toHaveFocus()
+    fireEvent.click(button)
+    expect(request).not.toHaveBeenCalled()
+  })
+  it.each(['assistant', 'reasoning', 'system'] as const)('omits rewind for %s', (role) => {
+    row(role)
+    expect(screen.queryByRole('button', { name: 'Revert to here' })).toBeNull()
+  })
+  it('leaves legacy user rows without rewind', () => {
+    row('user', null, false)
+    expect(screen.queryByRole('button', { name: 'Revert to here' })).toBeNull()
+  })
+})
diff --git a/src/renderer/src/components/native-chat/NativeChatRewindAction.tsx b/src/renderer/src/components/native-chat/NativeChatRewindAction.tsx
new file mode 100644
index 000000000000..5b71b558e520
--- /dev/null
+++ b/src/renderer/src/components/native-chat/NativeChatRewindAction.tsx
@@ -0,0 +1,33 @@
+import { Undo2 } from 'lucide-react'
+import { Button } from '@/components/ui/button'
+import { translate } from '@/i18n/i18n'
+import type { NativeChatRewindSurface } from './use-native-chat-rewind'
+
+export function NativeChatRewindAction({
+  itemId,
+  rewind
+}: {
+  itemId: string
+  rewind: NativeChatRewindSurface
+}) {
+  const label = translate('components.native-chat.rewind.action', 'Revert to here')
+  return (
+    <Button
+      type="button"
+      size="icon-xs"
+      variant="ghost"
+      className="text-muted-foreground aria-disabled:opacity-50"
+      aria-label={label}
+      aria-description={rewind.disabledReason ?? undefined}
+      aria-disabled={Boolean(rewind.disabledReason)}
+      title={rewind.disabledReason ?? label}
+      onClick={() => {
+        if (!rewind.disabledReason) {
+          rewind.request(itemId)
+        }
+      }}
+    >
+      <Undo2 className="size-3" />
+    </Button>
+  )
+}
diff --git a/src/renderer/src/components/native-chat/NativeChatStructuredSession.epoch.test.tsx b/src/renderer/src/components/native-chat/NativeChatStructuredSession.epoch.test.tsx
new file mode 100644
index 000000000000..509d9458b123
--- /dev/null
+++ b/src/renderer/src/components/native-chat/NativeChatStructuredSession.epoch.test.tsx
@@ -0,0 +1,86 @@
+// @vitest-environment happy-dom
+import { cleanup, fireEvent, render, screen } from '@testing-library/react'
+import { forwardRef } from 'react'
+import { afterEach, it, vi } from 'vitest'
+import { NativeChatStructuredSession } from './NativeChatStructuredSession'
+import { expect } from 'vitest'
+
+const mocks = vi.hoisted(() => ({
+  epoch: 'epoch-1',
+  composerProps: null as { paneKey: string } | null
+}))
+vi.mock('./use-structured-agent-session', () => ({
+  useStructuredAgentSession: () => ({
+    epoch: mocks.epoch,
+    messages: [{ id: 'message', role: 'user', blocks: [{ type: 'text', text: 'Prompt' }] }],
+    status: 'ready',
+    isWorking: false,
+    prompts: [],
+    outbox: [],
+    rewind: { pending: false, disabledReason: null, request: vi.fn() }
+  })
+}))
+vi.mock('@/components/confirmation-dialog-context', () => ({
+  useConfirmationDialog: () => vi.fn()
+}))
+vi.mock('./use-native-chat-font-scale', () => ({ useNativeChatFontScale: () => ({ scale: 1 }) }))
+vi.mock('./use-native-chat-file-link-context', () => ({ useNativeChatFileLinkContext: () => null }))
+vi.mock('./native-chat-image-runtime-context', () => ({
+  useNativeChatImageRuntimeContext: () => null
+}))
+vi.mock('./use-native-chat-link-actions', () => ({
+  useNativeChatLinkActions: () => ({
+    onLinkClick: vi.fn(),
+    linkActionRequest: null,
+    closeLinkActions: vi.fn()
+  })
+}))
+vi.mock('./use-structured-native-chat-pane-commands', () => ({
+  useStructuredNativeChatPaneCommands: () => ({ menu: null })
+}))
+vi.mock('./NativeChatMessageList', () => ({
+  NativeChatMessageList: () => <div data-testid="message-list" />
+}))
+vi.mock('./NativeChatComposer', async () => {
+  const { useNativeChatDraft } = await import('./use-native-chat-draft')
+  return {
+    NativeChatComposer: forwardRef((_props: { paneKey: string }, _ref) => {
+      mocks.composerProps = _props
+      const { draft, setDraft } = useNativeChatDraft(_props.paneKey)
+      return (
+        <textarea
+          data-testid="structured-composer"
+          value={draft}
+          onChange={(event) => setDraft(event.target.value)}
+        />
+      )
+    })
+  }
+})
+afterEach(cleanup)
+it('clears cached draft and remounts transcript on epoch change, preserving same-epoch refreshes', () => {
+  const props = {
+    isVisible: true,
+    tabId: 'epoch-tab',
+    sessionId: 'epoch-session',
+    target: { kind: 'local' as const },
+    agent: 'codex' as const
+  }
+  const view = render(<NativeChatStructuredSession {...props} />)
+  const composer = screen.getByTestId('structured-composer') as HTMLTextAreaElement
+  const transcript = screen.getByTestId('message-list')
+  const oldScope = mocks.composerProps!.paneKey
+  fireEvent.change(composer, { target: { value: 'stale unsent draft' } })
+  view.rerender(<NativeChatStructuredSession {...props} />)
+  expect(screen.getByTestId('structured-composer')).toBe(composer)
+  expect(composer.value).toBe('stale unsent draft')
+  mocks.epoch = 'epoch-2'
+  view.rerender(<NativeChatStructuredSession {...props} />)
+  expect(screen.getByTestId('message-list')).not.toBe(transcript)
+  expect(screen.getByTestId('structured-composer')).not.toBe(composer)
+  expect((screen.getByTestId('structured-composer') as HTMLTextAreaElement).value).toBe('')
+  expect(mocks.composerProps!.paneKey).not.toBe(oldScope)
+  view.unmount()
+  render(<NativeChatStructuredSession {...props} />)
+  expect((screen.getByTestId('structured-composer') as HTMLTextAreaElement).value).toBe('')
+})
diff --git a/src/renderer/src/components/native-chat/NativeChatStructuredSession.test.tsx b/src/renderer/src/components/native-chat/NativeChatStructuredSession.test.tsx
index bd8ba9ed7ec0..ef088dea0f66 100644
--- a/src/renderer/src/components/native-chat/NativeChatStructuredSession.test.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatStructuredSession.test.tsx
@@ -9,6 +9,8 @@ import { decodeAgentSessionQuestionAnswers } from '../../../../shared/agent-sess
 import type { NativeChatQuestionCardProps } from './NativeChatQuestionCard'
 
 const mocks = vi.hoisted(() => ({
+  epoch: 'epoch-1',
+  rewind: { disabledReason: null, pending: false, request: vi.fn() },
   call: vi.fn(),
   fileLinkClick: vi.fn(),
   mode: 'static' as 'static' | 'outbox',
@@ -34,6 +36,10 @@ const mocks = vi.hoisted(() => ({
   stopBackgroundTask: vi.fn()
 }))
 
+vi.mock('@/components/confirmation-dialog-context', () => ({
+  useConfirmationDialog: () => vi.fn()
+}))
+
 vi.mock('@/runtime/structured-agent-session-client', () => ({
   callStructuredAgentSession: mocks.call
 }))
@@ -64,6 +70,8 @@ vi.mock('./use-structured-agent-session', async () => {
                   blocks: [{ type: 'text', text: '[file](file:///repo/src/main.ts)' }]
                 }
               ],
+        epoch: mocks.epoch,
+        rewind: mocks.rewind,
         status: 'ready' as const,
         error: outbox.error,
         hasOlder: false,
diff --git a/src/renderer/src/components/native-chat/NativeChatStructuredSession.tsx b/src/renderer/src/components/native-chat/NativeChatStructuredSession.tsx
index 93a662a0157d..1c1494d1f2de 100644
--- a/src/renderer/src/components/native-chat/NativeChatStructuredSession.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatStructuredSession.tsx
@@ -1,3 +1,4 @@
+import { useConfirmationDialog } from '@/components/confirmation-dialog-context'
 import { useMemo, useRef, useState } from 'react'
 import { RotateCcw } from 'lucide-react'
 import { encodeAgentSessionQuestionAnswers } from '../../../../shared/agent-session-question-answer'
@@ -38,6 +39,32 @@ export function NativeChatStructuredSession(
   props: Omit<NativeChatStructuredViewProps, 'mode'>
 ): React.JSX.Element {
   const controller = useStructuredAgentSession(props)
+  return (
+    <NativeChatStructuredSessionContent
+      key={controller.epoch ?? 'loading'}
+      {...props}
+      controller={controller}
+    />
+  )
+}
+
+function NativeChatStructuredSessionContent({
+  controller,
+  ...props
+}: Omit<NativeChatStructuredViewProps, 'mode'> & {
+  controller: ReturnType<typeof useStructuredAgentSession>
+}): React.JSX.Element {
+  const confirm = useConfirmationDialog()
+  const { disabledReason, request } = controller.rewind
+  const rewind = useMemo(
+    () => ({
+      disabledReason,
+      request: (itemId: string) => {
+        void request(itemId, confirm)
+      }
+    }),
+    [disabledReason, request, confirm]
+  )
   const [composerError, setComposerError] = useState<string | null>(null)
   const [stoppingBackgroundTasks, setStoppingBackgroundTasks] =
     useState<StoppingBackgroundTasks | null>(null)
@@ -46,8 +73,12 @@ export function NativeChatStructuredSession(
     sequence: number
   } | null>(null)
   const paneKey = useMemo(
-    () => structuredAgentSessionPaneKey(props.tabId, props.sessionId),
-    [props.sessionId, props.tabId]
+    () =>
+      JSON.stringify([
+        structuredAgentSessionPaneKey(props.tabId, props.sessionId),
+        controller.epoch
+      ]),
+    [props.sessionId, props.tabId, controller.epoch]
   )
   const rootRef = useRef<HTMLDivElement>(null)
   const composerRef = useRef<NativeChatComposerHandle>(null)
@@ -191,6 +222,8 @@ export function NativeChatStructuredSession(
           <NativeChatEmptyState kind="empty" agent={props.agent} />
         ) : (
           <NativeChatMessageList
+            key={paneKey}
+            rewind={rewind}
             session={session}
             isWorking={controller.isWorking}
             expandSignal={false}
@@ -342,14 +375,15 @@ export function NativeChatStructuredSession(
           }}
         />
       ) : null}
-      {prompt ? null : (
+      {prompt || !controller.epoch ? null : (
         <NativeChatComposer
+          key={paneKey}
           ref={composerRef}
           terminalTabId={props.tabId}
           paneKey={paneKey}
           targetPtyId={null}
           agent={props.agent}
-          canSend={!prompt}
+          canSend={!prompt && !controller.rewind.pending}
           isWorking={controller.isWorking}
           onStop={() => {
             if (controller.turnId) {
diff --git a/src/renderer/src/components/native-chat/native-chat-rewind-copy.ts b/src/renderer/src/components/native-chat/native-chat-rewind-copy.ts
new file mode 100644
index 000000000000..dec800791af8
--- /dev/null
+++ b/src/renderer/src/components/native-chat/native-chat-rewind-copy.ts
@@ -0,0 +1,66 @@
+import { translate } from '@/i18n/i18n'
+import type { AgentSessionRewindReason } from '../../../../shared/agent-session-rewind'
+
+const reasonCopy = {
+  unsupported: () =>
+    translate(
+      'components.native-chat.rewind.unsupported',
+      'This session does not support rewinding conversation history.'
+    ),
+  'history-not-paginated': () =>
+    translate(
+      'components.native-chat.rewind.historyNotPaginated',
+      'This older Codex conversation does not support rewinding. Start a new conversation to use rewind.'
+    ),
+  busy: () =>
+    translate(
+      'components.native-chat.rewind.busy',
+      'Wait for the current turn, pending messages, approvals, and background work to finish before rewinding.'
+    ),
+  'stale-epoch': () =>
+    translate(
+      'components.native-chat.rewind.staleEpoch',
+      'The conversation changed. Review the latest messages before rewinding.'
+    ),
+  'invalid-target': () =>
+    translate(
+      'components.native-chat.rewind.invalidTarget',
+      'This message is no longer a valid rewind point. Review the latest conversation.'
+    ),
+  'history-limit': () =>
+    translate(
+      'components.native-chat.rewind.historyLimit',
+      'This conversation is too large to rewind safely.'
+    ),
+  'provider-refused': () =>
+    translate(
+      'components.native-chat.rewind.providerRefused',
+      'The agent refused to rewind this conversation.'
+    ),
+  'proof-mismatch': () =>
+    translate(
+      'components.native-chat.rewind.proofMismatch',
+      'Orca could not verify the conversation boundary. Reload the session before trying again.'
+    ),
+  'outcome-unknown': () =>
+    translate(
+      'components.native-chat.rewind.outcomeUnknown',
+      'The rewind may have completed, but Orca could not confirm it. Sending is blocked until the session is reloaded or the outcome is resolved.'
+    )
+} satisfies Record<AgentSessionRewindReason, () => string>
+
+export function nativeChatRewindReasonCopy(reason: string | undefined): string {
+  return reason && Object.hasOwn(reasonCopy, reason)
+    ? reasonCopy[reason as keyof typeof reasonCopy]()
+    : translate(
+        'components.native-chat.rewind.refused',
+        'Orca could not rewind this conversation. Reload the session to check its current state.'
+      )
+}
+
+export function nativeChatRewindUnavailableCopy(): string {
+  return translate(
+    'components.native-chat.rewind.unavailable',
+    'Reconnect to a writable chat session before rewinding.'
+  )
+}
diff --git a/src/renderer/src/components/native-chat/use-native-chat-rewind.test.tsx b/src/renderer/src/components/native-chat/use-native-chat-rewind.test.tsx
new file mode 100644
index 000000000000..e22b9c67ccec
--- /dev/null
+++ b/src/renderer/src/components/native-chat/use-native-chat-rewind.test.tsx
@@ -0,0 +1,238 @@
+// @vitest-environment happy-dom
+import { act, cleanup, renderHook } from '@testing-library/react'
+import { afterEach, describe, expect, it, vi } from 'vitest'
+import { EMPTY_STRUCTURED_AGENT_SESSION } from '../../../../shared/structured-agent-session-reducer'
+import type { AgentJournalRenderItem } from '../../../../shared/agent-session-journal-types'
+import { countNativeChatRewindMessages, useNativeChatRewind } from './use-native-chat-rewind'
+import { nativeChatRewindReasonCopy } from './native-chat-rewind-copy'
+
+afterEach(cleanup)
+const item = (itemId: string, sequence: number, role = 'user'): AgentJournalRenderItem =>
+  ({
+    itemId,
+    sequence,
+    revision: 1,
+    observedAt: sequence,
+    body: { kind: 'message', role, blocks: [{ type: 'text', text: itemId }] }
+  }) as AgentJournalRenderItem
+function input() {
+  return {
+    sessionId: 'session',
+    state: {
+      ...EMPTY_STRUCTURED_AGENT_SESSION,
+      epoch: 'old',
+      fence: 1,
+      status: 'ready' as const,
+      cursor: { epoch: 'old', sequence: 12 },
+      items: [item('user', 10), item('reply', 11, 'assistant'), item('later', 12)]
+    },
+    support: { supported: true as const },
+    supportResolved: true,
+    blocked: false,
+    send: vi.fn().mockResolvedValue({ itemId: 'user', epoch: 'new' }),
+    refresh: vi.fn()
+  }
+}
+function deferred<T>() {
+  let resolve!: (value: T) => void
+  const promise = new Promise<T>((done) => {
+    resolve = done
+  })
+  return { promise, resolve }
+}
+
+describe('structured chat rewind', () => {
+  it('confirms the exact suffix count even when earlier history is unloaded', async () => {
+    const props = input()
+    props.state.hasOlder = true
+    expect(countNativeChatRewindMessages(props.state, 'user')).toBe(3)
+    expect(countNativeChatRewindMessages(props.state, 'reply')).toBe(0)
+    const confirm = vi.fn().mockResolvedValue(true)
+    const view = renderHook(() => useNativeChatRewind(props))
+    await act(() => view.result.current.request('user', confirm))
+    expect(confirm).toHaveBeenCalledWith(
+      expect.objectContaining({
+        confirmVariant: 'destructive',
+        description: expect.stringContaining('3 messages total')
+      })
+    )
+    expect(props.send).toHaveBeenCalledWith(
+      { itemId: 'user', expectedEpoch: 'old' },
+      expect.any(Function)
+    )
+    expect(props.refresh).toHaveBeenCalledOnce()
+    expect(view.result.current.pending).toBe(true)
+    expect(view.result.current.blockedRef.current).toBe(true)
+  })
+
+  it('cancels without sending and blocks duplicate clicks while confirming', async () => {
+    const props = input(),
+      confirmation = deferred<boolean>()
+    const confirm = vi.fn(() => confirmation.promise)
+    const view = renderHook(() => useNativeChatRewind(props))
+    let request!: Promise<void>
+    act(() => {
+      request = view.result.current.request('user', confirm)
+    })
+    await act(() => view.result.current.request('user', confirm))
+    expect(confirm).toHaveBeenCalledOnce()
+    await act(async () => {
+      confirmation.resolve(false)
+      await request
+    })
+    expect(props.send).not.toHaveBeenCalled()
+    expect(view.result.current.pending).toBe(false)
+  })
+
+  it('does not execute a confirmation after its pane unmounts', async () => {
+    const props = input(),
+      confirmation = deferred<boolean>()
+    const view = renderHook(() => useNativeChatRewind(props))
+    let request!: Promise<void>
+    act(() => {
+      request = view.result.current.request('user', () => confirmation.promise)
+    })
+    view.unmount()
+    await act(async () => {
+      confirmation.resolve(true)
+      await request
+    })
+    expect(props.send).not.toHaveBeenCalled()
+  })
+
+  it.each(['busy', 'unwritable', 'handoff', 'legacy', 'loading-support'] as const)(
+    'disables %s sessions with explanatory copy',
+    async (mode) => {
+      const props: Parameters<typeof useNativeChatRewind>[0] = input()
+      if (mode === 'loading-support') {
+        props.supportResolved = false
+      }
+      if (mode === 'busy') {
+        props.blocked = true
+      }
+      if (mode === 'unwritable') {
+        props.state.fence = null
+      }
+      if (mode === 'handoff') {
+        props.state.handoff = {
+          owner: 'tui',
+          phase: 'idle',
+          stage: null,
+          direction: null,
+          operationId: null
+        }
+      }
+      if (mode === 'legacy') {
+        props.support = { supported: false, reason: 'history-not-paginated' }
+      }
+      const confirm = vi.fn()
+      const view = renderHook(() => useNativeChatRewind(props))
+      expect(view.result.current.disabledReason).toBeTruthy()
+      if (mode === 'legacy') {
+        expect(view.result.current.disabledReason).toContain('older Codex conversation')
+      }
+      await act(() => view.result.current.request('user', confirm))
+      expect(confirm).not.toHaveBeenCalled()
+      expect(props.send).not.toHaveBeenCalled()
+    }
+  )
+
+  it.each(['epoch', 'messages', 'busy'] as const)(
+    'rechecks %s after confirmation',
+    async (change) => {
+      const props = input(),
+        confirmation = deferred<boolean>()
+      const view = renderHook((value) => useNativeChatRewind(value), { initialProps: props })
+      let request!: Promise<void>
+      act(() => {
+        request = view.result.current.request('user', () => confirmation.promise)
+      })
+      view.rerender({
+        ...props,
+        blocked: change === 'busy',
+        state: {
+          ...props.state,
+          epoch: change === 'epoch' ? 'new' : 'old',
+          cursor: { epoch: 'old', sequence: change === 'messages' ? 13 : 12 }
+        }
+      })
+      await act(async () => {
+        confirmation.resolve(true)
+        await request
+      })
+      expect(props.send).not.toHaveBeenCalled()
+      expect(view.result.current.error).toBeTruthy()
+    }
+  )
+
+  it.each(['before', 'after'] as const)(
+    'settles when epoch reset arrives %s RPC success',
+    async (order) => {
+      const props = input(),
+        response = deferred<{ itemId: string; epoch: string }>()
+      props.send.mockReturnValue(response.promise)
+      const view = renderHook((value) => useNativeChatRewind(value), { initialProps: props })
+      let request!: Promise<void>
+      await act(async () => {
+        request = view.result.current.request('user', async () => true)
+      })
+      const reset = () =>
+        view.rerender({ ...props, state: { ...props.state, epoch: 'new', items: [] } })
+      if (order === 'before') {
+        reset()
+      }
+      await act(async () => {
+        response.resolve({ itemId: 'user', epoch: 'new' })
+        await request
+      })
+      if (order === 'after') {
+        expect(view.result.current.pending).toBe(true)
+        reset()
+      }
+      expect(view.result.current.pending).toBe(false)
+      expect(view.result.current.blockedRef.current).toBe(false)
+    }
+  )
+
+  it.each([
+    'unsupported',
+    'history-not-paginated',
+    'busy',
+    'stale-epoch',
+    'invalid-target',
+    'history-limit',
+    'provider-refused',
+    'proof-mismatch',
+    'outcome-unknown',
+    'future-reason'
+  ])('explains refusal %s', async (rewindReason) => {
+    const props = input()
+    props.send.mockImplementation(async (_fields, failure) => {
+      failure({ code: 'unsupported', rewindReason })
+      return null
+    })
+    const view = renderHook(() => useNativeChatRewind(props))
+    await act(() => view.result.current.request('user', async () => true))
+    expect(view.result.current.error).toBe(nativeChatRewindReasonCopy(rewindReason))
+    if (rewindReason === 'outcome-unknown') {
+      expect(view.result.current.error).toContain('may have completed')
+      expect(view.result.current.error).toContain('Sending is blocked')
+      expect(view.result.current.error).not.toContain('failed')
+      expect(view.result.current.pending).toBe(true)
+    }
+    expect(props.refresh).not.toHaveBeenCalled()
+  })
+
+  it('treats a lost transport response as uncertain and never retries', async () => {
+    const props = input()
+    props.send.mockImplementation(async (_fields, failure) => {
+      failure()
+      return null
+    })
+    const view = renderHook(() => useNativeChatRewind(props))
+    await act(() => view.result.current.request('user', async () => true))
+    await act(() => view.result.current.request('user', async () => true))
+    expect(props.send).toHaveBeenCalledOnce()
+    expect(view.result.current.error).toContain('may have completed')
+  })
+})
diff --git a/src/renderer/src/components/native-chat/use-native-chat-rewind.ts b/src/renderer/src/components/native-chat/use-native-chat-rewind.ts
new file mode 100644
index 000000000000..d5a657eba902
--- /dev/null
+++ b/src/renderer/src/components/native-chat/use-native-chat-rewind.ts
@@ -0,0 +1,193 @@
+import { useCallback, useLayoutEffect, useRef, useState } from 'react'
+import type { ConfirmationDialogContextValue } from '@/components/confirmation-dialog-context'
+import { translate } from '@/i18n/i18n'
+import type {
+  AgentSessionRewindResult,
+  AgentSessionRewindSupport
+} from '../../../../shared/agent-session-rewind'
+import type { AgentSessionWireRefusal } from '../../../../shared/agent-session-wire'
+import type { StructuredAgentSessionState } from '../../../../shared/structured-agent-session-reducer'
+import {
+  nativeChatRewindReasonCopy,
+  nativeChatRewindUnavailableCopy
+} from './native-chat-rewind-copy'
+
+export type NativeChatRewindSurface = {
+  disabledReason: string | null
+  request: (itemId: string) => void
+}
+
+type RewindInput = {
+  sessionId: string
+  state: StructuredAgentSessionState
+  support: AgentSessionRewindSupport | undefined
+  supportResolved: boolean
+  blocked: boolean
+  send: (
+    fields: { itemId: string; expectedEpoch: string },
+    onFailure: (refusal?: AgentSessionWireRefusal) => void
+  ) => Promise<AgentSessionRewindResult | null>
+  refresh: () => void
+}
+
+export function countNativeChatRewindMessages(
+  state: StructuredAgentSessionState,
+  itemId: string
+): number {
+  const index = state.items.findIndex(
+    (item) => item.itemId === itemId && item.body.kind === 'message' && item.body.role === 'user'
+  )
+  return index === -1
+    ? 0
+    : state.items.slice(index).filter((item) => item.body.kind === 'message').length
+}
+
+function blockedReason(input: RewindInput): string | null {
+  if (input.support?.supported === false) {
+    return nativeChatRewindReasonCopy(input.support.reason)
+  }
+  const { state } = input
+  if (
+    !input.supportResolved ||
+    !state.epoch ||
+    state.fence === null ||
+    state.status !== 'ready' ||
+    (state.handoff && (state.handoff.owner !== 'native' || state.handoff.phase !== 'idle'))
+  ) {
+    return nativeChatRewindUnavailableCopy()
+  }
+  return input.blocked ? nativeChatRewindReasonCopy('busy') : null
+}
+
+export function useNativeChatRewind(input: RewindInput) {
+  const active = useRef(false)
+  useLayoutEffect(() => {
+    active.current = true
+    return () => {
+      active.current = false
+    }
+  }, [])
+  const latest = useRef(input)
+  useLayoutEffect(() => {
+    latest.current = input
+  }, [input])
+  const inFlight = useRef(false)
+  const [pending, setPending] = useState(false)
+  const [settlement, setSettlement] = useState<{
+    sessionId: string
+    epoch: string
+    nextEpoch?: string
+  } | null>(null)
+  const [failure, setFailure] = useState<{
+    sessionId: string
+    epoch: string | null
+    message: string
+  } | null>(null)
+  const setError = (message: string | null) => {
+    const current = latest.current
+    setFailure(
+      message ? { sessionId: current.sessionId, epoch: current.state.epoch, message } : null
+    )
+  }
+  const error =
+    failure?.sessionId === input.sessionId && failure.epoch === input.state.epoch
+      ? failure.message
+      : null
+  const awaitingReset =
+    settlement?.sessionId === input.sessionId && settlement.epoch === input.state.epoch
+  const disabledReason =
+    pending || awaitingReset
+      ? settlement && !settlement.nextEpoch
+        ? nativeChatRewindReasonCopy('outcome-unknown')
+        : translate(
+            'components.native-chat.rewind.pending',
+            'Rewind is in progress. Wait for the conversation to reload.'
+          )
+      : blockedReason(input)
+  const blockedRef = useRef(false)
+  useLayoutEffect(() => {
+    blockedRef.current = pending || awaitingReset
+  }, [pending, awaitingReset])
+
+  const request = useCallback(async (itemId: string, confirm: ConfirmationDialogContextValue) => {
+    const captured = latest.current
+    if (inFlight.current || blockedRef.current || blockedReason(captured)) {
+      return
+    }
+    const expectedEpoch = captured.state.epoch!
+    const count = countNativeChatRewindMessages(captured.state, itemId)
+    if (!count) {
+      return
+    }
+    inFlight.current = true
+    blockedRef.current = true
+    setPending(true)
+    setError(null)
+    let keepBlocked = false
+    try {
+      const confirmed = await confirm({
+        title: translate('components.native-chat.rewind.title', 'Revert to here?'),
+        description: translate(
+          'components.native-chat.rewind.confirmation',
+          'Discard this message and every later message ({{count}} messages total)? This cannot be undone. Your composer draft and attachments will be cleared. File changes on disk will be kept.',
+          { count }
+        ),
+        confirmLabel: translate('components.native-chat.rewind.confirm', 'Discard messages'),
+        cancelLabel: translate('components.native-chat.rewind.cancel', 'Cancel'),
+        confirmVariant: 'destructive',
+        cancelVariant: 'ghost'
+      })
+      if (!confirmed) {
+        return
+      }
+      const current = latest.current
+      if (!active.current || current.sessionId !== captured.sessionId) {
+        return
+      }
+      if (
+        current.state.epoch !== expectedEpoch ||
+        current.state.cursor?.sequence !== captured.state.cursor?.sequence
+      ) {
+        setError(nativeChatRewindReasonCopy('stale-epoch'))
+        return
+      }
+      const reason = blockedReason(current)
+      if (reason) {
+        setError(reason)
+        return
+      }
+      const result = await current.send({ itemId, expectedEpoch }, (refusal) => {
+        if (
+          !active.current ||
+          latest.current.sessionId !== captured.sessionId ||
+          latest.current.state.epoch !== expectedEpoch
+        ) {
+          return
+        }
+        const unknown =
+          !refusal ||
+          refusal.rewindReason === 'outcome-unknown' ||
+          refusal.code === 'agent_session_operation_unknown'
+        setError(nativeChatRewindReasonCopy(unknown ? 'outcome-unknown' : refusal.rewindReason))
+        if (unknown) {
+          keepBlocked = latest.current.state.epoch === expectedEpoch
+          setSettlement({ sessionId: captured.sessionId, epoch: expectedEpoch })
+        }
+      })
+      if (result && active.current && latest.current.sessionId === captured.sessionId) {
+        keepBlocked = latest.current.state.epoch === expectedEpoch
+        setSettlement({
+          sessionId: captured.sessionId,
+          epoch: expectedEpoch,
+          nextEpoch: result.epoch
+        })
+        current.refresh()
+      }
+    } finally {
+      inFlight.current = false
+      blockedRef.current = keepBlocked
+      setPending(false)
+    }
+  }, [])
+  return { request, disabledReason, pending: pending || awaitingReset, blockedRef, error }
+}
diff --git a/src/renderer/src/components/native-chat/use-structured-agent-session-mutation.ts b/src/renderer/src/components/native-chat/use-structured-agent-session-mutation.ts
new file mode 100644
index 000000000000..d8b6b55c6a6c
--- /dev/null
+++ b/src/renderer/src/components/native-chat/use-structured-agent-session-mutation.ts
@@ -0,0 +1,104 @@
+import { translate } from '@/i18n/i18n'
+import { useCallback, useEffect, useRef, useState } from 'react'
+import type {
+  AgentSessionMutationResult,
+  AgentSessionWireRefusal
+} from '../../../../shared/agent-session-wire'
+import { hasRuntimeRpcErrorCode } from '../../../../shared/runtime-rpc-error-code'
+import { agentSessionRefusalOperationState } from '../../../../shared/agent-session-refusal-retry'
+import { structuredAgentSessionPayloadFingerprint } from '../../../../shared/structured-agent-session-mutation'
+import type { RuntimeClientTarget } from '@/runtime/runtime-rpc-client'
+import { callStructuredAgentSession } from '@/runtime/structured-agent-session-client'
+import { structuredSessionOperationId } from './use-structured-agent-session-outbox'
+import * as conversationCommands from './structured-conversation-command-send'
+
+export function useStructuredAgentSessionMutation(
+  sessionId: string,
+  target: RuntimeClientTarget,
+  fence: number | null
+) {
+  const stateRef = useRef({ fence })
+  const [writeError, setWriteError] = useState<string | null>(null)
+  const operationIds = useRef(new Map<string, string>())
+  useEffect(() => {
+    stateRef.current = { fence }
+  }, [fence])
+  const mutate = useCallback(
+    async <T>(
+      method: string,
+      fingerprintMethod: string,
+      fields: Record<string, unknown>,
+      operationIdOverride?: string | null,
+      onFailure?: (refusal?: AgentSessionWireRefusal) => void
+    ): Promise<T | null> => {
+      if (stateRef.current.fence === null) {
+        return null
+      }
+      const targetFence = stateRef.current.fence
+      const key = `${sessionId}:${fingerprintMethod}:${JSON.stringify(fields)}`
+      const clientOperationId =
+        operationIdOverride ?? operationIds.current.get(key) ?? structuredSessionOperationId()
+      operationIds.current.set(key, clientOperationId)
+      let result: AgentSessionMutationResult<T>
+      try {
+        result = await callStructuredAgentSession<AgentSessionMutationResult<T>>(target, method, {
+          envelope: {
+            sessionId,
+            clientOperationId,
+            expectedRuntimeFence: targetFence,
+            payloadFingerprint: structuredAgentSessionPayloadFingerprint({
+              method: fingerprintMethod,
+              sessionId,
+              fields
+            })
+          },
+          ...fields
+        })
+      } catch (error) {
+        if (onFailure) {
+          onFailure(
+            hasRuntimeRpcErrorCode(error, 'method_not_found')
+              ? {
+                  code: 'structured_agent_session_unsupported',
+                  message: '',
+                  rewindReason: 'unsupported'
+                }
+              : undefined
+          )
+        } else if (stateRef.current.fence === targetFence) {
+          setWriteError(
+            error instanceof Error
+              ? error.message
+              : translate('components.native-chat.requestNotSent', 'Request was not sent')
+          )
+        }
+        return null
+      }
+      if (!result.ok) {
+        if (
+          agentSessionRefusalOperationState(fingerprintMethod, result.refusal.code) ===
+          'settled-rejected'
+        ) {
+          operationIds.current.delete(key)
+        }
+        if (onFailure) {
+          onFailure(result.refusal)
+        } else if (stateRef.current.fence === targetFence) {
+          setWriteError(result.refusal.message)
+        }
+        return null
+      }
+      if (stateRef.current.fence !== targetFence && fingerprintMethod !== 'agentSession.rewind') {
+        return null
+      }
+      if (!conversationCommands.isUnconfirmedConversationCommand(fingerprintMethod, result.value)) {
+        operationIds.current.delete(key)
+      }
+      setWriteError(null)
+      return result.value
+    },
+    [sessionId, target]
+  )
+
+  return { mutate, writeError }
+}
diff --git a/src/renderer/src/components/native-chat/use-structured-agent-session-read.ts b/src/renderer/src/components/native-chat/use-structured-agent-session-read.ts
index 834d11d3fa1d..e398f31920bf 100644
--- a/src/renderer/src/components/native-chat/use-structured-agent-session-read.ts
+++ b/src/renderer/src/components/native-chat/use-structured-agent-session-read.ts
@@ -47,6 +47,7 @@ export function useStructuredAgentSessionRead(args: {
     state: snapshot.state,
     loadingOlder: snapshot.loadingOlder,
     loadOlder: owner.loadOlder,
+    refresh: owner.refresh,
     providerSession: snapshot.providerSession
   }
 }
diff --git a/src/renderer/src/components/native-chat/use-structured-agent-session.test.tsx b/src/renderer/src/components/native-chat/use-structured-agent-session.test.tsx
index abf185cb9136..d5687e44cff9 100644
--- a/src/renderer/src/components/native-chat/use-structured-agent-session.test.tsx
+++ b/src/renderer/src/components/native-chat/use-structured-agent-session.test.tsx
@@ -1,4 +1,5 @@
 // @vitest-environment happy-dom
+import type { AgentJournalRenderItem } from '../../../../shared/agent-session-journal-types'
 
 import { act, renderHook, waitFor } from '@testing-library/react'
 import { beforeEach, describe, expect, it, vi } from 'vitest'
@@ -6,9 +7,12 @@ import { beforeEach, describe, expect, it, vi } from 'vitest'
 const mocks = vi.hoisted(() => ({
   call: vi.fn(),
   operationId: vi.fn(),
-  enqueueSettingsWrite: vi.fn()
+  enqueueSettingsWrite: vi.fn(),
+  refresh: vi.fn()
 }))
 let fence = 3
+let rewindItems: AgentJournalRenderItem[] = []
+let epoch = 'epoch-1'
 let sessionCommands: { name: string; kind: 'command' | 'skill' }[] | undefined
 
 vi.mock('@/runtime/structured-agent-session-client', () => ({
@@ -23,8 +27,10 @@ vi.mock('./use-structured-agent-session-read', () => ({
   useStructuredAgentSessionRead: () => ({
     state: {
       fence,
+      epoch,
+      cursor: { epoch, sequence: 2 },
       commands: sessionCommands,
-      items: [],
+      items: rewindItems,
       submissions: [],
       status: 'ready',
       error: null,
@@ -32,7 +38,8 @@ vi.mock('./use-structured-agent-session-read', () => ({
       handoff: null
     },
     loadingOlder: false,
-    loadOlder: vi.fn()
+    loadOlder: vi.fn(),
+    refresh: mocks.refresh
   })
 }))
 
@@ -523,3 +530,108 @@ describe('session command catalog stream', () => {
     ).toHaveLength(0)
   })
 })
+
+describe('useStructuredAgentSession rewind RPC', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    fence = 3
+    epoch = 'epoch-1'
+    rewindItems = [
+      {
+        itemId: 'user-1',
+        sequence: 1,
+        revision: 1,
+        observedAt: 1,
+        body: { kind: 'message', role: 'user', blocks: [{ type: 'text', text: 'Prompt' }] }
+      }
+    ]
+    mocks.operationId.mockReset().mockReturnValue('rewind-operation')
+    mocks.call.mockImplementation((_target, method) =>
+      Promise.resolve(
+        method === 'agentSession.options'
+          ? { ...OPTIONS, rewind: { supported: true } }
+          : { ok: true, value: { itemId: 'user-1', epoch: 'epoch-2' } }
+      )
+    )
+  })
+
+  it('sends the agreed verb and fingerprint to the execution host and blocks the composer until reset', async () => {
+    const target = { kind: 'environment' as const, environmentId: 'ssh-host' }
+    const view = renderHook(() =>
+      useStructuredAgentSession({ sessionId: 'session-1', target, agent: 'codex', isVisible: true })
+    )
+    await waitFor(() => expect(view.result.current.rewind.disabledReason).toBeNull())
+    await act(() => view.result.current.rewind.request('user-1', async () => true))
+    const { structuredAgentSessionPayloadFingerprint } =
+      await import('../../../../shared/structured-agent-session-mutation')
+    expect(mocks.call).toHaveBeenCalledWith(target, 'agentSession.rewind', {
+      envelope: {
+        sessionId: 'session-1',
+        clientOperationId: 'rewind-operation',
+        expectedRuntimeFence: 3,
+        payloadFingerprint: structuredAgentSessionPayloadFingerprint({
+          method: 'agentSession.rewind',
+          sessionId: 'session-1',
+          fields: { itemId: 'user-1', expectedEpoch: 'epoch-1' }
+        })
+      },
+      itemId: 'user-1',
+      expectedEpoch: 'epoch-1'
+    })
+    expect(view.result.current.send('stale composer text', [])).toBe(false)
+    expect(mocks.refresh).toHaveBeenCalledOnce()
+    epoch = 'epoch-2'
+    rewindItems = []
+    view.rerender()
+    expect(view.result.current.messages).toEqual([])
+    expect(view.result.current.rewind.pending).toBe(false)
+  })
+
+  it('renders reason-only host refusals without relying on host English', async () => {
+    mocks.call.mockImplementation((_target, method) =>
+      Promise.resolve(
+        method === 'agentSession.options'
+          ? OPTIONS
+          : {
+              ok: false,
+              refusal: {
+                code: 'agent_session_conflict',
+                message: '',
+                rewindReason: 'proof-mismatch'
+              }
+            }
+      )
+    )
+    const view = renderHook(() =>
+      useStructuredAgentSession({
+        sessionId: 'session-1',
+        target: LOCAL_TARGET,
+        agent: 'claude',
+        isVisible: true
+      })
+    )
+    await waitFor(() => expect(view.result.current.rewind.disabledReason).toBeNull())
+    await act(() => view.result.current.rewind.request('user-1', async () => true))
+    expect(view.result.current.error).toContain('could not verify the conversation boundary')
+  })
+
+  it('explains an older host missing the RPC without claiming an uncertain rewind occurred', async () => {
+    mocks.call.mockImplementation((_target, method) =>
+      method === 'agentSession.rewind'
+        ? Promise.reject({ code: 'method_not_found' })
+        : Promise.resolve(OPTIONS)
+    )
+    const view = renderHook(() =>
+      useStructuredAgentSession({
+        sessionId: 'session-1',
+        target: LOCAL_TARGET,
+        agent: 'codex',
+        isVisible: true
+      })
+    )
+    await waitFor(() => expect(view.result.current.rewind.disabledReason).toBeNull())
+    await act(() => view.result.current.rewind.request('user-1', async () => true))
+    expect(view.result.current.error).toContain('does not support rewinding')
+    expect(view.result.current.rewind.pending).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 d32ad3383dd6..bb6acc4f853b 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
@@ -1,3 +1,9 @@
+import { useStructuredAgentSessionMutation } from './use-structured-agent-session-mutation'
+import { useNativeChatRewind } from './use-native-chat-rewind'
+import type {
+  AgentSessionRewindResult,
+  AgentSessionRewindSupport
+} from '../../../../shared/agent-session-rewind'
 import * as conversationCommands from './structured-conversation-command-send'
 import { useCallback, useEffect, useMemo, useRef, useState } from 'react'
 import type {
@@ -6,15 +12,12 @@ import type {
 } from '../../../../shared/agent-session-conversation-command'
 import type { AgentType } from '../../../../shared/agent-status-types'
 import type {
-  AgentSessionMutationResult,
   AgentSessionOptionResult,
   AgentSessionOptionsResult,
   AgentSessionPromptResult
 } from '../../../../shared/agent-session-wire'
 import { getAgentSessionOptionCatalog } from '../../../../shared/agent-session-option-catalog'
 import type { SessionOptionsSurface } from '../../../../shared/native-chat-session-options'
-import { agentSessionRefusalOperationState } from '../../../../shared/agent-session-refusal-retry'
-import { structuredAgentSessionPayloadFingerprint } from '../../../../shared/structured-agent-session-mutation'
 import {
   applyStructuredAgentSessionOptions,
   canSetStructuredAgentSessionOption,
@@ -26,10 +29,7 @@ import {
 import { activeStructuredAgentSessionTurnId } from '../../../../shared/structured-agent-session-projection'
 import type { RuntimeClientTarget } from '@/runtime/runtime-rpc-client'
 import { callStructuredAgentSession } from '@/runtime/structured-agent-session-client'
-import {
-  structuredSessionOperationId,
-  useStructuredAgentSessionOutbox
-} from './use-structured-agent-session-outbox'
+import { useStructuredAgentSessionOutbox } from './use-structured-agent-session-outbox'
 import { useStructuredAgentSessionHold } from './use-structured-agent-session-hold'
 import { useStructuredAgentSessionRead } from './use-structured-agent-session-read'
 import {
@@ -57,17 +57,17 @@ export function useStructuredAgentSession(args: {
     surface: 'desktop-chat',
     enabled: isVisible
   })
-  const { state, loadingOlder, loadOlder } = useStructuredAgentSessionRead({
+  const { state, loadingOlder, loadOlder, refresh } = useStructuredAgentSessionRead({
     sessionId,
     target,
     isVisible
   })
-  const stateRef = useRef(state)
-  const [writeError, setWriteError] = useState<string | null>(null)
-  const operationIds = useRef(new Map<string, string>())
+  const { mutate, writeError } = useStructuredAgentSessionMutation(sessionId, target, state.fence)
   const [conversationSupport, setConversationSupport] = useState<{
     sessionId: string
     commands: readonly AgentSessionConversationCommand[]
+    rewind?: AgentSessionRewindSupport
+    fence: number | null
   } | null>(null)
   const commandPending = useRef(false)
   const [optionState, setOptionState] = useState(() =>
@@ -82,76 +82,12 @@ export function useStructuredAgentSession(args: {
     submissions: state.submissions
   })
 
-  useEffect(() => {
-    stateRef.current = state
-  }, [state])
-
   useEffect(() => {
     const next = createStructuredAgentSessionOptionState(agent)
     activeOptionRecordRef.current = next.record
     setOptionState(next)
   }, [agent, sessionId, state.fence])
 
-  const mutate = useCallback(
-    async <T>(
-      method: string,
-      fingerprintMethod: string,
-      fields: Record<string, unknown>,
-      operationIdOverride?: string | null
-    ): Promise<T | null> => {
-      if (stateRef.current.fence === null) {
-        return null
-      }
-      const targetFence = stateRef.current.fence
-      const key = `${sessionId}:${fingerprintMethod}:${JSON.stringify(fields)}`
-      const clientOperationId =
-        operationIdOverride ?? operationIds.current.get(key) ?? structuredSessionOperationId()
-      operationIds.current.set(key, clientOperationId)
-      let result: AgentSessionMutationResult<T>
-      try {
-        result = await callStructuredAgentSession<AgentSessionMutationResult<T>>(target, method, {
-          envelope: {
-            sessionId,
-            clientOperationId,
-            expectedRuntimeFence: targetFence,
-            payloadFingerprint: structuredAgentSessionPayloadFingerprint({
-              method: fingerprintMethod,
-              sessionId,
-              fields
-            })
-          },
-          ...fields
-        })
-      } catch (error) {
-        if (stateRef.current.fence === targetFence) {
-          setWriteError(error instanceof Error ? error.message : 'Request was not sent')
-        }
-        return null
-      }
-      if (!result.ok) {
-        if (
-          agentSessionRefusalOperationState(fingerprintMethod, result.refusal.code) ===
-          'settled-rejected'
-        ) {
-          operationIds.current.delete(key)
-        }
-        if (stateRef.current.fence === targetFence) {
-          setWriteError(result.refusal.message)
-        }
-        return null
-      }
-      if (stateRef.current.fence !== targetFence) {
-        return null
-      }
-      if (!conversationCommands.isUnconfirmedConversationCommand(fingerprintMethod, result.value)) {
-        operationIds.current.delete(key)
-      }
-      setWriteError(null)
-      return result.value
-    },
-    [sessionId, target]
-  )
-
   // Refresh options each turn to confirm which model the provider actually selected.
   const turnId = activeStructuredAgentSessionTurnId(state.items)
   const turnActivity = useMemo(
@@ -171,7 +107,12 @@ export function useStructuredAgentSession(args: {
     })
       .then((result) => {
         if (!stale) {
-          setConversationSupport({ sessionId, commands: result.conversationCommands ?? [] })
+          setConversationSupport({
+            sessionId,
+            commands: result.conversationCommands ?? [],
+            rewind: result.rewind,
+            fence: state.fence
+          })
           setOptionState((current) =>
             current.record === activeOptionRecordRef.current
               ? applyStructuredAgentSessionOptions(current, optionCatalog, result)
@@ -250,7 +191,35 @@ export function useStructuredAgentSession(args: {
   )
 
   const prompts = pendingStructuredSessionPrompts(state.items)
+  const rewind = useNativeChatRewind({
+    sessionId,
+    state,
+    support:
+      conversationSupport?.sessionId === sessionId && conversationSupport.fence === state.fence
+        ? conversationSupport.rewind
+        : undefined,
+    supportResolved:
+      conversationSupport?.sessionId === sessionId && conversationSupport.fence === state.fence,
+    blocked: Boolean(
+      turnId ||
+      prompts.length ||
+      isMonitoringBackgroundTasks ||
+      outboxController.outbox.length ||
+      commandPending.current
+    ),
+    send: (fields, onFailure) =>
+      mutate<AgentSessionRewindResult>(
+        'agentSession.rewind',
+        'agentSession.rewind',
+        fields,
+        undefined,
+        onFailure
+      ),
+    refresh
+  })
   return {
+    epoch: state.epoch,
+    rewind,
     conversationCommands:
       conversationSupport?.sessionId === sessionId ? conversationSupport.commands : [],
     runConversationCommand: (command: AgentSessionConversationCommand) =>
@@ -258,7 +227,11 @@ export function useStructuredAgentSession(args: {
         command,
         pending: commandPending,
         blocked: Boolean(
-          turnId || prompts.length || isMonitoringBackgroundTasks || outboxController.outbox.length
+          turnId ||
+          prompts.length ||
+          isMonitoringBackgroundTasks ||
+          outboxController.outbox.length ||
+          rewind.blockedRef.current
         ),
         send: (command) =>
           mutate<AgentSessionConversationCommandResult>(
@@ -273,7 +246,7 @@ export function useStructuredAgentSession(args: {
       state.submissions
     ),
     status: state.status,
-    error: state.error ?? writeError ?? outboxController.error,
+    error: rewind.error ?? state.error ?? writeError ?? outboxController.error,
     hasOlder: state.hasOlder,
     loadingOlder,
     loadOlder,
@@ -281,7 +254,7 @@ export function useStructuredAgentSession(args: {
     outbox: outboxController.outbox,
     blockedClientMessageId: outboxController.blockedClientMessageId,
     send: (...input: Parameters<typeof outboxController.send>) =>
-      !commandPending.current && outboxController.send(...input),
+      !commandPending.current && !rewind.blockedRef.current && outboxController.send(...input),
     retry: outboxController.retry,
     isWorking: turnId !== null,
     turnActivity,
diff --git a/src/renderer/src/i18n/locales/en.json b/src/renderer/src/i18n/locales/en.json
index cf00f09b861e..d582d58f1932 100644
--- a/src/renderer/src/i18n/locales/en.json
+++ b/src/renderer/src/i18n/locales/en.json
@@ -17148,7 +17148,27 @@
       "conversationCommand": {
         "pendingWork": "Wait for pending work and messages to finish before using this command.",
         "unconfirmed": "Conversation operation was not confirmed."
-      }
+      },
+      "rewind": {
+        "unsupported": "This session does not support rewinding conversation history.",
+        "historyNotPaginated": "This older Codex conversation does not support rewinding. Start a new conversation to use rewind.",
+        "busy": "Wait for the current turn, pending messages, approvals, and background work to finish before rewinding.",
+        "staleEpoch": "The conversation changed. Review the latest messages before rewinding.",
+        "invalidTarget": "This message is no longer a valid rewind point. Review the latest conversation.",
+        "historyLimit": "This conversation is too large to rewind safely.",
+        "providerRefused": "The agent refused to rewind this conversation.",
+        "proofMismatch": "Orca could not verify the conversation boundary. Reload the session before trying again.",
+        "outcomeUnknown": "The rewind may have completed, but Orca could not confirm it. Sending is blocked until the session is reloaded or the outcome is resolved.",
+        "refused": "Orca could not rewind this conversation. Reload the session to check its current state.",
+        "unavailable": "Reconnect to a writable chat session before rewinding.",
+        "pending": "Rewind is in progress. Wait for the conversation to reload.",
+        "title": "Revert to here?",
+        "confirmation": "Discard this message and every later message ({{count}} messages total)? This cannot be undone. Your composer draft and attachments will be cleared. File changes on disk will be kept.",
+        "confirm": "Discard messages",
+        "cancel": "Cancel",
+        "action": "Revert to here"
+      },
+      "requestNotSent": "Request was not sent"
     },
     "tab": {
       "bar": {

From a8f3a5e34e57a177e66e11f78a41da92adef1001 Mon Sep 17 00:00:00 2001
From: Merge Sim <sim@local>
Date: Mon, 7 Sep 2026 00:43:17 -0700
Subject: [PATCH 02/22] fix(native-chat): retain rewind uncertainty from host
 status

---
 .../StructuredAgentSessionStatusBridge.tsx    | 20 +++-------------
 .../native-chat/native-chat-rewind-copy.ts    |  2 +-
 .../use-native-chat-rewind.test.tsx           | 24 ++++++++++++++++++-
 .../native-chat/use-native-chat-rewind.ts     | 24 ++++++++++++++-----
 ...structured-agent-session-status-summary.ts | 18 ++++++++++++++
 .../use-structured-agent-session.test.tsx     |  4 ++++
 .../use-structured-agent-session.ts           |  3 +++
 src/renderer/src/i18n/locales/en.json         |  2 +-
 8 files changed, 71 insertions(+), 26 deletions(-)
 create mode 100644 src/renderer/src/components/native-chat/use-structured-agent-session-status-summary.ts

diff --git a/src/renderer/src/components/native-chat/StructuredAgentSessionStatusBridge.tsx b/src/renderer/src/components/native-chat/StructuredAgentSessionStatusBridge.tsx
index a72f28d7c081..0362a63ebfe9 100644
--- a/src/renderer/src/components/native-chat/StructuredAgentSessionStatusBridge.tsx
+++ b/src/renderer/src/components/native-chat/StructuredAgentSessionStatusBridge.tsx
@@ -1,4 +1,4 @@
-import { useEffect, useMemo, useSyncExternalStore } from 'react'
+import { useEffect, useMemo } from 'react'
 import { useShallow } from 'zustand/react/shallow'
 import { agentProviderSessionsEqual } from '../../../../shared/agent-session-resume'
 import type { AgentSessionStatusSummary } from '../../../../shared/agent-session-wire'
@@ -7,8 +7,8 @@ import type { Tab } from '../../../../shared/tab-types'
 import { isAgentSessionHandleProvider } from '../../../../shared/agent-session-provider-handle'
 import { getRuntimeEnvironmentIdForWorktree } from '@/lib/worktree-runtime-owner'
 import { useAppStore } from '@/store'
-import { getActiveRuntimeTarget, type RuntimeClientTarget } from '@/runtime/runtime-rpc-client'
-import { getStructuredAgentSessionStatusFeed } from '@/runtime/structured-agent-session-status-feed'
+import { getActiveRuntimeTarget } from '@/runtime/runtime-rpc-client'
+import { useStructuredAgentSessionStatusSummary } from './use-structured-agent-session-status-summary'
 
 type StructuredTab = Tab & { contentType: 'agent-session' }
 
@@ -42,20 +42,6 @@ export function getStructuredAgentSessionTabs(
   return tabs
 }
 
-/** The host's projected status for one session, live while the caller is mounted. */
-function useStructuredAgentSessionStatusSummary(
-  sessionId: string,
-  target: RuntimeClientTarget
-): AgentSessionStatusSummary | null {
-  const feed = useMemo(() => getStructuredAgentSessionStatusFeed(target), [target])
-  useEffect(() => feed.activate(), [feed])
-  return useSyncExternalStore(
-    feed.subscribe,
-    () => feed.getSnapshot().get(sessionId) ?? null,
-    () => null
-  )
-}
-
 function projectStatus(tab: StructuredTab, summary: AgentSessionStatusSummary | null): void {
   const paneKey = structuredAgentSessionPaneKey(tab.id, tab.entityId)
   const store = useAppStore.getState()
diff --git a/src/renderer/src/components/native-chat/native-chat-rewind-copy.ts b/src/renderer/src/components/native-chat/native-chat-rewind-copy.ts
index dec800791af8..6ac70c565a32 100644
--- a/src/renderer/src/components/native-chat/native-chat-rewind-copy.ts
+++ b/src/renderer/src/components/native-chat/native-chat-rewind-copy.ts
@@ -30,7 +30,7 @@ const reasonCopy = {
   'history-limit': () =>
     translate(
       'components.native-chat.rewind.historyLimit',
-      'This conversation is too large to rewind safely.'
+      'This conversation is too large to rewind safely. Nothing was changed.'
     ),
   'provider-refused': () =>
     translate(
diff --git a/src/renderer/src/components/native-chat/use-native-chat-rewind.test.tsx b/src/renderer/src/components/native-chat/use-native-chat-rewind.test.tsx
index e22b9c67ccec..5cce5e30e418 100644
--- a/src/renderer/src/components/native-chat/use-native-chat-rewind.test.tsx
+++ b/src/renderer/src/components/native-chat/use-native-chat-rewind.test.tsx
@@ -84,6 +84,25 @@ describe('structured chat rewind', () => {
     expect(view.result.current.pending).toBe(false)
   })
 
+  it('keeps sending blocked after reopening while the host reports an unresolved rewind', async () => {
+    const props: Parameters<typeof useNativeChatRewind>[0] = {
+      ...input(),
+      hostBlockedReason: 'outcome-unknown'
+    }
+    const view = renderHook((value) => useNativeChatRewind(value), { initialProps: props })
+    expect(view.result.current.error).toContain('may have completed')
+    expect(view.result.current.disabledReason).toContain('Sending is blocked')
+    expect(view.result.current.blockedRef.current).toBe(true)
+    expect(view.result.current.pending).toBe(true)
+    const confirm = vi.fn()
+    await act(() => view.result.current.request('user', confirm))
+    expect(confirm).not.toHaveBeenCalled()
+    view.rerender({ ...props, hostBlockedReason: undefined })
+    expect(view.result.current.error).toBeNull()
+    expect(view.result.current.pending).toBe(false)
+    expect(view.result.current.blockedRef.current).toBe(false)
+  })
+
   it('does not execute a confirmation after its pane unmounts', async () => {
     const props = input(),
       confirmation = deferred<boolean>()
@@ -208,12 +227,15 @@ describe('structured chat rewind', () => {
   ])('explains refusal %s', async (rewindReason) => {
     const props = input()
     props.send.mockImplementation(async (_fields, failure) => {
-      failure({ code: 'unsupported', rewindReason })
+      failure({ code: 'agent_session_conflict', rewindReason })
       return null
     })
     const view = renderHook(() => useNativeChatRewind(props))
     await act(() => view.result.current.request('user', async () => true))
     expect(view.result.current.error).toBe(nativeChatRewindReasonCopy(rewindReason))
+    if (rewindReason === 'history-limit') {
+      expect(view.result.current.error).toContain('Nothing was changed')
+    }
     if (rewindReason === 'outcome-unknown') {
       expect(view.result.current.error).toContain('may have completed')
       expect(view.result.current.error).toContain('Sending is blocked')
diff --git a/src/renderer/src/components/native-chat/use-native-chat-rewind.ts b/src/renderer/src/components/native-chat/use-native-chat-rewind.ts
index d5a657eba902..b604cdfc1ad8 100644
--- a/src/renderer/src/components/native-chat/use-native-chat-rewind.ts
+++ b/src/renderer/src/components/native-chat/use-native-chat-rewind.ts
@@ -2,6 +2,7 @@ import { useCallback, useLayoutEffect, useRef, useState } from 'react'
 import type { ConfirmationDialogContextValue } from '@/components/confirmation-dialog-context'
 import { translate } from '@/i18n/i18n'
 import type {
+  AgentSessionRewindReason,
   AgentSessionRewindResult,
   AgentSessionRewindSupport
 } from '../../../../shared/agent-session-rewind'
@@ -22,6 +23,7 @@ type RewindInput = {
   state: StructuredAgentSessionState
   support: AgentSessionRewindSupport | undefined
   supportResolved: boolean
+  hostBlockedReason?: AgentSessionRewindReason
   blocked: boolean
   send: (
     fields: { itemId: string; expectedEpoch: string },
@@ -43,6 +45,9 @@ export function countNativeChatRewindMessages(
 }
 
 function blockedReason(input: RewindInput): string | null {
+  if (input.hostBlockedReason) {
+    return nativeChatRewindReasonCopy(input.hostBlockedReason)
+  }
   if (input.support?.supported === false) {
     return nativeChatRewindReasonCopy(input.support.reason)
   }
@@ -89,8 +94,9 @@ export function useNativeChatRewind(input: RewindInput) {
       message ? { sessionId: current.sessionId, epoch: current.state.epoch, message } : null
     )
   }
-  const error =
-    failure?.sessionId === input.sessionId && failure.epoch === input.state.epoch
+  const error = input.hostBlockedReason
+    ? nativeChatRewindReasonCopy(input.hostBlockedReason)
+    : failure?.sessionId === input.sessionId && failure.epoch === input.state.epoch
       ? failure.message
       : null
   const awaitingReset =
@@ -106,8 +112,8 @@ export function useNativeChatRewind(input: RewindInput) {
       : blockedReason(input)
   const blockedRef = useRef(false)
   useLayoutEffect(() => {
-    blockedRef.current = pending || awaitingReset
-  }, [pending, awaitingReset])
+    blockedRef.current = pending || awaitingReset || Boolean(input.hostBlockedReason)
+  }, [pending, awaitingReset, input.hostBlockedReason])
 
   const request = useCallback(async (itemId: string, confirm: ConfirmationDialogContextValue) => {
     const captured = latest.current
@@ -185,9 +191,15 @@ export function useNativeChatRewind(input: RewindInput) {
       }
     } finally {
       inFlight.current = false
-      blockedRef.current = keepBlocked
+      blockedRef.current = keepBlocked || Boolean(latest.current.hostBlockedReason)
       setPending(false)
     }
   }, [])
-  return { request, disabledReason, pending: pending || awaitingReset, blockedRef, error }
+  return {
+    request,
+    disabledReason,
+    pending: pending || awaitingReset || Boolean(input.hostBlockedReason),
+    blockedRef,
+    error
+  }
 }
diff --git a/src/renderer/src/components/native-chat/use-structured-agent-session-status-summary.ts b/src/renderer/src/components/native-chat/use-structured-agent-session-status-summary.ts
new file mode 100644
index 000000000000..c083be6c4423
--- /dev/null
+++ b/src/renderer/src/components/native-chat/use-structured-agent-session-status-summary.ts
@@ -0,0 +1,18 @@
+import { useEffect, useMemo, useSyncExternalStore } from 'react'
+import type { AgentSessionStatusSummary } from '../../../../shared/agent-session-wire'
+import type { RuntimeClientTarget } from '@/runtime/runtime-rpc-client'
+import { getStructuredAgentSessionStatusFeed } from '@/runtime/structured-agent-session-status-feed'
+
+/** The host's projected status for one session, live while the caller is mounted. */
+export function useStructuredAgentSessionStatusSummary(
+  sessionId: string,
+  target: RuntimeClientTarget
+): AgentSessionStatusSummary | null {
+  const feed = useMemo(() => getStructuredAgentSessionStatusFeed(target), [target])
+  useEffect(() => feed.activate(), [feed])
+  return useSyncExternalStore(
+    feed.subscribe,
+    () => feed.getSnapshot().get(sessionId) ?? null,
+    () => null
+  )
+}
diff --git a/src/renderer/src/components/native-chat/use-structured-agent-session.test.tsx b/src/renderer/src/components/native-chat/use-structured-agent-session.test.tsx
index d5687e44cff9..c517a044ad18 100644
--- a/src/renderer/src/components/native-chat/use-structured-agent-session.test.tsx
+++ b/src/renderer/src/components/native-chat/use-structured-agent-session.test.tsx
@@ -19,6 +19,10 @@ vi.mock('@/runtime/structured-agent-session-client', () => ({
   callStructuredAgentSession: mocks.call
 }))
 
+vi.mock('./use-structured-agent-session-status-summary', () => ({
+  useStructuredAgentSessionStatusSummary: () => null
+}))
+
 vi.mock('./native-chat-session-option-settings-write', () => ({
   enqueueSessionOptionSettingsWrite: mocks.enqueueSettingsWrite
 }))
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 bb6acc4f853b..2a992e2b9978 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
@@ -1,3 +1,4 @@
+import { useStructuredAgentSessionStatusSummary } from './use-structured-agent-session-status-summary'
 import { useStructuredAgentSessionMutation } from './use-structured-agent-session-mutation'
 import { useNativeChatRewind } from './use-native-chat-rewind'
 import type {
@@ -49,6 +50,7 @@ export function useStructuredAgentSession(args: {
   isVisible: boolean
 }) {
   const { agent, isVisible, sessionId, target } = args
+  const summary = useStructuredAgentSessionStatusSummary(sessionId, target)
   // Declared first: the hold is what gives a restored session its provider child back, and the
   // read below is useless for sending until it lands.
   useStructuredAgentSessionHold({
@@ -193,6 +195,7 @@ export function useStructuredAgentSession(args: {
   const prompts = pendingStructuredSessionPrompts(state.items)
   const rewind = useNativeChatRewind({
     sessionId,
+    hostBlockedReason: summary?.rewindBlockedReason,
     state,
     support:
       conversationSupport?.sessionId === sessionId && conversationSupport.fence === state.fence
diff --git a/src/renderer/src/i18n/locales/en.json b/src/renderer/src/i18n/locales/en.json
index d582d58f1932..97f00283c418 100644
--- a/src/renderer/src/i18n/locales/en.json
+++ b/src/renderer/src/i18n/locales/en.json
@@ -17155,7 +17155,7 @@
         "busy": "Wait for the current turn, pending messages, approvals, and background work to finish before rewinding.",
         "staleEpoch": "The conversation changed. Review the latest messages before rewinding.",
         "invalidTarget": "This message is no longer a valid rewind point. Review the latest conversation.",
-        "historyLimit": "This conversation is too large to rewind safely.",
+        "historyLimit": "This conversation is too large to rewind safely. Nothing was changed.",
         "providerRefused": "The agent refused to rewind this conversation.",
         "proofMismatch": "Orca could not verify the conversation boundary. Reload the session before trying again.",
         "outcomeUnknown": "The rewind may have completed, but Orca could not confirm it. Sending is blocked until the session is reloaded or the outcome is resolved.",

From 2162750e1846380cc30b387a0f4a037ced1dab8b Mon Sep 17 00:00:00 2001
From: Merge Sim <sim@local>
Date: Mon, 7 Sep 2026 00:49:04 -0700
Subject: [PATCH 03/22] fix(native-chat): await the authoritative rewind epoch
 reset

---
 .../use-native-chat-rewind.test.tsx           | 31 ++++++++++++++++---
 .../native-chat/use-native-chat-rewind.ts     | 19 ++++++------
 .../use-structured-agent-session-read.ts      |  1 -
 .../use-structured-agent-session.test.tsx     |  7 ++---
 .../use-structured-agent-session.ts           |  5 ++-
 src/renderer/src/i18n/locales/en.json         |  2 +-
 6 files changed, 41 insertions(+), 24 deletions(-)

diff --git a/src/renderer/src/components/native-chat/use-native-chat-rewind.test.tsx b/src/renderer/src/components/native-chat/use-native-chat-rewind.test.tsx
index 5cce5e30e418..153896fa146d 100644
--- a/src/renderer/src/components/native-chat/use-native-chat-rewind.test.tsx
+++ b/src/renderer/src/components/native-chat/use-native-chat-rewind.test.tsx
@@ -29,8 +29,7 @@ function input() {
     support: { supported: true as const },
     supportResolved: true,
     blocked: false,
-    send: vi.fn().mockResolvedValue({ itemId: 'user', epoch: 'new' }),
-    refresh: vi.fn()
+    send: vi.fn().mockResolvedValue({ itemId: 'user', epoch: 'new' })
   }
 }
 function deferred<T>() {
@@ -53,14 +52,13 @@ describe('structured chat rewind', () => {
     expect(confirm).toHaveBeenCalledWith(
       expect.objectContaining({
         confirmVariant: 'destructive',
-        description: expect.stringContaining('3 messages total')
+        description: expect.stringContaining('3 in total')
       })
     )
     expect(props.send).toHaveBeenCalledWith(
       { itemId: 'user', expectedEpoch: 'old' },
       expect.any(Function)
     )
-    expect(props.refresh).toHaveBeenCalledOnce()
     expect(view.result.current.pending).toBe(true)
     expect(view.result.current.blockedRef.current).toBe(true)
   })
@@ -103,6 +101,30 @@ describe('structured chat rewind', () => {
     expect(view.result.current.blockedRef.current).toBe(false)
   })
 
+  it('does not label its in-flight request as an unknown outcome when the host prepares recovery', async () => {
+    const props = input(),
+      response = deferred<{ itemId: string; epoch: string }>()
+    props.send.mockReturnValue(response.promise)
+    const view = renderHook(
+      (value: Parameters<typeof useNativeChatRewind>[0]) => useNativeChatRewind(value),
+      { initialProps: props }
+    )
+    let request!: Promise<void>
+    await act(async () => {
+      request = view.result.current.request('user', async () => true)
+    })
+    view.rerender({ ...props, hostBlockedReason: 'outcome-unknown' })
+    expect(view.result.current.pending).toBe(true)
+    expect(view.result.current.error).toBeNull()
+    await act(async () => {
+      response.resolve({ itemId: 'user', epoch: 'new' })
+      await request
+    })
+    expect(view.result.current.error).toBeNull()
+    view.rerender({ ...props, state: { ...props.state, epoch: 'new' } })
+    expect(view.result.current.pending).toBe(false)
+  })
+
   it('does not execute a confirmation after its pane unmounts', async () => {
     const props = input(),
       confirmation = deferred<boolean>()
@@ -242,7 +264,6 @@ describe('structured chat rewind', () => {
       expect(view.result.current.error).not.toContain('failed')
       expect(view.result.current.pending).toBe(true)
     }
-    expect(props.refresh).not.toHaveBeenCalled()
   })
 
   it('treats a lost transport response as uncertain and never retries', async () => {
diff --git a/src/renderer/src/components/native-chat/use-native-chat-rewind.ts b/src/renderer/src/components/native-chat/use-native-chat-rewind.ts
index b604cdfc1ad8..8c314f953397 100644
--- a/src/renderer/src/components/native-chat/use-native-chat-rewind.ts
+++ b/src/renderer/src/components/native-chat/use-native-chat-rewind.ts
@@ -29,7 +29,6 @@ type RewindInput = {
     fields: { itemId: string; expectedEpoch: string },
     onFailure: (refusal?: AgentSessionWireRefusal) => void
   ) => Promise<AgentSessionRewindResult | null>
-  refresh: () => void
 }
 
 export function countNativeChatRewindMessages(
@@ -94,16 +93,19 @@ export function useNativeChatRewind(input: RewindInput) {
       message ? { sessionId: current.sessionId, epoch: current.state.epoch, message } : null
     )
   }
-  const error = input.hostBlockedReason
-    ? nativeChatRewindReasonCopy(input.hostBlockedReason)
-    : failure?.sessionId === input.sessionId && failure.epoch === input.state.epoch
-      ? failure.message
-      : null
   const awaitingReset =
     settlement?.sessionId === input.sessionId && settlement.epoch === input.state.epoch
+  const confirmedResetPending = awaitingReset && Boolean(settlement?.nextEpoch)
+  // The host also holds its recovery latch while our request is still in flight.
+  const error =
+    input.hostBlockedReason && !pending && !confirmedResetPending
+      ? nativeChatRewindReasonCopy(input.hostBlockedReason)
+      : failure?.sessionId === input.sessionId && failure.epoch === input.state.epoch
+        ? failure.message
+        : null
   const disabledReason =
     pending || awaitingReset
-      ? settlement && !settlement.nextEpoch
+      ? awaitingReset && !settlement?.nextEpoch
         ? nativeChatRewindReasonCopy('outcome-unknown')
         : translate(
             'components.native-chat.rewind.pending',
@@ -135,7 +137,7 @@ export function useNativeChatRewind(input: RewindInput) {
         title: translate('components.native-chat.rewind.title', 'Revert to here?'),
         description: translate(
           'components.native-chat.rewind.confirmation',
-          'Discard this message and every later message ({{count}} messages total)? This cannot be undone. Your composer draft and attachments will be cleared. File changes on disk will be kept.',
+          'Discard this message and every later message ({{count}} in total)? This cannot be undone. Your composer draft and attachments will be cleared. File changes on disk will be kept.',
           { count }
         ),
         confirmLabel: translate('components.native-chat.rewind.confirm', 'Discard messages'),
@@ -187,7 +189,6 @@ export function useNativeChatRewind(input: RewindInput) {
           epoch: expectedEpoch,
           nextEpoch: result.epoch
         })
-        current.refresh()
       }
     } finally {
       inFlight.current = false
diff --git a/src/renderer/src/components/native-chat/use-structured-agent-session-read.ts b/src/renderer/src/components/native-chat/use-structured-agent-session-read.ts
index e398f31920bf..834d11d3fa1d 100644
--- a/src/renderer/src/components/native-chat/use-structured-agent-session-read.ts
+++ b/src/renderer/src/components/native-chat/use-structured-agent-session-read.ts
@@ -47,7 +47,6 @@ export function useStructuredAgentSessionRead(args: {
     state: snapshot.state,
     loadingOlder: snapshot.loadingOlder,
     loadOlder: owner.loadOlder,
-    refresh: owner.refresh,
     providerSession: snapshot.providerSession
   }
 }
diff --git a/src/renderer/src/components/native-chat/use-structured-agent-session.test.tsx b/src/renderer/src/components/native-chat/use-structured-agent-session.test.tsx
index c517a044ad18..72e449c81a8e 100644
--- a/src/renderer/src/components/native-chat/use-structured-agent-session.test.tsx
+++ b/src/renderer/src/components/native-chat/use-structured-agent-session.test.tsx
@@ -7,8 +7,7 @@ import { beforeEach, describe, expect, it, vi } from 'vitest'
 const mocks = vi.hoisted(() => ({
   call: vi.fn(),
   operationId: vi.fn(),
-  enqueueSettingsWrite: vi.fn(),
-  refresh: vi.fn()
+  enqueueSettingsWrite: vi.fn()
 }))
 let fence = 3
 let rewindItems: AgentJournalRenderItem[] = []
@@ -42,8 +41,7 @@ vi.mock('./use-structured-agent-session-read', () => ({
       handoff: null
     },
     loadingOlder: false,
-    loadOlder: vi.fn(),
-    refresh: mocks.refresh
+    loadOlder: vi.fn()
   })
 }))
 
@@ -583,7 +581,6 @@ describe('useStructuredAgentSession rewind RPC', () => {
       expectedEpoch: 'epoch-1'
     })
     expect(view.result.current.send('stale composer text', [])).toBe(false)
-    expect(mocks.refresh).toHaveBeenCalledOnce()
     epoch = 'epoch-2'
     rewindItems = []
     view.rerender()
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 2a992e2b9978..e5ecb78b3aef 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
@@ -59,7 +59,7 @@ export function useStructuredAgentSession(args: {
     surface: 'desktop-chat',
     enabled: isVisible
   })
-  const { state, loadingOlder, loadOlder, refresh } = useStructuredAgentSessionRead({
+  const { state, loadingOlder, loadOlder } = useStructuredAgentSessionRead({
     sessionId,
     target,
     isVisible
@@ -217,8 +217,7 @@ export function useStructuredAgentSession(args: {
         fields,
         undefined,
         onFailure
-      ),
-    refresh
+      )
   })
   return {
     epoch: state.epoch,
diff --git a/src/renderer/src/i18n/locales/en.json b/src/renderer/src/i18n/locales/en.json
index 97f00283c418..07d636f968de 100644
--- a/src/renderer/src/i18n/locales/en.json
+++ b/src/renderer/src/i18n/locales/en.json
@@ -17163,7 +17163,7 @@
         "unavailable": "Reconnect to a writable chat session before rewinding.",
         "pending": "Rewind is in progress. Wait for the conversation to reload.",
         "title": "Revert to here?",
-        "confirmation": "Discard this message and every later message ({{count}} messages total)? This cannot be undone. Your composer draft and attachments will be cleared. File changes on disk will be kept.",
+        "confirmation": "Discard this message and every later message ({{count}} in total)? This cannot be undone. Your composer draft and attachments will be cleared. File changes on disk will be kept.",
         "confirm": "Discard messages",
         "cancel": "Cancel",
         "action": "Revert to here"

From f920c81cb470ee7f76a69c2c6d15bbb7b10b5f4b Mon Sep 17 00:00:00 2001
From: Merge Sim <sim@local>
Date: Mon, 7 Sep 2026 01:57:41 -0700
Subject: [PATCH 04/22] Pause restored chat outbox during rewind recovery

---
 .../NativeChatStructuredSession.tsx           |  1 +
 ...tured-agent-session.rewind-outbox.test.tsx | 86 +++++++++++++++++++
 .../use-structured-agent-session.ts           |  8 +-
 3 files changed, 93 insertions(+), 2 deletions(-)
 create mode 100644 src/renderer/src/components/native-chat/use-structured-agent-session.rewind-outbox.test.tsx

diff --git a/src/renderer/src/components/native-chat/NativeChatStructuredSession.tsx b/src/renderer/src/components/native-chat/NativeChatStructuredSession.tsx
index 1c1494d1f2de..4bc3c656633c 100644
--- a/src/renderer/src/components/native-chat/NativeChatStructuredSession.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatStructuredSession.tsx
@@ -321,6 +321,7 @@ function NativeChatStructuredSessionContent({
             type="button"
             variant="ghost"
             size="xs"
+            disabled={controller.rewind.pending}
             onClick={() => controller.retry(retryableOutboxEntry.clientMessageId)}
           >
             <RotateCcw className="size-3" />
diff --git a/src/renderer/src/components/native-chat/use-structured-agent-session.rewind-outbox.test.tsx b/src/renderer/src/components/native-chat/use-structured-agent-session.rewind-outbox.test.tsx
new file mode 100644
index 000000000000..74bf334ece79
--- /dev/null
+++ b/src/renderer/src/components/native-chat/use-structured-agent-session.rewind-outbox.test.tsx
@@ -0,0 +1,86 @@
+// @vitest-environment happy-dom
+
+import { act, renderHook } from '@testing-library/react'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import { EMPTY_STRUCTURED_AGENT_SESSION } from '../../../../shared/structured-agent-session-reducer'
+import {
+  enqueueStructuredAgentSessionLaunchPrompt,
+  readOutbox,
+  writeOutbox
+} from './structured-agent-session-outbox-storage'
+
+const mocks = vi.hoisted(() => ({ call: vi.fn(), blocked: true }))
+const state = {
+  ...EMPTY_STRUCTURED_AGENT_SESSION,
+  epoch: 'epoch-1',
+  fence: 3,
+  status: 'ready' as const
+}
+
+vi.mock('@/runtime/structured-agent-session-client', () => ({
+  callStructuredAgentSession: mocks.call
+}))
+vi.mock('./use-structured-agent-session-hold', () => ({
+  useStructuredAgentSessionHold: () => undefined
+}))
+vi.mock('./use-structured-agent-session-status-summary', () => ({
+  useStructuredAgentSessionStatusSummary: () =>
+    mocks.blocked ? { rewindBlockedReason: 'outcome-unknown' } : null
+}))
+vi.mock('./use-structured-agent-session-read', () => ({
+  useStructuredAgentSessionRead: () => ({ state, loadingOlder: false, loadOlder: vi.fn() })
+}))
+
+import { useStructuredAgentSession } from './use-structured-agent-session'
+
+const args = {
+  sessionId: 'rewind-outbox',
+  target: { kind: 'local' as const },
+  agent: 'codex' as const,
+  isVisible: true
+}
+
+describe('rewind recovery outbox suspension', () => {
+  beforeEach(() => {
+    vi.useFakeTimers()
+    vi.clearAllMocks()
+    localStorage.clear()
+    mocks.blocked = true
+    mocks.call.mockImplementation((_target, method) =>
+      method === 'agentSession.send'
+        ? new Promise(() => {})
+        : Promise.resolve({ models: [], current: {}, rewind: { supported: true } })
+    )
+  })
+  afterEach(() => vi.useRealTimers())
+
+  it.each(['queued', 'unconfirmed'] as const)(
+    'suspends a restored %s message, probes, and manual retry until the host clears recovery',
+    async (entryState) => {
+      const entry = enqueueStructuredAgentSessionLaunchPrompt(args.sessionId, 'Pending prompt')!
+      writeOutbox(args.sessionId, [{ ...entry, state: entryState }])
+      const view = renderHook(() => useStructuredAgentSession(args))
+      await act(async () => {
+        view.result.current.retry(entry.clientMessageId)
+        await vi.advanceTimersByTimeAsync(60_000)
+      })
+
+      expect(mocks.call.mock.calls.filter(([, method]) => method === 'agentSession.send')).toEqual(
+        []
+      )
+      expect(readOutbox(args.sessionId)[0]?.state).toBe(entryState)
+      expect(view.result.current.send('New prompt', [])).toBe(false)
+      expect(view.result.current.error).toContain('The rewind may have completed')
+
+      mocks.blocked = false
+      await act(async () => view.rerender())
+      if (entryState === 'unconfirmed') {
+        await act(async () => view.result.current.retry(entry.clientMessageId))
+      }
+      expect(
+        mocks.call.mock.calls.filter(([, method]) => method === 'agentSession.send')
+      ).toHaveLength(1)
+      view.unmount()
+    }
+  )
+})
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 e5ecb78b3aef..e4883232e4a9 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
@@ -80,7 +80,7 @@ export function useStructuredAgentSession(args: {
   const outboxController = useStructuredAgentSessionOutbox({
     sessionId,
     target,
-    fence: state.fence,
+    fence: summary?.rewindBlockedReason ? null : state.fence,
     submissions: state.submissions
   })
 
@@ -257,7 +257,11 @@ export function useStructuredAgentSession(args: {
     blockedClientMessageId: outboxController.blockedClientMessageId,
     send: (...input: Parameters<typeof outboxController.send>) =>
       !commandPending.current && !rewind.blockedRef.current && outboxController.send(...input),
-    retry: outboxController.retry,
+    retry: (clientMessageId: string) => {
+      if (!rewind.blockedRef.current) {
+        outboxController.retry(clientMessageId)
+      }
+    },
     isWorking: turnId !== null,
     turnActivity,
     isMonitoringBackgroundTasks,

From 9c659a0b513b5a6ee02df1eab81d3dc76575778c Mon Sep 17 00:00:00 2001
From: Merge Sim <sim@local>
Date: Mon, 7 Sep 2026 09:31:49 -0700
Subject: [PATCH 05/22] Verify rewind targets after message acceptance

---
 .../NativeChatRewindAction.target.test.tsx    | 144 ++++++++++++++++++
 .../native-chat/native-chat-rewind-copy.ts    |   2 +-
 .../use-native-chat-rewind.test.tsx           |   1 +
 src/renderer/src/i18n/locales/en.json         |   2 +-
 4 files changed, 147 insertions(+), 2 deletions(-)
 create mode 100644 src/renderer/src/components/native-chat/NativeChatRewindAction.target.test.tsx

diff --git a/src/renderer/src/components/native-chat/NativeChatRewindAction.target.test.tsx b/src/renderer/src/components/native-chat/NativeChatRewindAction.target.test.tsx
new file mode 100644
index 000000000000..c5dd49252667
--- /dev/null
+++ b/src/renderer/src/components/native-chat/NativeChatRewindAction.target.test.tsx
@@ -0,0 +1,144 @@
+// @vitest-environment happy-dom
+
+import {
+  act,
+  cleanup,
+  fireEvent,
+  render,
+  renderHook,
+  screen,
+  waitFor
+} from '@testing-library/react'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import {
+  EMPTY_STRUCTURED_AGENT_SESSION,
+  type StructuredAgentSessionState
+} from '../../../../shared/structured-agent-session-reducer'
+import {
+  agentJournalItemKey,
+  agentJournalSubmissionKey
+} from '../../../../shared/agent-session-journal-item-key'
+import { MessageRow } from './NativeChatMessageRow'
+
+const mocks = vi.hoisted(() => ({ call: vi.fn() }))
+let state: StructuredAgentSessionState
+
+vi.mock('@/runtime/structured-agent-session-client', () => ({
+  callStructuredAgentSession: mocks.call
+}))
+vi.mock('./use-structured-agent-session-hold', () => ({
+  useStructuredAgentSessionHold: () => undefined
+}))
+vi.mock('./use-structured-agent-session-status-summary', () => ({
+  useStructuredAgentSessionStatusSummary: () => null
+}))
+vi.mock('./use-structured-agent-session-read', () => ({
+  useStructuredAgentSessionRead: () => ({ state, loadingOlder: false, loadOlder: vi.fn() })
+}))
+
+import { useStructuredAgentSession } from './use-structured-agent-session'
+
+const target = { kind: 'local' } as const
+
+describe('rewind target after send acceptance', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    localStorage.clear()
+    state = {
+      ...EMPTY_STRUCTURED_AGENT_SESSION,
+      epoch: 'epoch-1',
+      cursor: { epoch: 'epoch-1', sequence: 0 },
+      fence: 3,
+      status: 'ready'
+    }
+    mocks.call.mockImplementation((_target, method, params) => {
+      if (method === 'agentSession.send') {
+        return new Promise(() => {})
+      }
+      return Promise.resolve(
+        method === 'agentSession.rewind'
+          ? { ok: true, value: { itemId: params.itemId, epoch: 'epoch-2' } }
+          : { models: [], current: {}, rewind: { supported: true } }
+      )
+    })
+  })
+  afterEach(cleanup)
+
+  it.each([
+    ['codex', 'orca'],
+    ['codex', 'provider'],
+    ['claude', 'orca'],
+    ['claude', 'provider']
+  ] as const)('uses the accepted %s row with a %s journal key', async (agent, keySource) => {
+    const hook = renderHook(() =>
+      useStructuredAgentSession({ sessionId: 'session', target, agent, isVisible: true })
+    )
+    await act(async () => {
+      expect(hook.result.current.send('Just sent', [])).toBe(true)
+    })
+    await waitFor(() => expect(hook.result.current.messages).toHaveLength(1))
+    const entry = hook.result.current.outbox[0]!
+    const optimisticId = agentJournalSubmissionKey(entry.clientMessageId)
+    const confirm = vi.fn().mockResolvedValue(true)
+    const row = () => (
+      <MessageRow
+        message={hook.result.current.messages[0]!}
+        expandSignal={false}
+        onScrollMessageToTop={vi.fn()}
+        rewind={{
+          disabledReason: hook.result.current.rewind.disabledReason,
+          request: (itemId) => void hook.result.current.rewind.request(itemId, confirm)
+        }}
+      />
+    )
+    const view = render(row())
+    fireEvent.click(screen.getByRole('button', { name: 'Revert to here' }))
+    expect(confirm).not.toHaveBeenCalled()
+
+    const providerItemId = agentJournalItemKey(
+      agent === 'codex'
+        ? { provider: 'codex', threadId: 'thread', turnId: 'turn', ordinal: 0 }
+        : { provider: 'claude', sessionId: 'provider-session', uuid: 'message-uuid' }
+    )
+    const itemId = keySource === 'orca' ? optimisticId : providerItemId
+    state = {
+      ...state,
+      cursor: { epoch: 'epoch-1', sequence: 1 },
+      items: [{ itemId, revision: 1, sequence: 1, observedAt: 1, body: entry.body }],
+      submissions: [
+        {
+          clientMessageId: entry.clientMessageId,
+          fence: 3,
+          payloadFingerprint: 'send-fingerprint',
+          dispatchState: 'accepted',
+          providerItemId,
+          reason: null,
+          submittedAt: 1,
+          resolvedAt: 2
+        }
+      ]
+    }
+    hook.rerender()
+    await waitFor(() => expect(hook.result.current.rewind.disabledReason).toBeNull())
+    expect(hook.result.current.outbox).toEqual([])
+    expect(hook.result.current.messages.map((message) => message.id)).toEqual([itemId])
+    if (keySource === 'provider') {
+      await act(() => hook.result.current.rewind.request(optimisticId, confirm))
+      expect(confirm).not.toHaveBeenCalled()
+    }
+
+    view.rerender(row())
+    fireEvent.click(screen.getByRole('button', { name: 'Revert to here' }))
+    await waitFor(() =>
+      expect(mocks.call).toHaveBeenCalledWith(
+        target,
+        'agentSession.rewind',
+        expect.objectContaining({ itemId, expectedEpoch: 'epoch-1' })
+      )
+    )
+    expect(confirm).toHaveBeenCalledOnce()
+    expect(confirm).toHaveBeenCalledWith(
+      expect.objectContaining({ description: expect.stringContaining('1 in total') })
+    )
+  })
+})
diff --git a/src/renderer/src/components/native-chat/native-chat-rewind-copy.ts b/src/renderer/src/components/native-chat/native-chat-rewind-copy.ts
index 6ac70c565a32..2e9860f43fc6 100644
--- a/src/renderer/src/components/native-chat/native-chat-rewind-copy.ts
+++ b/src/renderer/src/components/native-chat/native-chat-rewind-copy.ts
@@ -45,7 +45,7 @@ const reasonCopy = {
   'outcome-unknown': () =>
     translate(
       'components.native-chat.rewind.outcomeUnknown',
-      'The rewind may have completed, but Orca could not confirm it. Sending is blocked until the session is reloaded or the outcome is resolved.'
+      'The rewind may have completed, but Orca could not confirm it. Sending is blocked until the outcome is resolved.'
     )
 } satisfies Record<AgentSessionRewindReason, () => string>
 
diff --git a/src/renderer/src/components/native-chat/use-native-chat-rewind.test.tsx b/src/renderer/src/components/native-chat/use-native-chat-rewind.test.tsx
index 153896fa146d..236b84eafa87 100644
--- a/src/renderer/src/components/native-chat/use-native-chat-rewind.test.tsx
+++ b/src/renderer/src/components/native-chat/use-native-chat-rewind.test.tsx
@@ -261,6 +261,7 @@ describe('structured chat rewind', () => {
     if (rewindReason === 'outcome-unknown') {
       expect(view.result.current.error).toContain('may have completed')
       expect(view.result.current.error).toContain('Sending is blocked')
+      expect(view.result.current.error).toContain('until the outcome is resolved')
       expect(view.result.current.error).not.toContain('failed')
       expect(view.result.current.pending).toBe(true)
     }
diff --git a/src/renderer/src/i18n/locales/en.json b/src/renderer/src/i18n/locales/en.json
index 07d636f968de..2fc1c463276c 100644
--- a/src/renderer/src/i18n/locales/en.json
+++ b/src/renderer/src/i18n/locales/en.json
@@ -17158,7 +17158,7 @@
         "historyLimit": "This conversation is too large to rewind safely. Nothing was changed.",
         "providerRefused": "The agent refused to rewind this conversation.",
         "proofMismatch": "Orca could not verify the conversation boundary. Reload the session before trying again.",
-        "outcomeUnknown": "The rewind may have completed, but Orca could not confirm it. Sending is blocked until the session is reloaded or the outcome is resolved.",
+        "outcomeUnknown": "The rewind may have completed, but Orca could not confirm it. Sending is blocked until the outcome is resolved.",
         "refused": "Orca could not rewind this conversation. Reload the session to check its current state.",
         "unavailable": "Reconnect to a writable chat session before rewinding.",
         "pending": "Rewind is in progress. Wait for the conversation to reload.",

From 0dd43946045b32f25e004dc8f27d38b2d0c834a8 Mon Sep 17 00:00:00 2001
From: Merge Sim <sim@local>
Date: Mon, 7 Sep 2026 12:24:21 -0700
Subject: [PATCH 06/22] test(native-chat): verify rewind copy against host
 reason contract

---
 .../use-native-chat-rewind.test.tsx           | 65 ++++++++++---------
 1 file changed, 36 insertions(+), 29 deletions(-)

diff --git a/src/renderer/src/components/native-chat/use-native-chat-rewind.test.tsx b/src/renderer/src/components/native-chat/use-native-chat-rewind.test.tsx
index 236b84eafa87..2bc497cefe3a 100644
--- a/src/renderer/src/components/native-chat/use-native-chat-rewind.test.tsx
+++ b/src/renderer/src/components/native-chat/use-native-chat-rewind.test.tsx
@@ -1,6 +1,7 @@
 // @vitest-environment happy-dom
 import { act, cleanup, renderHook } from '@testing-library/react'
 import { afterEach, describe, expect, it, vi } from 'vitest'
+import { AGENT_SESSION_REWIND_REASONS } from '../../../../shared/agent-session-rewind'
 import { EMPTY_STRUCTURED_AGENT_SESSION } from '../../../../shared/structured-agent-session-reducer'
 import type { AgentJournalRenderItem } from '../../../../shared/agent-session-journal-types'
 import { countNativeChatRewindMessages, useNativeChatRewind } from './use-native-chat-rewind'
@@ -235,38 +236,44 @@ describe('structured chat rewind', () => {
     }
   )
 
-  it.each([
-    'unsupported',
-    'history-not-paginated',
-    'busy',
-    'stale-epoch',
-    'invalid-target',
-    'history-limit',
-    'provider-refused',
-    'proof-mismatch',
-    'outcome-unknown',
-    'future-reason'
-  ])('explains refusal %s', async (rewindReason) => {
-    const props = input()
-    props.send.mockImplementation(async (_fields, failure) => {
-      failure({ code: 'agent_session_conflict', rewindReason })
-      return null
-    })
-    const view = renderHook(() => useNativeChatRewind(props))
-    await act(() => view.result.current.request('user', async () => true))
-    expect(view.result.current.error).toBe(nativeChatRewindReasonCopy(rewindReason))
-    if (rewindReason === 'history-limit') {
-      expect(view.result.current.error).toContain('Nothing was changed')
-    }
-    if (rewindReason === 'outcome-unknown') {
-      expect(view.result.current.error).toContain('may have completed')
-      expect(view.result.current.error).toContain('Sending is blocked')
-      expect(view.result.current.error).toContain('until the outcome is resolved')
-      expect(view.result.current.error).not.toContain('failed')
-      expect(view.result.current.pending).toBe(true)
+  it.each(AGENT_SESSION_REWIND_REASONS)('explains disabled host support: %s', async (reason) => {
+    const props: Parameters<typeof useNativeChatRewind>[0] = {
+      ...input(),
+      support: { supported: false, reason }
     }
+    const view = renderHook(() => useNativeChatRewind(props))
+    expect(view.result.current.disabledReason).toBe(nativeChatRewindReasonCopy(reason))
+    expect(view.result.current.disabledReason).not.toBe(nativeChatRewindReasonCopy('future-reason'))
+    const confirm = vi.fn()
+    await act(() => view.result.current.request('user', confirm))
+    expect(confirm).not.toHaveBeenCalled()
+    expect(props.send).not.toHaveBeenCalled()
   })
 
+  it.each([...AGENT_SESSION_REWIND_REASONS, 'future-reason'])(
+    'explains refusal %s',
+    async (rewindReason) => {
+      const props = input()
+      props.send.mockImplementation(async (_fields, failure) => {
+        failure({ code: 'agent_session_conflict', rewindReason })
+        return null
+      })
+      const view = renderHook(() => useNativeChatRewind(props))
+      await act(() => view.result.current.request('user', async () => true))
+      expect(view.result.current.error).toBe(nativeChatRewindReasonCopy(rewindReason))
+      if (rewindReason === 'history-limit') {
+        expect(view.result.current.error).toContain('Nothing was changed')
+      }
+      if (rewindReason === 'outcome-unknown') {
+        expect(view.result.current.error).toContain('may have completed')
+        expect(view.result.current.error).toContain('Sending is blocked')
+        expect(view.result.current.error).toContain('until the outcome is resolved')
+        expect(view.result.current.error).not.toContain('failed')
+        expect(view.result.current.pending).toBe(true)
+      }
+    }
+  )
+
   it('treats a lost transport response as uncertain and never retries', async () => {
     const props = input()
     props.send.mockImplementation(async (_fields, failure) => {

From c1d463c35d0faeef279710ed5bed60597828a306 Mon Sep 17 00:00:00 2001
From: Merge Sim <sim@local>
Date: Mon, 7 Sep 2026 12:27:57 -0700
Subject: [PATCH 07/22] fix: type rewind hook test props explicitly

---
 .../native-chat/use-native-chat-rewind.test.tsx           | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/renderer/src/components/native-chat/use-native-chat-rewind.test.tsx b/src/renderer/src/components/native-chat/use-native-chat-rewind.test.tsx
index 2bc497cefe3a..716c53819b2d 100644
--- a/src/renderer/src/components/native-chat/use-native-chat-rewind.test.tsx
+++ b/src/renderer/src/components/native-chat/use-native-chat-rewind.test.tsx
@@ -106,10 +106,10 @@ describe('structured chat rewind', () => {
     const props = input(),
       response = deferred<{ itemId: string; epoch: string }>()
     props.send.mockReturnValue(response.promise)
-    const view = renderHook(
-      (value: Parameters<typeof useNativeChatRewind>[0]) => useNativeChatRewind(value),
-      { initialProps: props }
-    )
+    const view = renderHook<
+      ReturnType<typeof useNativeChatRewind>,
+      Parameters<typeof useNativeChatRewind>[0]
+    >((value) => useNativeChatRewind(value), { initialProps: props })
     let request!: Promise<void>
     await act(async () => {
       request = view.result.current.request('user', async () => true)

From 0ac059956ba294960a3b5a79b23949a9b52e9e0c Mon Sep 17 00:00:00 2001
From: Merge Sim <sim@local>
Date: Mon, 7 Sep 2026 17:20:43 -0700
Subject: [PATCH 08/22] Show rewind explanations on keyboard focus

---
 .../native-chat/NativeChatMessageRow.test.tsx | 27 ++++++------
 .../NativeChatRewindAction.target.test.tsx    | 21 ++++++----
 .../NativeChatRewindAction.test.tsx           | 36 +++++++++-------
 .../native-chat/NativeChatRewindAction.tsx    | 41 +++++++++++--------
 4 files changed, 72 insertions(+), 53 deletions(-)

diff --git a/src/renderer/src/components/native-chat/NativeChatMessageRow.test.tsx b/src/renderer/src/components/native-chat/NativeChatMessageRow.test.tsx
index f9666e850abc..7aa34e78ee72 100644
--- a/src/renderer/src/components/native-chat/NativeChatMessageRow.test.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatMessageRow.test.tsx
@@ -1,5 +1,6 @@
 // @vitest-environment happy-dom
 import '@testing-library/jest-dom/vitest'
+import { TooltipProvider } from '@/components/ui/tooltip'
 import { cleanup, fireEvent, render, screen } from '@testing-library/react'
 import { afterEach, describe, expect, it, vi } from 'vitest'
 import type { NativeChatMessage } from '../../../../shared/native-chat-types'
@@ -14,18 +15,20 @@ function renderMessage(
   rewind?: NativeChatRewindSurface
 ) {
   return render(
-    <MessageRow
-      message={{
-        id: 'message',
-        role,
-        timestamp,
-        source: 'transcript',
-        blocks: [{ type: 'text', text: 'Message text' }]
-      }}
-      expandSignal={false}
-      onScrollMessageToTop={vi.fn()}
-      rewind={rewind}
-    />
+    <TooltipProvider>
+      <MessageRow
+        message={{
+          id: 'message',
+          role,
+          timestamp,
+          source: 'transcript',
+          blocks: [{ type: 'text', text: 'Message text' }]
+        }}
+        expandSignal={false}
+        onScrollMessageToTop={vi.fn()}
+        rewind={rewind}
+      />
+    </TooltipProvider>
   )
 }
 
diff --git a/src/renderer/src/components/native-chat/NativeChatRewindAction.target.test.tsx b/src/renderer/src/components/native-chat/NativeChatRewindAction.target.test.tsx
index c5dd49252667..d6f88b7f99ea 100644
--- a/src/renderer/src/components/native-chat/NativeChatRewindAction.target.test.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatRewindAction.target.test.tsx
@@ -18,6 +18,7 @@ import {
   agentJournalItemKey,
   agentJournalSubmissionKey
 } from '../../../../shared/agent-session-journal-item-key'
+import { TooltipProvider } from '@/components/ui/tooltip'
 import { MessageRow } from './NativeChatMessageRow'
 
 const mocks = vi.hoisted(() => ({ call: vi.fn() }))
@@ -81,15 +82,17 @@ describe('rewind target after send acceptance', () => {
     const optimisticId = agentJournalSubmissionKey(entry.clientMessageId)
     const confirm = vi.fn().mockResolvedValue(true)
     const row = () => (
-      <MessageRow
-        message={hook.result.current.messages[0]!}
-        expandSignal={false}
-        onScrollMessageToTop={vi.fn()}
-        rewind={{
-          disabledReason: hook.result.current.rewind.disabledReason,
-          request: (itemId) => void hook.result.current.rewind.request(itemId, confirm)
-        }}
-      />
+      <TooltipProvider>
+        <MessageRow
+          message={hook.result.current.messages[0]!}
+          expandSignal={false}
+          onScrollMessageToTop={vi.fn()}
+          rewind={{
+            disabledReason: hook.result.current.rewind.disabledReason,
+            request: (itemId) => void hook.result.current.rewind.request(itemId, confirm)
+          }}
+        />
+      </TooltipProvider>
     )
     const view = render(row())
     fireEvent.click(screen.getByRole('button', { name: 'Revert to here' }))
diff --git a/src/renderer/src/components/native-chat/NativeChatRewindAction.test.tsx b/src/renderer/src/components/native-chat/NativeChatRewindAction.test.tsx
index 11773ef0e99d..d80749457601 100644
--- a/src/renderer/src/components/native-chat/NativeChatRewindAction.test.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatRewindAction.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 { TooltipProvider } from '@/components/ui/tooltip'
+import { act, cleanup, fireEvent, render, screen } from '@testing-library/react'
 import { afterEach, describe, expect, it, vi } from 'vitest'
 import { MessageRow } from './NativeChatMessageRow'
 import type { NativeChatMessage } from '../../../../shared/native-chat-types'
@@ -13,18 +14,20 @@ function row(
 ) {
   const request = vi.fn()
   render(
-    <MessageRow
-      message={{
-        id: 'user-1',
-        role,
-        timestamp: 1,
-        source: 'transcript',
-        blocks: [{ type: 'text', text: 'Prompt' }]
-      }}
-      expandSignal={false}
-      onScrollMessageToTop={vi.fn()}
-      rewind={enabled ? { request, disabledReason } : undefined}
-    />
+    <TooltipProvider>
+      <MessageRow
+        message={{
+          id: 'user-1',
+          role,
+          timestamp: 1,
+          source: 'transcript',
+          blocks: [{ type: 'text', text: 'Prompt' }]
+        }}
+        expandSignal={false}
+        onScrollMessageToTop={vi.fn()}
+        rewind={enabled ? { request, disabledReason } : undefined}
+      />
+    </TooltipProvider>
   )
   return request
 }
@@ -41,7 +44,7 @@ describe('user-row rewind affordance', () => {
     fireEvent.click(button)
     expect(request).toHaveBeenCalledWith('user-1')
   })
-  it('exposes the disabled reason to keyboard users and cannot invoke rewind', () => {
+  it('exposes the disabled reason to keyboard users and cannot invoke rewind', async () => {
     const request = row('user', 'This older Codex conversation does not support rewinding.')
     const button = screen.getByRole('button', { name: 'Revert to here' })
     expect(button).toHaveAttribute('aria-disabled', 'true')
@@ -49,8 +52,11 @@ describe('user-row rewind affordance', () => {
       'aria-description',
       'This older Codex conversation does not support rewinding.'
     )
-    button.focus()
+    act(() => button.focus())
     expect(button).toHaveFocus()
+    expect(await screen.findByRole('tooltip')).toHaveTextContent(
+      'This older Codex conversation does not support rewinding.'
+    )
     fireEvent.click(button)
     expect(request).not.toHaveBeenCalled()
   })
diff --git a/src/renderer/src/components/native-chat/NativeChatRewindAction.tsx b/src/renderer/src/components/native-chat/NativeChatRewindAction.tsx
index 5b71b558e520..42d10af84668 100644
--- a/src/renderer/src/components/native-chat/NativeChatRewindAction.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatRewindAction.tsx
@@ -1,5 +1,6 @@
 import { Undo2 } from 'lucide-react'
 import { Button } from '@/components/ui/button'
+import { Tooltip, TooltipContent, TooltipTrigger } from '@/components/ui/tooltip'
 import { translate } from '@/i18n/i18n'
 import type { NativeChatRewindSurface } from './use-native-chat-rewind'
 
@@ -12,22 +13,28 @@ export function NativeChatRewindAction({
 }) {
   const label = translate('components.native-chat.rewind.action', 'Revert to here')
   return (
-    <Button
-      type="button"
-      size="icon-xs"
-      variant="ghost"
-      className="text-muted-foreground aria-disabled:opacity-50"
-      aria-label={label}
-      aria-description={rewind.disabledReason ?? undefined}
-      aria-disabled={Boolean(rewind.disabledReason)}
-      title={rewind.disabledReason ?? label}
-      onClick={() => {
-        if (!rewind.disabledReason) {
-          rewind.request(itemId)
-        }
-      }}
-    >
-      <Undo2 className="size-3" />
-    </Button>
+    <Tooltip>
+      <TooltipTrigger asChild>
+        <Button
+          type="button"
+          size="icon-xs"
+          variant="ghost"
+          className="text-muted-foreground aria-disabled:opacity-50"
+          aria-label={label}
+          aria-description={rewind.disabledReason ?? undefined}
+          aria-disabled={Boolean(rewind.disabledReason)}
+          onClick={() => {
+            if (!rewind.disabledReason) {
+              rewind.request(itemId)
+            }
+          }}
+        >
+          <Undo2 className="size-3" />
+        </Button>
+      </TooltipTrigger>
+      <TooltipContent side="top" sideOffset={4}>
+        {rewind.disabledReason ?? label}
+      </TooltipContent>
+    </Tooltip>
   )
 }

From 3922654becdbabf3b1efa2f954c868270502cd7f Mon Sep 17 00:00:00 2001
From: Merge Sim <sim@local>
Date: Wed, 9 Sep 2026 12:43:14 -0700
Subject: [PATCH 09/22] fix(native-chat): read renamed background stop-all
 capability

---
 .../src/components/native-chat/NativeChatStructuredSession.tsx  | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/renderer/src/components/native-chat/NativeChatStructuredSession.tsx b/src/renderer/src/components/native-chat/NativeChatStructuredSession.tsx
index 27a4ab47d0ae..627dd537c43c 100644
--- a/src/renderer/src/components/native-chat/NativeChatStructuredSession.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatStructuredSession.tsx
@@ -342,7 +342,7 @@ function NativeChatStructuredSessionContent({
         <NativeChatBackgroundTasksStatus
           tasks={controller.backgroundTasks}
           supportsTaskStop={controller.supportsBackgroundTaskStop}
-          supportsStopAll={controller.backgroundTasksView.supportsStopAll}
+          supportsStopAll={controller.backgroundTasksView.supportsBackgroundTaskStopAll}
           stoppingTaskIds={activeStoppingBackgroundTasks?.taskIds ?? NO_STOPPING_TASKS}
           stoppingAll={activeStoppingBackgroundTasks?.all ?? false}
           onStop={(taskId) => {

From 6521a4cc1370f8c9bee003f00ea31e746b0e8bb1 Mon Sep 17 00:00:00 2001
From: Merge Sim <sim@local>
Date: Wed, 9 Sep 2026 16:08:07 -0700
Subject: [PATCH 10/22] fix(native-chat): consolidate epoch test vitest imports

---
 .../native-chat/NativeChatStructuredSession.epoch.test.tsx     | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/src/renderer/src/components/native-chat/NativeChatStructuredSession.epoch.test.tsx b/src/renderer/src/components/native-chat/NativeChatStructuredSession.epoch.test.tsx
index 509d9458b123..a12a17576a5b 100644
--- a/src/renderer/src/components/native-chat/NativeChatStructuredSession.epoch.test.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatStructuredSession.epoch.test.tsx
@@ -1,9 +1,8 @@
 // @vitest-environment happy-dom
 import { cleanup, fireEvent, render, screen } from '@testing-library/react'
 import { forwardRef } from 'react'
-import { afterEach, it, vi } from 'vitest'
+import { afterEach, expect, it, vi } from 'vitest'
 import { NativeChatStructuredSession } from './NativeChatStructuredSession'
-import { expect } from 'vitest'
 
 const mocks = vi.hoisted(() => ({
   epoch: 'epoch-1',

From b9d3fb0fa1ee217edcfd02b8e267162a56cb2c19 Mon Sep 17 00:00:00 2001
From: Merge Sim <sim@local>
Date: Wed, 9 Sep 2026 17:13:21 -0700
Subject: [PATCH 11/22] fix(native-chat): restore rewind refusal delivery after
 merge

---
 .../NativeChatStructuredSession.test.tsx      |   4 +-
 .../use-structured-agent-session-mutate.ts    |  30 ++++-
 .../use-structured-agent-session-mutation.ts  | 104 ------------------
 .../use-structured-agent-session.ts           |  63 ++++++-----
 4 files changed, 65 insertions(+), 136 deletions(-)
 delete mode 100644 src/renderer/src/components/native-chat/use-structured-agent-session-mutation.ts

diff --git a/src/renderer/src/components/native-chat/NativeChatStructuredSession.test.tsx b/src/renderer/src/components/native-chat/NativeChatStructuredSession.test.tsx
index d3131577f909..fc01d132694f 100644
--- a/src/renderer/src/components/native-chat/NativeChatStructuredSession.test.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatStructuredSession.test.tsx
@@ -86,7 +86,9 @@ vi.mock('./use-structured-agent-session', async () => {
         isWorking: false,
         isMonitoringBackgroundTasks: mocks.monitoringBackgroundTasks,
         supportsBackgroundTaskStop: mocks.supportsBackgroundTaskStop,
-        supportsBackgroundTaskStopAll: mocks.supportsBackgroundTaskStopAll,
+        backgroundTasksView: {
+          supportsBackgroundTaskStopAll: mocks.supportsBackgroundTaskStopAll
+        },
         backgroundTasks: mocks.backgroundTasks,
         turnId: null,
         cancel: vi.fn(),
diff --git a/src/renderer/src/components/native-chat/use-structured-agent-session-mutate.ts b/src/renderer/src/components/native-chat/use-structured-agent-session-mutate.ts
index 6f071e1a16bb..fb1e3d4a7e74 100644
--- a/src/renderer/src/components/native-chat/use-structured-agent-session-mutate.ts
+++ b/src/renderer/src/components/native-chat/use-structured-agent-session-mutate.ts
@@ -7,7 +7,11 @@
 
 import { useCallback, useRef, useState } from 'react'
 import * as conversationCommands from './structured-conversation-command-send'
-import type { AgentSessionMutationResult } from '../../../../shared/agent-session-wire'
+import type {
+  AgentSessionMutationResult,
+  AgentSessionWireRefusal
+} from '../../../../shared/agent-session-wire'
+import { hasRuntimeRpcErrorCode } from '../../../../shared/runtime-rpc-error-code'
 import { agentSessionRefusalOperationState } from '../../../../shared/agent-session-refusal-retry'
 import { structuredAgentSessionPayloadFingerprint } from '../../../../shared/structured-agent-session-mutation'
 import type { RuntimeClientTarget } from '@/runtime/runtime-rpc-client'
@@ -18,7 +22,8 @@ export type StructuredAgentSessionMutate = <T>(
   method: string,
   fingerprintMethod: string,
   fields: Record<string, unknown>,
-  operationIdOverride?: string | null
+  operationIdOverride?: string | null,
+  onFailure?: (refusal?: AgentSessionWireRefusal) => void
 ) => Promise<T | null>
 
 export function useStructuredAgentSessionMutate(args: {
@@ -37,7 +42,8 @@ export function useStructuredAgentSessionMutate(args: {
       method: string,
       fingerprintMethod: string,
       fields: Record<string, unknown>,
-      operationIdOverride?: string | null
+      operationIdOverride?: string | null,
+      onFailure?: (refusal?: AgentSessionWireRefusal) => void
     ): Promise<T | null> => {
       if (stateRef.current.fence === null) {
         return null
@@ -63,7 +69,17 @@ export function useStructuredAgentSessionMutate(args: {
           ...fields
         })
       } catch (error) {
-        if (stateRef.current.fence === targetFence) {
+        if (onFailure) {
+          onFailure(
+            hasRuntimeRpcErrorCode(error, 'method_not_found')
+              ? {
+                  code: 'structured_agent_session_unsupported',
+                  message: '',
+                  rewindReason: 'unsupported'
+                }
+              : undefined
+          )
+        } else if (stateRef.current.fence === targetFence) {
           setWriteError(error instanceof Error ? error.message : 'Request was not sent')
         }
         return null
@@ -75,12 +91,14 @@ export function useStructuredAgentSessionMutate(args: {
         ) {
           operationIds.current.delete(key)
         }
-        if (stateRef.current.fence === targetFence) {
+        if (onFailure) {
+          onFailure(result.refusal)
+        } else if (stateRef.current.fence === targetFence) {
           setWriteError(result.refusal.message)
         }
         return null
       }
-      if (stateRef.current.fence !== targetFence) {
+      if (stateRef.current.fence !== targetFence && fingerprintMethod !== 'agentSession.rewind') {
         return null
       }
       if (!conversationCommands.isUnconfirmedConversationCommand(fingerprintMethod, result.value)) {
diff --git a/src/renderer/src/components/native-chat/use-structured-agent-session-mutation.ts b/src/renderer/src/components/native-chat/use-structured-agent-session-mutation.ts
deleted file mode 100644
index d8b6b55c6a6c..000000000000
--- a/src/renderer/src/components/native-chat/use-structured-agent-session-mutation.ts
+++ /dev/null
@@ -1,104 +0,0 @@
-import { translate } from '@/i18n/i18n'
-import { useCallback, useEffect, useRef, useState } from 'react'
-import type {
-  AgentSessionMutationResult,
-  AgentSessionWireRefusal
-} from '../../../../shared/agent-session-wire'
-import { hasRuntimeRpcErrorCode } from '../../../../shared/runtime-rpc-error-code'
-import { agentSessionRefusalOperationState } from '../../../../shared/agent-session-refusal-retry'
-import { structuredAgentSessionPayloadFingerprint } from '../../../../shared/structured-agent-session-mutation'
-import type { RuntimeClientTarget } from '@/runtime/runtime-rpc-client'
-import { callStructuredAgentSession } from '@/runtime/structured-agent-session-client'
-import { structuredSessionOperationId } from './use-structured-agent-session-outbox'
-import * as conversationCommands from './structured-conversation-command-send'
-
-export function useStructuredAgentSessionMutation(
-  sessionId: string,
-  target: RuntimeClientTarget,
-  fence: number | null
-) {
-  const stateRef = useRef({ fence })
-  const [writeError, setWriteError] = useState<string | null>(null)
-  const operationIds = useRef(new Map<string, string>())
-  useEffect(() => {
-    stateRef.current = { fence }
-  }, [fence])
-  const mutate = useCallback(
-    async <T>(
-      method: string,
-      fingerprintMethod: string,
-      fields: Record<string, unknown>,
-      operationIdOverride?: string | null,
-      onFailure?: (refusal?: AgentSessionWireRefusal) => void
-    ): Promise<T | null> => {
-      if (stateRef.current.fence === null) {
-        return null
-      }
-      const targetFence = stateRef.current.fence
-      const key = `${sessionId}:${fingerprintMethod}:${JSON.stringify(fields)}`
-      const clientOperationId =
-        operationIdOverride ?? operationIds.current.get(key) ?? structuredSessionOperationId()
-      operationIds.current.set(key, clientOperationId)
-      let result: AgentSessionMutationResult<T>
-      try {
-        result = await callStructuredAgentSession<AgentSessionMutationResult<T>>(target, method, {
-          envelope: {
-            sessionId,
-            clientOperationId,
-            expectedRuntimeFence: targetFence,
-            payloadFingerprint: structuredAgentSessionPayloadFingerprint({
-              method: fingerprintMethod,
-              sessionId,
-              fields
-            })
-          },
-          ...fields
-        })
-      } catch (error) {
-        if (onFailure) {
-          onFailure(
-            hasRuntimeRpcErrorCode(error, 'method_not_found')
-              ? {
-                  code: 'structured_agent_session_unsupported',
-                  message: '',
-                  rewindReason: 'unsupported'
-                }
-              : undefined
-          )
-        } else if (stateRef.current.fence === targetFence) {
-          setWriteError(
-            error instanceof Error
-              ? error.message
-              : translate('components.native-chat.requestNotSent', 'Request was not sent')
-          )
-        }
-        return null
-      }
-      if (!result.ok) {
-        if (
-          agentSessionRefusalOperationState(fingerprintMethod, result.refusal.code) ===
-          'settled-rejected'
-        ) {
-          operationIds.current.delete(key)
-        }
-        if (onFailure) {
-          onFailure(result.refusal)
-        } else if (stateRef.current.fence === targetFence) {
-          setWriteError(result.refusal.message)
-        }
-        return null
-      }
-      if (stateRef.current.fence !== targetFence && fingerprintMethod !== 'agentSession.rewind') {
-        return null
-      }
-      if (!conversationCommands.isUnconfirmedConversationCommand(fingerprintMethod, result.value)) {
-        operationIds.current.delete(key)
-      }
-      setWriteError(null)
-      return result.value
-    },
-    [sessionId, target]
-  )
-
-  return { mutate, writeError }
-}
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 82050ea811b7..eaebfd30ec30 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
@@ -191,31 +191,44 @@ export function useStructuredAgentSession(args: {
   )
 
   const prompts = pendingStructuredSessionPrompts(state.items)
-  const rewind = useNativeChatRewind({
-    sessionId,
-    hostBlockedReason: summary?.rewindBlockedReason,
-    state,
-    support:
-      conversationSupport?.sessionId === sessionId && conversationSupport.fence === state.fence
-        ? conversationSupport.rewind
-        : undefined,
-    supportResolved:
-      conversationSupport?.sessionId === sessionId && conversationSupport.fence === state.fence,
-    blocked: Boolean(
-      turnId ||
-      prompts.length ||
-      isMonitoringBackgroundTasks ||
-      outboxController.outbox.length ||
-      commandPending.current
-    ),
-    send: (fields) =>
-      mutate<AgentSessionRewindResult>(
-        'agentSession.rewind',
-        'agentSession.rewind',
-        fields,
-        undefined
-      )
-  })
+  const rewindSupportResolved =
+    conversationSupport?.sessionId === sessionId && conversationSupport.fence === state.fence
+  const rewindSupport = rewindSupportResolved ? conversationSupport.rewind : undefined
+  const rewindBlocked = Boolean(
+    turnId ||
+    prompts.length ||
+    isMonitoringBackgroundTasks ||
+    outboxController.outbox.length ||
+    commandPending.current
+  )
+  const rewindInput = useMemo<Parameters<typeof useNativeChatRewind>[0]>(
+    () => ({
+      sessionId,
+      hostBlockedReason: summary?.rewindBlockedReason,
+      state,
+      support: rewindSupport,
+      supportResolved: rewindSupportResolved,
+      blocked: rewindBlocked,
+      send: (fields, onFailure) =>
+        mutate<AgentSessionRewindResult>(
+          'agentSession.rewind',
+          'agentSession.rewind',
+          fields,
+          undefined,
+          onFailure
+        )
+    }),
+    [
+      sessionId,
+      summary?.rewindBlockedReason,
+      state,
+      rewindSupport,
+      rewindSupportResolved,
+      rewindBlocked,
+      mutate
+    ]
+  )
+  const rewind = useNativeChatRewind(rewindInput)
   const { outbox } = outboxController
   const messages = useStructuredAgentSessionMessages(state.items, outbox, state.submissions)
   return {

From 463a2de472cac3aef5c7adffd52ce246140cffcb Mon Sep 17 00:00:00 2001
From: Brennan Benson <79079362+brennanb2025@users.noreply.github.com>
Date: Mon, 5 Oct 2026 14:43:09 -0700
Subject: [PATCH 12/22] fix(native-chat): satisfy main's design-system and cast
 gates in rewind

Match the rewind button to the copy button beside it instead of
restyling the shared Button, read refusal reasons without a cast, and
merge a duplicate import.
---
 .../native-chat/NativeChatRewindAction.tsx    | 12 +++++-------
 .../native-chat/native-chat-rewind-copy.ts    | 10 +++++++---
 ...agent-session-withdrawn-message-restore.ts |  6 ++++--
 .../use-native-chat-rewind.test.tsx           | 19 +++++++++++--------
 4 files changed, 27 insertions(+), 20 deletions(-)

diff --git a/src/renderer/src/components/native-chat/NativeChatRewindAction.tsx b/src/renderer/src/components/native-chat/NativeChatRewindAction.tsx
index e826732f0c51..3924f653fcd5 100644
--- a/src/renderer/src/components/native-chat/NativeChatRewindAction.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatRewindAction.tsx
@@ -1,6 +1,5 @@
 import { Undo2 } from 'lucide-react'
 import { useConfirmationDialog } from '@/components/confirmation-dialog-context'
-import { Button } from '@/components/ui/button'
 import { Tooltip, TooltipContent, TooltipTrigger } from '@/components/ui/tooltip'
 import { translate } from '@/i18n/i18n'
 import type { NativeChatRewindSurface } from './use-native-chat-rewind'
@@ -17,11 +16,10 @@ export function NativeChatRewindAction({
   return (
     <Tooltip>
       <TooltipTrigger asChild>
-        <Button
+        {/* Styled like the copy button beside it in the same hover strip. */}
+        <button
           type="button"
-          size="icon-xs"
-          variant="ghost"
-          className="text-muted-foreground aria-disabled:opacity-50"
+          className="flex size-6 shrink-0 items-center justify-center rounded-md text-muted-foreground transition-colors hover:bg-accent hover:text-accent-foreground focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring aria-disabled:opacity-50"
           aria-label={label}
           aria-description={rewind.disabledReason ?? undefined}
           aria-disabled={Boolean(rewind.disabledReason)}
@@ -31,8 +29,8 @@ export function NativeChatRewindAction({
             }
           }}
         >
-          <Undo2 className="size-3" />
-        </Button>
+          <Undo2 className="size-3.5" />
+        </button>
       </TooltipTrigger>
       <TooltipContent side="top" sideOffset={4}>
         {rewind.disabledReason ?? label}
diff --git a/src/renderer/src/components/native-chat/native-chat-rewind-copy.ts b/src/renderer/src/components/native-chat/native-chat-rewind-copy.ts
index 2e9860f43fc6..a1f69708d17b 100644
--- a/src/renderer/src/components/native-chat/native-chat-rewind-copy.ts
+++ b/src/renderer/src/components/native-chat/native-chat-rewind-copy.ts
@@ -1,5 +1,8 @@
 import { translate } from '@/i18n/i18n'
-import type { AgentSessionRewindReason } from '../../../../shared/agent-session-rewind'
+import {
+  AGENT_SESSION_REWIND_REASONS,
+  type AgentSessionRewindReason
+} from '../../../../shared/agent-session-rewind'
 
 const reasonCopy = {
   unsupported: () =>
@@ -50,8 +53,9 @@ const reasonCopy = {
 } satisfies Record<AgentSessionRewindReason, () => string>
 
 export function nativeChatRewindReasonCopy(reason: string | undefined): string {
-  return reason && Object.hasOwn(reasonCopy, reason)
-    ? reasonCopy[reason as keyof typeof reasonCopy]()
+  const known = AGENT_SESSION_REWIND_REASONS.find((value) => value === reason)
+  return known
+    ? reasonCopy[known]()
     : translate(
         'components.native-chat.rewind.refused',
         'Orca could not rewind this conversation. Reload the session to check its current state.'
diff --git a/src/renderer/src/components/native-chat/structured-agent-session-withdrawn-message-restore.ts b/src/renderer/src/components/native-chat/structured-agent-session-withdrawn-message-restore.ts
index 6b68e33d77c8..ee6a1ee824c2 100644
--- a/src/renderer/src/components/native-chat/structured-agent-session-withdrawn-message-restore.ts
+++ b/src/renderer/src/components/native-chat/structured-agent-session-withdrawn-message-restore.ts
@@ -1,8 +1,10 @@
 import { useMemo } from 'react'
-import type { AgentJournalSubmission } from '../../../../shared/agent-session-journal-types'
+import type {
+  AgentJournalMessageItem,
+  AgentJournalSubmission
+} from '../../../../shared/agent-session-journal-types'
 import { dispatchWasWithdrawn } from '../../../../shared/structured-agent-session-dispatch-rejection'
 import type { StructuredAgentSessionOutboxEntry } from '../../../../shared/structured-agent-session-outbox'
-import type { AgentJournalMessageItem } from '../../../../shared/agent-session-journal-types'
 import { appendNativeChatDraftCache } from './native-chat-draft-cache'
 import { getStructuredAgentSessionOutbox } from './structured-agent-session-outbox-storage'
 import { appendNativeChatAttachmentCache } from './use-native-chat-composer-attachments'
diff --git a/src/renderer/src/components/native-chat/use-native-chat-rewind.test.tsx b/src/renderer/src/components/native-chat/use-native-chat-rewind.test.tsx
index a820c3beb0bf..54436f6f86b7 100644
--- a/src/renderer/src/components/native-chat/use-native-chat-rewind.test.tsx
+++ b/src/renderer/src/components/native-chat/use-native-chat-rewind.test.tsx
@@ -18,14 +18,17 @@ const notDone = (failure: AgentSessionWriteFailure) => ({
   notice: '',
   failure
 })
-const item = (itemId: string, sequence: number, role = 'user'): AgentJournalRenderItem =>
-  ({
-    itemId,
-    sequence,
-    revision: 1,
-    observedAt: sequence,
-    body: { kind: 'message', role, blocks: [{ type: 'text', text: itemId }] }
-  }) as AgentJournalRenderItem
+const item = (
+  itemId: string,
+  sequence: number,
+  role: 'user' | 'assistant' = 'user'
+): AgentJournalRenderItem => ({
+  itemId,
+  sequence,
+  revision: 1,
+  observedAt: sequence,
+  body: { kind: 'message', role, blocks: [{ type: 'text', text: itemId }] }
+})
 function input() {
   return {
     sessionId: 'session',

From 5af345b87317a3d8c55ddf2796e4457df3867f66 Mon Sep 17 00:00:00 2001
From: Brennan Benson <79079362+brennanb2025@users.noreply.github.com>
Date: Mon, 5 Oct 2026 15:26:10 -0700
Subject: [PATCH 13/22] fix(native-chat): let the host govern an in-doubt
 rewind; offer Edit from here only on turn openers

- Pending starts after Confirm and ends with the request; a confirmed rewind waits up to 120 s
  for its new conversation, then lets go with one toast.
- An unknown outcome no longer blocks sending: the host recovers it on the next send. Its latch
  only disables the action. The message goes back to the composer on success and on an unknown
  outcome; refusals and timeouts are toasted once instead of holding the error line.
- The action is offered only on sent prompts that opened their own turn (no steers, unsent,
  queued, /compact or goal rows), and not at all where the provider cannot rewind.
- Rewind is held behind host-queued cards, gets the command's 195 s remote timeout, focuses the
  composer after returning the message, drops the message count, and uses plain copy.
---
 ...NativeChatMessageList.rewind-rows.test.tsx | 125 +++++++
 .../native-chat/NativeChatMessageRow.test.tsx |  12 +-
 .../NativeChatRewindAction.target.test.tsx    |   8 +-
 .../NativeChatRewindAction.test.tsx           |  19 +-
 .../native-chat/NativeChatRewindAction.tsx    |   2 +-
 ...tiveChatStructuredSession.test-harness.tsx |   2 +-
 .../NativeChatStructuredSession.tsx           |  21 +-
 ...tiveChatStructuredSessionDelivery.test.tsx |   2 +-
 .../native-chat/NativeChatTranscriptRow.tsx   |  13 +-
 .../native-chat/native-chat-rewind-copy.ts    |  44 ++-
 .../use-native-chat-rewind.test.tsx           | 326 ++++++++++++------
 .../native-chat/use-native-chat-rewind.ts     | 243 +++++++------
 ...tured-agent-session.rewind-outbox.test.tsx |  39 +--
 ...e-structured-agent-session.rewind.test.tsx | 108 +++++-
 .../use-structured-agent-session.ts           |  18 +-
 src/renderer/src/i18n/locales/en.json         |  34 +-
 .../structured-agent-session-client.test.ts   |   9 +-
 .../structured-agent-session-client.ts        |   2 +
 src/shared/native-chat-types.ts               |   2 +
 .../structured-agent-session-projection.ts    |   4 +-
 20 files changed, 720 insertions(+), 313 deletions(-)
 create mode 100644 src/renderer/src/components/native-chat/NativeChatMessageList.rewind-rows.test.tsx

diff --git a/src/renderer/src/components/native-chat/NativeChatMessageList.rewind-rows.test.tsx b/src/renderer/src/components/native-chat/NativeChatMessageList.rewind-rows.test.tsx
new file mode 100644
index 000000000000..e6b9d37d0163
--- /dev/null
+++ b/src/renderer/src/components/native-chat/NativeChatMessageList.rewind-rows.test.tsx
@@ -0,0 +1,125 @@
+// @vitest-environment happy-dom
+
+import '@testing-library/jest-dom/vitest'
+
+import { cleanup, render, screen } from '@testing-library/react'
+import { afterAll, afterEach, beforeAll, describe, expect, it, vi } from 'vitest'
+import {
+  agentJournalItemKey,
+  agentJournalSubmissionKey
+} from '../../../../shared/agent-session-journal-item-key'
+import type {
+  AgentJournalItemBody,
+  AgentJournalRenderItem,
+  AgentJournalSubmission,
+  AgentJournalTurnScope
+} from '../../../../shared/agent-session-journal-types'
+import { projectStructuredAgentSessionMessages } from '../../../../shared/structured-agent-session-message-projection'
+import { TooltipProvider } from '@/components/ui/tooltip'
+import { NativeChatMessageList } from './NativeChatMessageList'
+import { installNativeChatMessageListTestViewport } from './native-chat-message-list-test-viewport'
+
+vi.mock('@/components/confirmation-dialog-context', () => ({
+  useConfirmationDialog: () => vi.fn()
+}))
+
+let restoreViewport = (): void => {}
+beforeAll(() => {
+  restoreViewport = installNativeChatMessageListTestViewport()
+})
+afterAll(() => restoreViewport())
+afterEach(cleanup)
+
+const THREAD: AgentJournalTurnScope = { kind: 'thread' }
+const inTurn = (turnItemId: string): AgentJournalTurnScope => ({ kind: 'turn', turnItemId })
+let sequence = 0
+function item(
+  itemId: string,
+  body: AgentJournalItemBody,
+  turnScope: AgentJournalTurnScope = THREAD
+): AgentJournalRenderItem {
+  sequence += 1
+  return { itemId, revision: 0, sequence, observedAt: sequence, body, turnScope }
+}
+const say = (
+  itemId: string,
+  role: 'user' | 'assistant',
+  text: string,
+  scope: AgentJournalTurnScope = THREAD,
+  extra: { command?: { name: string } } = {}
+) => item(itemId, { kind: 'message', role, blocks: [{ type: 'text', text }], ...extra }, scope)
+const settledTurn = (itemId: string, userItemId: string, start: number) =>
+  item(itemId, {
+    kind: 'turn',
+    turnId: itemId,
+    state: 'completed',
+    outcome: 'success',
+    userItemId,
+    startedAt: start,
+    completedAt: start + 1_000
+  })
+
+describe('which transcript rows offer Edit from here', () => {
+  it('offers it only on prompts that opened their own turn', () => {
+    const steer = agentJournalSubmissionKey('steer')
+    const compact = agentJournalItemKey({ provider: 'orca', clientMessageId: 'cmd-1' })
+    const items = [
+      say('u1', 'user', 'List three fruits'),
+      settledTurn('t1', 'u1', 1_000),
+      say(steer, 'user', 'Make it four', inTurn('t1')),
+      say('t1-answer', 'assistant', 'Apple, banana, cherry, date.', inTurn('t1')),
+      say(compact, 'user', '/compact', THREAD, { command: { name: 'compact' } }),
+      settledTurn('t2', compact, 5_000),
+      say('u3', 'user', 'Now vegetables'),
+      settledTurn('t3', 'u3', 9_000),
+      say('t3-answer', 'assistant', 'Carrot.', inTurn('t3'))
+    ]
+    const submissions: AgentJournalSubmission[] = [
+      {
+        clientMessageId: 'steer',
+        fence: 1,
+        payloadFingerprint: 'steer',
+        dispatchState: 'accepted',
+        providerItemId: null,
+        reason: null,
+        submittedAt: 2_000,
+        resolvedAt: 2_100
+      }
+    ]
+    render(
+      <TooltipProvider>
+        <NativeChatMessageList
+          session={{
+            messages: projectStructuredAgentSessionMessages(items, [], submissions, {
+              rejectedInPlace: true
+            }),
+            status: 'ready',
+            sessionId: 'session-1',
+            agent: 'codex',
+            hasMore: false,
+            loadingEarlier: false,
+            olderHistoryGeneration: 0,
+            loadEarlier: vi.fn(),
+            readPhase: 'ready'
+          }}
+          journalItems={items}
+          journalSubmissions={submissions}
+          isWorking={false}
+          expandSignal={false}
+          fontScale={1}
+          rewind={{ disabledReason: null, request: vi.fn() }}
+        />
+      </TooltipProvider>
+    )
+    expect(screen.getByText('Make it four')).toBeInTheDocument()
+    expect(screen.getByText('/compact')).toBeInTheDocument()
+    const offered = screen.getAllByRole('button', { name: 'Edit from here' })
+    const after = (later: Element, earlier: Element) =>
+      Boolean(earlier.compareDocumentPosition(later) & Node.DOCUMENT_POSITION_FOLLOWING)
+    // The opener's and the last prompt's; the steer and the /compact row get none.
+    expect(offered).toHaveLength(2)
+    expect(after(offered[0]!, screen.getByText('List three fruits'))).toBe(true)
+    expect(after(screen.getByText('Make it four'), offered[0]!)).toBe(true)
+    expect(after(offered[1]!, screen.getByText('Now vegetables'))).toBe(true)
+  })
+})
diff --git a/src/renderer/src/components/native-chat/NativeChatMessageRow.test.tsx b/src/renderer/src/components/native-chat/NativeChatMessageRow.test.tsx
index efbbfd1bbc4d..d97a30041718 100644
--- a/src/renderer/src/components/native-chat/NativeChatMessageRow.test.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatMessageRow.test.tsx
@@ -103,17 +103,17 @@ describe('MessageRow control visibility', () => {
     expect(time).toHaveFocus()
   })
 
-  it('composes the revert action into the user hover/focus strip', () => {
+  it('composes the edit-from-here action into the user hover/focus strip', () => {
     const request = vi.fn()
     renderMessage('user', 0, { disabledReason: null, request })
     const copy = screen.getByRole('button', { name: 'Copy message' })
     const time = screen.getByRole('time')
-    const revert = screen.getByRole('button', { name: 'Revert to here' })
-    expect(Array.from(copy.parentElement!.children)).toEqual([copy, time, revert])
+    const edit = screen.getByRole('button', { name: 'Edit from here' })
+    expect(Array.from(copy.parentElement!.children)).toEqual([copy, time, edit])
     expect(copy.parentElement).toHaveClass('can-hover:opacity-0', 'group-hover:opacity-100')
-    revert.focus()
-    expect(revert).toHaveFocus()
-    fireEvent.click(revert)
+    edit.focus()
+    expect(edit).toHaveFocus()
+    fireEvent.click(edit)
     expect(request).toHaveBeenCalledWith('message', confirm)
   })
 
diff --git a/src/renderer/src/components/native-chat/NativeChatRewindAction.target.test.tsx b/src/renderer/src/components/native-chat/NativeChatRewindAction.target.test.tsx
index fcf79010cadb..8f0a266df0e9 100644
--- a/src/renderer/src/components/native-chat/NativeChatRewindAction.target.test.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatRewindAction.target.test.tsx
@@ -95,7 +95,7 @@ describe('rewind target after send acceptance', () => {
       </TooltipProvider>
     )
     const view = render(row())
-    fireEvent.click(screen.getByRole('button', { name: 'Revert to here' }))
+    fireEvent.click(screen.getByRole('button', { name: 'Edit from here' }))
     expect(confirm).not.toHaveBeenCalled()
 
     const providerItemId = agentJournalItemKey(
@@ -131,7 +131,7 @@ describe('rewind target after send acceptance', () => {
     }
 
     view.rerender(row())
-    fireEvent.click(screen.getByRole('button', { name: 'Revert to here' }))
+    fireEvent.click(screen.getByRole('button', { name: 'Edit from here' }))
     await waitFor(() =>
       expect(mocks.call).toHaveBeenCalledWith(
         target,
@@ -140,8 +140,6 @@ describe('rewind target after send acceptance', () => {
       )
     )
     expect(confirm).toHaveBeenCalledOnce()
-    expect(confirm).toHaveBeenCalledWith(
-      expect.objectContaining({ description: expect.stringContaining('1 in total') })
-    )
+    expect(confirm).toHaveBeenCalledWith(expect.objectContaining({ title: 'Edit from here?' }))
   })
 })
diff --git a/src/renderer/src/components/native-chat/NativeChatRewindAction.test.tsx b/src/renderer/src/components/native-chat/NativeChatRewindAction.test.tsx
index 3de89da97865..5d9780c036fc 100644
--- a/src/renderer/src/components/native-chat/NativeChatRewindAction.test.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatRewindAction.test.tsx
@@ -39,7 +39,7 @@ function row(
 describe('user-row rewind affordance', () => {
   it('is keyboard reachable and calls the selected user item from the hover strip', () => {
     const request = row('user')
-    const button = screen.getByRole('button', { name: 'Revert to here' })
+    const button = screen.getByRole('button', { name: 'Edit from here' })
     button.focus()
     expect(button).toHaveFocus()
     expect(button.parentElement).toHaveClass(
@@ -50,27 +50,24 @@ describe('user-row rewind affordance', () => {
     expect(request).toHaveBeenCalledWith('user-1', confirm)
   })
   it('exposes the disabled reason to keyboard users and cannot invoke rewind', async () => {
-    const request = row('user', 'This older Codex conversation does not support rewinding.')
-    const button = screen.getByRole('button', { name: 'Revert to here' })
+    const request = row('user', 'Wait for the current turn to finish first.')
+    const button = screen.getByRole('button', { name: 'Edit from here' })
     expect(button).toHaveAttribute('aria-disabled', 'true')
-    expect(button).toHaveAttribute(
-      'aria-description',
-      'This older Codex conversation does not support rewinding.'
-    )
+    expect(button).toHaveAttribute('aria-description', 'Wait for the current turn to finish first.')
     act(() => button.focus())
     expect(button).toHaveFocus()
     expect(await screen.findByRole('tooltip')).toHaveTextContent(
-      'This older Codex conversation does not support rewinding.'
+      'Wait for the current turn to finish first.'
     )
     fireEvent.click(button)
     expect(request).not.toHaveBeenCalled()
   })
   it.each(['assistant', 'reasoning', 'system'] as const)('omits rewind for %s', (role) => {
     row(role)
-    expect(screen.queryByRole('button', { name: 'Revert to here' })).toBeNull()
+    expect(screen.queryByRole('button', { name: 'Edit from here' })).toBeNull()
   })
-  it('leaves legacy user rows without rewind', () => {
+  it('renders nothing where the row is offered no rewind', () => {
     row('user', null, false)
-    expect(screen.queryByRole('button', { name: 'Revert to here' })).toBeNull()
+    expect(screen.queryByRole('button', { name: 'Edit from here' })).toBeNull()
   })
 })
diff --git a/src/renderer/src/components/native-chat/NativeChatRewindAction.tsx b/src/renderer/src/components/native-chat/NativeChatRewindAction.tsx
index 3924f653fcd5..197002e01c6f 100644
--- a/src/renderer/src/components/native-chat/NativeChatRewindAction.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatRewindAction.tsx
@@ -12,7 +12,7 @@ export function NativeChatRewindAction({
   rewind: NativeChatRewindSurface
 }) {
   const confirm = useConfirmationDialog()
-  const label = translate('components.native-chat.rewind.action', 'Revert to here')
+  const label = translate('components.native-chat.rewind.action', 'Edit from here')
   return (
     <Tooltip>
       <TooltipTrigger asChild>
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 486ea7f433ac..e7ca1b7564a0 100644
--- a/src/renderer/src/components/native-chat/NativeChatStructuredSession.test-harness.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatStructuredSession.test-harness.tsx
@@ -231,7 +231,7 @@ export function createStructuredSessionMocks() {
             },
             turnId: mocks.turnId,
             epoch: 'epoch-1',
-            rewind: { disabledReason: null, pending: false, request: async () => {} },
+            rewind: { surface: undefined },
             canStop: mocks.canStop ?? mocks.turnId !== null,
             stop: mocks.stop,
             queuedMessages: {
diff --git a/src/renderer/src/components/native-chat/NativeChatStructuredSession.tsx b/src/renderer/src/components/native-chat/NativeChatStructuredSession.tsx
index ddd10b61957f..663b32c4ae3f 100644
--- a/src/renderer/src/components/native-chat/NativeChatStructuredSession.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatStructuredSession.tsx
@@ -1,4 +1,4 @@
-import { useMemo, useRef, useState } from 'react'
+import { useCallback, useMemo, useRef, useState } from 'react'
 import { agentSessionPromptQuestions } from '../../../../shared/agent-session-question-answer'
 import { dispatchStructuredAgentSessionComposerCommand } from '../../../../shared/structured-agent-session-composer'
 import { structuredAgentSessionPaneKey } from '../../../../shared/structured-agent-session-projection'
@@ -56,12 +56,16 @@ export function NativeChatStructuredSession(
   )
   // Chat-wide: absent means on; only an explicit off keeps mid-turn sends immediate.
   const queueFollowUps = useAppStore((store) => store.settings?.nativeChatQueueFollowUps !== false)
+  const composerRef = useRef<NativeChatComposerHandle>(null)
+  const focusComposer = useCallback(() => {
+    composerRef.current?.focus()
+  }, [])
   const controller = useStructuredAgentSession({
     ...props,
     composerScopeKey: paneKey,
     queueFollowUps,
     providerStarting: startupPhase === 'starting',
-    rewindBlockedReason,
+    rewind: { hostBlockedReason: rewindBlockedReason, onMessageReturned: focusComposer },
     transportEnabled: provisionalLaunch.transportEnabled,
     ...(provisionalLaunch.launch ? { launch: provisionalLaunch.launch } : {})
   })
@@ -73,18 +77,12 @@ export function NativeChatStructuredSession(
     // phases, that empty list must not become the draft's turn baseline.
     transcriptLoading: controller.status === 'idle' || controller.status === 'loading'
   })
-  const { disabledReason: rewindDisabledReason, request: requestRewind } = controller.rewind
-  const rewind = useMemo(
-    () => ({ disabledReason: rewindDisabledReason, request: requestRewind }),
-    [rewindDisabledReason, requestRewind]
-  )
   const [composerError, setComposerError] = useState<string | null>(null)
   const [optionPickerRequest, setOptionPickerRequest] = useState<{
     id: string
     sequence: number
   } | null>(null)
   const rootRef = useRef<HTMLDivElement>(null)
-  const composerRef = useRef<NativeChatComposerHandle>(null)
   const paneCommands = useStructuredNativeChatPaneCommands({
     tabId: props.tabId,
     groupId: props.groupId,
@@ -276,7 +274,7 @@ export function NativeChatStructuredSession(
           <NativeChatMessageList
             // A rewind replaces the conversation; nothing the old transcript held carries over.
             key={controller.epoch ?? undefined}
-            rewind={rewind}
+            rewind={controller.rewind.surface}
             session={session}
             journalItems={controller.journalItems}
             journalSubmissions={controller.submissions}
@@ -308,9 +306,7 @@ export function NativeChatStructuredSession(
           {/* Host-held drafts, never transcript rows. Above the status area, so running shells and agents sit next to the composer. */}
           <NativeChatQueuedMessageList
             controller={controller.queuedMessages}
-            focusComposer={() => {
-              composerRef.current?.focus()
-            }}
+            focusComposer={focusComposer}
           />
           <NativeChatStructuredSessionStatus
             sessionId={props.sessionId}
@@ -393,7 +389,6 @@ export function NativeChatStructuredSession(
               paneKey={paneKey}
               targetPtyId={null}
               agent={props.agent}
-              canSend={!controller.rewind.pending}
               isWorking={controller.canStop}
               onStop={() => void controller.stop()}
               steerQueued={controller.queuedMessages.steerNewest}
diff --git a/src/renderer/src/components/native-chat/NativeChatStructuredSessionDelivery.test.tsx b/src/renderer/src/components/native-chat/NativeChatStructuredSessionDelivery.test.tsx
index 54a9ed1acc89..bab9e6f9efa2 100644
--- a/src/renderer/src/components/native-chat/NativeChatStructuredSessionDelivery.test.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatStructuredSessionDelivery.test.tsx
@@ -94,7 +94,7 @@ vi.mock('./use-structured-agent-session', async () => {
         backgroundTasks: mocks.backgroundTasks,
         turnId: null,
         epoch: 'epoch-1',
-        rewind: { disabledReason: null, pending: false, request: vi.fn() },
+        rewind: { surface: undefined },
         cancel: vi.fn(),
         queuedMessages: {
           cards: [],
diff --git a/src/renderer/src/components/native-chat/NativeChatTranscriptRow.tsx b/src/renderer/src/components/native-chat/NativeChatTranscriptRow.tsx
index 084f93f45b7c..fa57ed66db9d 100644
--- a/src/renderer/src/components/native-chat/NativeChatTranscriptRow.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatTranscriptRow.tsx
@@ -12,7 +12,7 @@ import type { NativeChatSubagentDisclosure } from './native-chat-subagent-sectio
 import type { NativeChatTaskListPredecessors } from './native-chat-task-list-history'
 import type { NativeChatTranscriptSlot } from './native-chat-transcript-slots'
 import type { NativeChatDiffReveal, NativeChatDiffTarget } from './native-chat-turn-diffs'
-import type { NativeChatRewindSurface } from './use-native-chat-rewind'
+import { nativeChatRowOffersRewind, type NativeChatRewindSurface } from './use-native-chat-rewind'
 
 /** Everything a row needs that is the same for every row. Held as one memoized
  *  object so a row's props change only when that row's own slot does. */
@@ -30,7 +30,7 @@ export type NativeChatTranscriptRowContext = {
   subagentDisclosure: NativeChatSubagentDisclosure
   onScrollMessageToTop: (element: HTMLElement) => void
   onRevealDiff: (target: NativeChatDiffTarget) => void
-  /** Offered on the conversation's own user rows, never inside a subagent's section. */
+  /** Offered on the conversation's own turn-opening prompts (`nativeChatRowOffersRewind`). */
   rewind?: NativeChatRewindSurface
 }
 
@@ -76,6 +76,7 @@ export const NativeChatTranscriptRow = memo(function NativeChatTranscriptRow({
     )
   }
   const { message, turnKey, status, receipt, turnDiff } = slot
+  const deliveryNotice = context.deliveryNotices?.get(message.id)
   const predecessors = context.taskListPredecessors.get(message.id)
   const expanded = turnKey ? context.expandedTurnIds.has(turnKey) : undefined
   const statusRow = status ? (
@@ -109,13 +110,17 @@ export const NativeChatTranscriptRow = memo(function NativeChatTranscriptRow({
           onScrollMessageToTop={context.onScrollMessageToTop}
           onLinkClick={context.onLinkClick}
           allowFileUriLinks={context.allowFileUriLinks}
-          deliveryNotice={context.deliveryNotices?.get(message.id)}
+          deliveryNotice={deliveryNotice}
           folded={slot.folded}
           subagentRoster={slot.subagentRoster}
           subagentDisclosure={context.subagentDisclosure}
           inSubagentSection={slot.depth > 0}
           runtimeContext={context.runtimeContext}
-          rewind={message.role === 'user' && slot.depth === 0 ? context.rewind : undefined}
+          rewind={
+            nativeChatRowOffersRewind(message, slot, deliveryNotice !== undefined)
+              ? context.rewind
+              : undefined
+          }
         />
       )}
       {slot.statusAbove ? null : statusRow}
diff --git a/src/renderer/src/components/native-chat/native-chat-rewind-copy.ts b/src/renderer/src/components/native-chat/native-chat-rewind-copy.ts
index a1f69708d17b..3e34332e1623 100644
--- a/src/renderer/src/components/native-chat/native-chat-rewind-copy.ts
+++ b/src/renderer/src/components/native-chat/native-chat-rewind-copy.ts
@@ -8,47 +8,47 @@ const reasonCopy = {
   unsupported: () =>
     translate(
       'components.native-chat.rewind.unsupported',
-      'This session does not support rewinding conversation history.'
+      "This chat can't go back to an earlier message."
     ),
   'history-not-paginated': () =>
     translate(
       'components.native-chat.rewind.historyNotPaginated',
-      'This older Codex conversation does not support rewinding. Start a new conversation to use rewind.'
+      "This older Codex chat can't go back to an earlier message. Start a new chat to use Edit from here."
     ),
   busy: () =>
     translate(
       'components.native-chat.rewind.busy',
-      'Wait for the current turn, pending messages, approvals, and background work to finish before rewinding.'
+      'Wait for the current turn, queued messages, approvals, and background work to finish first.'
     ),
   'stale-epoch': () =>
     translate(
       'components.native-chat.rewind.staleEpoch',
-      'The conversation changed. Review the latest messages before rewinding.'
+      'The conversation changed. Review the latest messages and try again.'
     ),
   'invalid-target': () =>
     translate(
       'components.native-chat.rewind.invalidTarget',
-      'This message is no longer a valid rewind point. Review the latest conversation.'
+      "The conversation can't go back to this message. Nothing was changed."
     ),
   'history-limit': () =>
     translate(
       'components.native-chat.rewind.historyLimit',
-      'This conversation is too large to rewind safely. Nothing was changed.'
+      'This conversation is too long to go back in. Nothing was changed.'
     ),
   'provider-refused': () =>
     translate(
       'components.native-chat.rewind.providerRefused',
-      'The agent refused to rewind this conversation.'
+      "The agent couldn't go back to this message."
     ),
   'proof-mismatch': () =>
     translate(
       'components.native-chat.rewind.proofMismatch',
-      'Orca could not verify the conversation boundary. Reload the session before trying again.'
+      "The agent's history didn't match this chat. Check the conversation before continuing."
     ),
   'outcome-unknown': () =>
     translate(
       'components.native-chat.rewind.outcomeUnknown',
-      'The rewind may have completed, but Orca could not confirm it. Sending is blocked until the outcome is resolved.'
+      "Orca couldn't confirm whether the conversation went back to an earlier message. It checks before your next message is sent."
     )
 } satisfies Record<AgentSessionRewindReason, () => string>
 
@@ -58,13 +58,35 @@ export function nativeChatRewindReasonCopy(reason: string | undefined): string {
     ? reasonCopy[known]()
     : translate(
         'components.native-chat.rewind.refused',
-        'Orca could not rewind this conversation. Reload the session to check its current state.'
+        "Orca couldn't go back to this message. Check the conversation before continuing."
       )
 }
 
 export function nativeChatRewindUnavailableCopy(): string {
   return translate(
     'components.native-chat.rewind.unavailable',
-    'Reconnect to a writable chat session before rewinding.'
+    'Wait for the chat to finish connecting.'
+  )
+}
+
+/** The unknown outcome, said where the message has already gone back to the composer. */
+export function nativeChatRewindReturnedUnknownCopy(): string {
+  return translate(
+    'components.native-chat.rewind.outcomeUnknownReturned',
+    "Orca couldn't confirm whether the conversation went back to this message. Your message is back in the composer, and Orca checks the conversation before your next message is sent."
+  )
+}
+
+export function nativeChatRewindTimeoutCopy(): string {
+  return translate(
+    'components.native-chat.rewind.timeout',
+    "Orca couldn't confirm in time that the conversation went back to this message. Check the conversation before continuing."
+  )
+}
+
+export function nativeChatRewindPendingCopy(): string {
+  return translate(
+    'components.native-chat.rewind.pending',
+    'Wait for the conversation to go back to the earlier message.'
   )
 }
diff --git a/src/renderer/src/components/native-chat/use-native-chat-rewind.test.tsx b/src/renderer/src/components/native-chat/use-native-chat-rewind.test.tsx
index 54436f6f86b7..b0c08beeb8e5 100644
--- a/src/renderer/src/components/native-chat/use-native-chat-rewind.test.tsx
+++ b/src/renderer/src/components/native-chat/use-native-chat-rewind.test.tsx
@@ -1,23 +1,49 @@
 // @vitest-environment happy-dom
 import { act, cleanup, renderHook } from '@testing-library/react'
-import { afterEach, describe, expect, it, vi } from 'vitest'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+
+const toastError = vi.hoisted(() => vi.fn())
+vi.mock('sonner', () => ({ toast: { error: toastError } }))
+
 import { AGENT_SESSION_REWIND_REASONS } from '../../../../shared/agent-session-rewind'
 import { EMPTY_STRUCTURED_AGENT_SESSION } from '../../../../shared/structured-agent-session-reducer'
 import type { AgentJournalRenderItem } from '../../../../shared/agent-session-journal-types'
-import { countNativeChatRewindMessages, useNativeChatRewind } from './use-native-chat-rewind'
-import { nativeChatRewindReasonCopy } from './native-chat-rewind-copy'
+import type { NativeChatMessage } from '../../../../shared/native-chat-types'
+import {
+  NATIVE_CHAT_REWIND_RESET_TIMEOUT_MS,
+  nativeChatRowOffersRewind,
+  useNativeChatRewind
+} from './use-native-chat-rewind'
+import {
+  nativeChatRewindPendingCopy,
+  nativeChatRewindReasonCopy,
+  nativeChatRewindReturnedUnknownCopy,
+  nativeChatRewindTimeoutCopy
+} from './native-chat-rewind-copy'
 import {
   parseAgentSessionWriteFailure,
   type AgentSessionWriteFailure
 } from '../../../../shared/agent-session-write-failure'
+import { readNativeChatDraftCache, writeNativeChatDraftCache } from './native-chat-draft-cache'
+
+type Input = Parameters<typeof useNativeChatRewind>[0]
 
 afterEach(cleanup)
+beforeEach(() => {
+  toastError.mockReset()
+  writeNativeChatDraftCache('pane', '')
+})
 const done = { kind: 'done' as const, value: { itemId: 'user', epoch: 'new' } }
 const notDone = (failure: AgentSessionWriteFailure) => ({
   kind: 'not-done' as const,
   notice: '',
   failure
 })
+const unknownRefusal: AgentSessionWriteFailure = {
+  kind: 'refused',
+  code: 'agent_session_operation_unknown',
+  details: { reason: 'rewindUnconfirmed', rewindReason: 'outcome-unknown' }
+}
 const item = (
   itemId: string,
   sequence: number,
@@ -27,11 +53,12 @@ const item = (
   sequence,
   revision: 1,
   observedAt: sequence,
-  body: { kind: 'message', role, blocks: [{ type: 'text', text: itemId }] }
+  body: { kind: 'message', role, blocks: [{ type: 'text', text: `text of ${itemId}` }] }
 })
-function input() {
+function input(): Input & { send: ReturnType<typeof vi.fn> } {
   return {
     sessionId: 'session',
+    composerScopeKey: 'pane',
     state: {
       ...EMPTY_STRUCTURED_AGENT_SESSION,
       epoch: 'old',
@@ -52,36 +79,51 @@ function deferred<T>() {
   })
   return { promise, resolve }
 }
+function render(props: Input) {
+  return renderHook((value: Input) => useNativeChatRewind(value), { initialProps: props })
+}
 
 describe('structured chat rewind', () => {
-  it('confirms the exact suffix count even when earlier history is unloaded', async () => {
+  it('confirms without a count, sends, and returns the message', async () => {
     const props = input()
-    props.state.hasOlder = true
-    expect(countNativeChatRewindMessages(props.state, 'user')).toBe(3)
-    expect(countNativeChatRewindMessages(props.state, 'reply')).toBe(0)
+    const onMessageReturned = vi.fn()
     const confirm = vi.fn().mockResolvedValue(true)
-    const view = renderHook(() => useNativeChatRewind(props))
+    const view = render({ ...props, onMessageReturned })
     await act(() => view.result.current.request('user', confirm))
     expect(confirm).toHaveBeenCalledWith(
       expect.objectContaining({
+        title: 'Edit from here?',
+        confirmLabel: 'Discard and edit',
         confirmVariant: 'destructive',
-        description: expect.stringContaining('3 in total')
+        description: expect.not.stringMatching(/in total/)
       })
     )
     expect(props.send).toHaveBeenCalledWith({ itemId: 'user', expectedEpoch: 'old' })
-    expect(view.result.current.pending).toBe(true)
-    expect(view.result.current.blockedRef.current).toBe(true)
+    expect(readNativeChatDraftCache('pane')).toContain('text of user')
+    expect(onMessageReturned).toHaveBeenCalledOnce()
+    expect(toastError).not.toHaveBeenCalled()
+  })
+
+  it('offers nothing for a row the journal does not hold as a user message', async () => {
+    const props = input()
+    const confirm = vi.fn()
+    const view = render(props)
+    await act(() => view.result.current.request('reply', confirm))
+    await act(() => view.result.current.request('missing', confirm))
+    expect(confirm).not.toHaveBeenCalled()
   })
 
-  it('cancels without sending and blocks duplicate clicks while confirming', async () => {
+  it('blocks nothing while the confirmation is open, and ignores a second click', async () => {
     const props = input(),
       confirmation = deferred<boolean>()
     const confirm = vi.fn(() => confirmation.promise)
-    const view = renderHook(() => useNativeChatRewind(props))
+    const view = render(props)
     let request!: Promise<void>
     act(() => {
       request = view.result.current.request('user', confirm)
     })
+    expect(view.result.current.pending).toBe(false)
+    expect(view.result.current.blockedRef.current).toBe(false)
     await act(() => view.result.current.request('user', confirm))
     expect(confirm).toHaveBeenCalledOnce()
     await act(async () => {
@@ -92,53 +134,50 @@ describe('structured chat rewind', () => {
     expect(view.result.current.pending).toBe(false)
   })
 
-  it('keeps sending blocked after reopening while the host reports an unresolved rewind', async () => {
-    const props: Parameters<typeof useNativeChatRewind>[0] = {
-      ...input(),
-      hostBlockedReason: 'outcome-unknown'
-    }
-    const view = renderHook((value) => useNativeChatRewind(value), { initialProps: props })
-    expect(view.result.current.error).toContain('may have completed')
-    expect(view.result.current.disabledReason).toContain('Sending is blocked')
-    expect(view.result.current.blockedRef.current).toBe(true)
-    expect(view.result.current.pending).toBe(true)
-    const confirm = vi.fn()
-    await act(() => view.result.current.request('user', confirm))
-    expect(confirm).not.toHaveBeenCalled()
-    view.rerender({ ...props, hostBlockedReason: undefined })
-    expect(view.result.current.error).toBeNull()
-    expect(view.result.current.pending).toBe(false)
-    expect(view.result.current.blockedRef.current).toBe(false)
-  })
-
-  it('does not label its in-flight request as an unknown outcome when the host prepares recovery', async () => {
+  it('blocks only while the confirmed request is in flight', async () => {
     const props = input(),
       response = deferred<typeof done>()
     props.send.mockReturnValue(response.promise)
-    const view = renderHook<
-      ReturnType<typeof useNativeChatRewind>,
-      Parameters<typeof useNativeChatRewind>[0]
-    >((value) => useNativeChatRewind(value), { initialProps: props })
+    const view = render(props)
     let request!: Promise<void>
     await act(async () => {
       request = view.result.current.request('user', async () => true)
     })
-    view.rerender({ ...props, hostBlockedReason: 'outcome-unknown' })
     expect(view.result.current.pending).toBe(true)
-    expect(view.result.current.error).toBeNull()
+    expect(view.result.current.blockedRef.current).toBe(true)
+    expect(view.result.current.disabledReason).toBe(nativeChatRewindPendingCopy())
+    // The host's latch covers its own in-flight work; it does not relabel ours.
+    view.rerender({ ...props, hostBlockedReason: 'outcome-unknown' })
+    expect(view.result.current.disabledReason).toBe(nativeChatRewindPendingCopy())
     await act(async () => {
+      view.rerender({ ...props, state: { ...props.state, epoch: 'new', items: [] } })
       response.resolve(done)
       await request
     })
-    expect(view.result.current.error).toBeNull()
-    view.rerender({ ...props, state: { ...props.state, epoch: 'new' } })
     expect(view.result.current.pending).toBe(false)
+    expect(view.result.current.blockedRef.current).toBe(false)
+  })
+
+  it("lets the host's in-doubt latch disable only the action, never sending", async () => {
+    const props: Input = { ...input(), hostBlockedReason: 'outcome-unknown' }
+    const view = render(props)
+    expect(view.result.current.disabledReason).toBe(nativeChatRewindReasonCopy('outcome-unknown'))
+    expect(view.result.current.blockedRef.current).toBe(false)
+    expect(view.result.current.pending).toBe(false)
+    const run = vi.fn()
+    view.result.current.unlessBlocked(run)()
+    expect(run).toHaveBeenCalledOnce()
+    const confirm = vi.fn()
+    await act(() => view.result.current.request('user', confirm))
+    expect(confirm).not.toHaveBeenCalled()
+    view.rerender({ ...props, hostBlockedReason: undefined })
+    expect(view.result.current.disabledReason).toBeNull()
   })
 
   it('does not execute a confirmation after its pane unmounts', async () => {
     const props = input(),
       confirmation = deferred<boolean>()
-    const view = renderHook(() => useNativeChatRewind(props))
+    const view = render(props)
     let request!: Promise<void>
     act(() => {
       request = view.result.current.request('user', () => confirmation.promise)
@@ -151,40 +190,56 @@ describe('structured chat rewind', () => {
     expect(props.send).not.toHaveBeenCalled()
   })
 
-  it.each(['busy', 'unwritable', 'legacy', 'loading-support'] as const)(
+  it.each(['busy', 'unwritable', 'loading'] as const)(
     'disables %s sessions with explanatory copy',
     async (mode) => {
-      const props: Parameters<typeof useNativeChatRewind>[0] = input()
-      if (mode === 'loading-support') {
-        props.support = undefined
-      }
+      const props = input()
       if (mode === 'busy') {
         props.blocked = true
       }
       if (mode === 'unwritable') {
         props.state.fence = null
       }
-      if (mode === 'legacy') {
-        props.support = { supported: false, reason: 'history-not-paginated' }
+      if (mode === 'loading') {
+        props.state.status = 'loading'
       }
       const confirm = vi.fn()
-      const view = renderHook(() => useNativeChatRewind(props))
+      const view = render(props)
+      expect(view.result.current.surface).toBeDefined()
       expect(view.result.current.disabledReason).toBeTruthy()
-      if (mode === 'legacy') {
-        expect(view.result.current.disabledReason).toContain('older Codex conversation')
-      }
       await act(() => view.result.current.request('user', confirm))
       expect(confirm).not.toHaveBeenCalled()
       expect(props.send).not.toHaveBeenCalled()
     }
   )
 
+  it.each([
+    ['unresolved', undefined],
+    ['unsupported', { supported: false, reason: 'unsupported' }],
+    ['legacy', { supported: false, reason: 'history-not-paginated' }]
+  ] as const)('offers no action where support is %s', async (_mode, support) => {
+    const props: Input = { ...input(), support }
+    const confirm = vi.fn()
+    const view = render(props)
+    expect(view.result.current.surface).toBeUndefined()
+    await act(() => view.result.current.request('user', confirm))
+    expect(confirm).not.toHaveBeenCalled()
+  })
+
+  it('still offers the action when the options read answered while the host was in doubt', () => {
+    const view = render({ ...input(), support: { supported: false, reason: 'outcome-unknown' } })
+    expect(view.result.current.surface).toEqual({
+      disabledReason: null,
+      request: view.result.current.request
+    })
+  })
+
   it.each(['epoch', 'messages', 'busy'] as const)(
-    'rechecks %s after confirmation',
+    'rechecks %s after confirmation and says so once',
     async (change) => {
       const props = input(),
         confirmation = deferred<boolean>()
-      const view = renderHook((value) => useNativeChatRewind(value), { initialProps: props })
+      const view = render(props)
       let request!: Promise<void>
       act(() => {
         request = view.result.current.request('user', () => confirmation.promise)
@@ -203,7 +258,8 @@ describe('structured chat rewind', () => {
         await request
       })
       expect(props.send).not.toHaveBeenCalled()
-      expect(view.result.current.error).toBeTruthy()
+      expect(toastError).toHaveBeenCalledOnce()
+      expect(view.result.current.pending).toBe(false)
     }
   )
 
@@ -213,7 +269,7 @@ describe('structured chat rewind', () => {
       const props = input(),
         response = deferred<typeof done>()
       props.send.mockReturnValue(response.promise)
-      const view = renderHook((value) => useNativeChatRewind(value), { initialProps: props })
+      const view = render(props)
       let request!: Promise<void>
       await act(async () => {
         request = view.result.current.request('user', async () => true)
@@ -229,6 +285,7 @@ describe('structured chat rewind', () => {
       })
       if (order === 'after') {
         expect(view.result.current.pending).toBe(true)
+        expect(view.result.current.blockedRef.current).toBe(true)
         reset()
       }
       expect(view.result.current.pending).toBe(false)
@@ -236,63 +293,132 @@ describe('structured chat rewind', () => {
     }
   )
 
-  it.each(AGENT_SESSION_REWIND_REASONS)('explains disabled host support: %s', async (reason) => {
-    const props: Parameters<typeof useNativeChatRewind>[0] = {
-      ...input(),
-      support: { supported: false, reason }
+  it('lets go of a confirmed rewind whose new conversation never arrives, and says so once', async () => {
+    vi.useFakeTimers()
+    try {
+      const props = input()
+      const view = render(props)
+      await act(() => view.result.current.request('user', async () => true))
+      expect(view.result.current.blockedRef.current).toBe(true)
+      await act(() => vi.advanceTimersByTimeAsync(NATIVE_CHAT_REWIND_RESET_TIMEOUT_MS - 1))
+      expect(view.result.current.pending).toBe(true)
+      await act(() => vi.advanceTimersByTimeAsync(1))
+      expect(view.result.current.pending).toBe(false)
+      expect(view.result.current.blockedRef.current).toBe(false)
+      expect(toastError).toHaveBeenCalledExactlyOnceWith(nativeChatRewindTimeoutCopy())
+      await act(() => vi.advanceTimersByTimeAsync(NATIVE_CHAT_REWIND_RESET_TIMEOUT_MS))
+      expect(toastError).toHaveBeenCalledOnce()
+    } finally {
+      vi.useRealTimers()
     }
-    const view = renderHook(() => useNativeChatRewind(props))
-    expect(view.result.current.disabledReason).toBe(nativeChatRewindReasonCopy(reason))
-    expect(view.result.current.disabledReason).not.toBe(nativeChatRewindReasonCopy('future-reason'))
-    const confirm = vi.fn()
-    await act(() => view.result.current.request('user', confirm))
-    expect(confirm).not.toHaveBeenCalled()
-    expect(props.send).not.toHaveBeenCalled()
   })
 
-  it.each([...AGENT_SESSION_REWIND_REASONS, 'future-reason'])(
-    'explains refusal %s',
+  it.each([...AGENT_SESSION_REWIND_REASONS.filter((r) => r !== 'outcome-unknown'), 'future'])(
+    'toasts refusal %s once, unblocks, and keeps the message where it is',
     async (rewindReason) => {
       const props = input()
       props.send.mockResolvedValue(
         notDone(
-          rewindReason === 'outcome-unknown'
-            ? {
-                kind: 'refused',
-                code: 'agent_session_operation_unknown',
-                details: { reason: 'rewindUnconfirmed', rewindReason: 'outcome-unknown' }
-              }
-            : // Parsed as a reply is, so a reason this build does not know is dropped.
-              (parseAgentSessionWriteFailure({
-                kind: 'refused',
-                code: 'agent_session_operation_invalid',
-                details: { reason: 'rewindRefused', rewindReason }
-              }) ?? { kind: 'failed' })
+          // Parsed as a reply is, so a reason this build does not know is dropped.
+          parseAgentSessionWriteFailure({
+            kind: 'refused',
+            code: 'agent_session_operation_invalid',
+            details: { reason: 'rewindRefused', rewindReason }
+          }) ?? { kind: 'failed' }
         )
       )
-      const view = renderHook(() => useNativeChatRewind(props))
+      const onMessageReturned = vi.fn()
+      const view = render({ ...props, onMessageReturned })
       await act(() => view.result.current.request('user', async () => true))
-      expect(view.result.current.error).toBe(nativeChatRewindReasonCopy(rewindReason))
-      if (rewindReason === 'history-limit') {
-        expect(view.result.current.error).toContain('Nothing was changed')
-      }
-      if (rewindReason === 'outcome-unknown') {
-        expect(view.result.current.error).toContain('may have completed')
-        expect(view.result.current.error).toContain('Sending is blocked')
-        expect(view.result.current.error).toContain('until the outcome is resolved')
-        expect(view.result.current.error).not.toContain('failed')
-        expect(view.result.current.pending).toBe(true)
-      }
+      expect(toastError).toHaveBeenCalledExactlyOnceWith(nativeChatRewindReasonCopy(rewindReason))
+      expect(view.result.current.pending).toBe(false)
+      expect(view.result.current.blockedRef.current).toBe(false)
+      expect(readNativeChatDraftCache('pane')).toBe('')
+      expect(onMessageReturned).not.toHaveBeenCalled()
     }
   )
 
-  it('treats a lost transport response as uncertain and never retries', async () => {
+  it.each([
+    ['unconfirmed', { kind: 'unconfirmed' } as const],
+    ['operation-unknown', unknownRefusal]
+  ])(
+    'an unknown outcome (%s) unblocks at once and returns the message',
+    async (_label, failure) => {
+      const props = input()
+      props.send.mockResolvedValue(notDone(failure))
+      const onMessageReturned = vi.fn()
+      const view = render({ ...props, onMessageReturned })
+      await act(() => view.result.current.request('user', async () => true))
+      expect(view.result.current.pending).toBe(false)
+      expect(view.result.current.blockedRef.current).toBe(false)
+      expect(view.result.current.disabledReason).toBeNull()
+      expect(readNativeChatDraftCache('pane')).toContain('text of user')
+      expect(onMessageReturned).toHaveBeenCalledOnce()
+      expect(toastError).toHaveBeenCalledExactlyOnceWith(nativeChatRewindReturnedUnknownCopy())
+      expect(nativeChatRewindReturnedUnknownCopy()).not.toContain('blocked')
+    }
+  )
+
+  it('is not stranded when the host latches and then settles an unknown outcome as refused', async () => {
     const props = input()
     props.send.mockResolvedValue(notDone({ kind: 'unconfirmed' }))
-    const view = renderHook(() => useNativeChatRewind(props))
+    const view = render(props)
     await act(() => view.result.current.request('user', async () => true))
+    view.rerender({ ...props, hostBlockedReason: 'outcome-unknown' })
+    expect(view.result.current.blockedRef.current).toBe(false)
+    view.rerender({ ...props, hostBlockedReason: undefined })
+    expect(view.result.current.blockedRef.current).toBe(false)
+    expect(view.result.current.disabledReason).toBeNull()
+    const confirm = vi.fn().mockResolvedValue(false)
+    await act(() => view.result.current.request('user', confirm))
+    expect(confirm).toHaveBeenCalledOnce()
+  })
+
+  it('keeps the message when an unknown outcome turns out to have rewound', async () => {
+    const props = input()
+    props.send.mockResolvedValue(notDone({ kind: 'unconfirmed' }))
+    const view = render(props)
     await act(() => view.result.current.request('user', async () => true))
-    expect(props.send).toHaveBeenCalledOnce()
-    expect(view.result.current.error).toContain('may have completed')
+    view.rerender({ ...props, state: { ...props.state, epoch: 'new', items: [] } })
+    expect(readNativeChatDraftCache('pane')).toContain('text of user')
+  })
+
+  it('says nothing and returns nothing for a reply the pane stopped waiting on', async () => {
+    const props = input()
+    props.send.mockResolvedValue({ kind: 'dropped' })
+    const view = render(props)
+    await act(() => view.result.current.request('user', async () => true))
+    expect(toastError).not.toHaveBeenCalled()
+    expect(readNativeChatDraftCache('pane')).toBe('')
+    expect(view.result.current.blockedRef.current).toBe(false)
+  })
+})
+
+describe('which rows offer rewind', () => {
+  const message = (fields: Partial<NativeChatMessage> = {}): NativeChatMessage => ({
+    id: 'opener',
+    role: 'user',
+    blocks: [{ type: 'text', text: 'Prompt' }],
+    timestamp: 1,
+    source: 'transcript',
+    ...fields
+  })
+  const opens = { depth: 0, turnKey: 'opener' }
+
+  it('offers a sent prompt that opened its own turn', () => {
+    expect(nativeChatRowOffersRewind(message(), opens, false)).toBe(true)
+  })
+
+  it.each([
+    ['a steer into a running turn', message(), { depth: 0, turnKey: 'earlier-opener' }, false],
+    ['an unsent row', message({ unsent: true }), { depth: 0, turnKey: undefined }, false],
+    ['a row with a delivery notice', message(), opens, true],
+    ['a queued row', message({ queued: true }), opens, false],
+    ['a /compact row', message({ command: { name: 'compact' } }), opens, false],
+    ['a goal', message({ sentAs: 'goal' }), opens, false],
+    ['a subagent prompt', message(), { depth: 1, turnKey: 'opener' }, false],
+    ['an assistant row', message({ role: 'assistant' }), opens, false]
+  ] as const)('never offers %s', (_label, row, slot, notice) => {
+    expect(nativeChatRowOffersRewind(row, slot, notice)).toBe(false)
   })
 })
diff --git a/src/renderer/src/components/native-chat/use-native-chat-rewind.ts b/src/renderer/src/components/native-chat/use-native-chat-rewind.ts
index d226e509e614..55481b70181e 100644
--- a/src/renderer/src/components/native-chat/use-native-chat-rewind.ts
+++ b/src/renderer/src/components/native-chat/use-native-chat-rewind.ts
@@ -1,4 +1,5 @@
-import { useCallback, useLayoutEffect, useMemo, useRef, useState } from 'react'
+import { useCallback, useEffect, useLayoutEffect, useMemo, useRef, useState } from 'react'
+import { toast } from 'sonner'
 import type { ConfirmationDialogContextValue } from '@/components/confirmation-dialog-context'
 import { translate } from '@/i18n/i18n'
 import type {
@@ -8,8 +9,12 @@ import type {
 } from '../../../../shared/agent-session-rewind'
 import type { AgentSessionWriteFailure } from '../../../../shared/agent-session-write-failure'
 import type { StructuredAgentSessionState } from '../../../../shared/structured-agent-session-reducer'
+import type { NativeChatMessage } from '../../../../shared/native-chat-types'
 import {
+  nativeChatRewindPendingCopy,
   nativeChatRewindReasonCopy,
+  nativeChatRewindReturnedUnknownCopy,
+  nativeChatRewindTimeoutCopy,
   nativeChatRewindUnavailableCopy
 } from './native-chat-rewind-copy'
 import type {
@@ -23,13 +28,19 @@ export type NativeChatRewindSurface = {
   request: (itemId: string, confirm: ConfirmationDialogContextValue) => Promise<void>
 }
 
+/** How long a confirmed rewind waits for its new conversation before letting go. */
+export const NATIVE_CHAT_REWIND_RESET_TIMEOUT_MS = 120_000
+
 type RewindInput = {
   sessionId: string
   /** The composer the discarded message returns to, after whatever is typed there. */
   composerScopeKey?: string
+  /** Called once the discarded message is back in the composer. */
+  onMessageReturned?: () => void
   state: StructuredAgentSessionState
   /** Undefined until the host has answered for the current runtime. */
   support: AgentSessionRewindSupport | undefined
+  /** The host's in-doubt latch: disables the action, never sending. */
   hostBlockedReason?: AgentSessionRewindReason
   blocked: boolean
   send: (fields: {
@@ -57,23 +68,42 @@ function rewindFailureReason(failure: AgentSessionWriteFailure): string | undefi
     : undefined
 }
 
-export function countNativeChatRewindMessages(
-  state: StructuredAgentSessionState,
-  itemId: string
-): number {
-  const index = state.items.findIndex(
+/** Whether the provider can rewind at all. An in-doubt read is still capable: the status feed's
+ *  live latch, not this cached read, says when it resolves. */
+export function nativeChatRewindOffered(support: AgentSessionRewindSupport | undefined): boolean {
+  return support !== undefined && (support.supported || support.reason === 'outcome-unknown')
+}
+
+/** A sent prompt that opened its own turn, outside any subagent's section. Codex rewinds whole
+ *  turns, so a steer would also discard its turn's opener; unsent, queued, command and goal rows
+ *  have no turn to go back to. */
+export function nativeChatRowOffersRewind(
+  message: NativeChatMessage,
+  slot: { depth: number; turnKey: string | undefined },
+  hasDeliveryNotice: boolean
+): boolean {
+  return (
+    message.role === 'user' &&
+    slot.depth === 0 &&
+    slot.turnKey === message.id &&
+    !hasDeliveryNotice &&
+    message.queued !== true &&
+    message.command === undefined &&
+    message.sentAs === undefined
+  )
+}
+
+function isRewindTarget(state: StructuredAgentSessionState, itemId: string): boolean {
+  return state.items.some(
     (item) => item.itemId === itemId && item.body.kind === 'message' && item.body.role === 'user'
   )
-  return index === -1
-    ? 0
-    : state.items.slice(index).filter((item) => item.body.kind === 'message').length
 }
 
 function blockedReason(input: RewindInput): string | null {
   if (input.hostBlockedReason) {
     return nativeChatRewindReasonCopy(input.hostBlockedReason)
   }
-  if (input.support?.supported === false) {
+  if (input.support?.supported === false && !nativeChatRewindOffered(input.support)) {
     return nativeChatRewindReasonCopy(input.support.reason)
   }
   const { state } = input
@@ -83,6 +113,16 @@ function blockedReason(input: RewindInput): string | null {
   return input.blocked ? nativeChatRewindReasonCopy('busy') : null
 }
 
+/** Whether the message went back; read from the state the user confirmed against. */
+function returnTargetToComposer(input: RewindInput, itemId: string): boolean {
+  const target = input.state.items.find((item) => item.itemId === itemId)
+  if (!input.composerScopeKey || target?.body.kind !== 'message') {
+    return false
+  }
+  returnMessageToComposer(input.composerScopeKey, `rewound-${itemId}`, target.body.blocks)
+  return true
+}
+
 export function useNativeChatRewind(input: RewindInput) {
   const active = useRef(false)
   useLayoutEffect(() => {
@@ -95,132 +135,112 @@ export function useNativeChatRewind(input: RewindInput) {
   useLayoutEffect(() => {
     latest.current = input
   }, [input])
+  // Single-flight from the click on; only `sending` (after Confirm) blocks anything else.
   const inFlight = useRef(false)
-  const [pending, setPending] = useState(false)
-  const [settlement, setSettlement] = useState<{
-    sessionId: string
-    epoch: string
-    nextEpoch?: string
-  } | null>(null)
-  const [failure, setFailure] = useState<{
-    sessionId: string
-    epoch: string | null
-    message: string
-  } | null>(null)
-  const setError = (message: string | null) => {
-    const current = latest.current
-    setFailure(
-      message ? { sessionId: current.sessionId, epoch: current.state.epoch, message } : null
-    )
-  }
+  const [sending, setSending] = useState(false)
+  // A confirmed rewind whose new conversation has not arrived yet.
+  const [awaiting, setAwaiting] = useState<{ sessionId: string; epoch: string } | null>(null)
   const awaitingReset =
-    settlement?.sessionId === input.sessionId && settlement.epoch === input.state.epoch
-  const confirmedResetPending = awaitingReset && Boolean(settlement?.nextEpoch)
-  // The host also holds its recovery latch while our request is still in flight.
-  const error =
-    input.hostBlockedReason && !pending && !confirmedResetPending
-      ? nativeChatRewindReasonCopy(input.hostBlockedReason)
-      : failure?.sessionId === input.sessionId && failure.epoch === input.state.epoch
-        ? failure.message
-        : null
-  const disabledReason =
-    pending || awaitingReset
-      ? awaitingReset && !settlement?.nextEpoch
-        ? nativeChatRewindReasonCopy('outcome-unknown')
-        : translate(
-            'components.native-chat.rewind.pending',
-            'Rewind is in progress. Wait for the conversation to reload.'
-          )
-      : blockedReason(input)
+    awaiting?.sessionId === input.sessionId && awaiting.epoch === input.state.epoch
+  useEffect(() => {
+    if (!awaitingReset) {
+      return
+    }
+    const timer = setTimeout(() => {
+      setAwaiting(null)
+      toast.error(nativeChatRewindTimeoutCopy())
+    }, NATIVE_CHAT_REWIND_RESET_TIMEOUT_MS)
+    return () => clearTimeout(timer)
+  }, [awaitingReset])
+  const pending = sending || awaitingReset
+  const disabledReason = pending ? nativeChatRewindPendingCopy() : blockedReason(input)
   const blockedRef = useRef(false)
   useLayoutEffect(() => {
-    blockedRef.current = pending || awaitingReset || Boolean(input.hostBlockedReason)
-  }, [pending, awaitingReset, input.hostBlockedReason])
+    blockedRef.current = pending
+  }, [pending])
 
   const request = useCallback(async (itemId: string, confirm: ConfirmationDialogContextValue) => {
     const captured = latest.current
-    if (inFlight.current || blockedRef.current || blockedReason(captured)) {
+    if (
+      inFlight.current ||
+      blockedRef.current ||
+      blockedReason(captured) ||
+      !isRewindTarget(captured.state, itemId)
+    ) {
       return
     }
     const expectedEpoch = captured.state.epoch!
-    const count = countNativeChatRewindMessages(captured.state, itemId)
-    if (!count) {
-      return
-    }
     inFlight.current = true
-    blockedRef.current = true
-    setPending(true)
-    setError(null)
     let keepBlocked = false
     try {
       const confirmed = await confirm({
-        title: translate('components.native-chat.rewind.title', 'Revert to here?'),
+        title: translate('components.native-chat.rewind.title', 'Edit from here?'),
         description: translate(
           'components.native-chat.rewind.confirmation',
-          'Discard this message and every later message ({{count}} in total)? This cannot be undone. The message returns to the composer so you can edit and resend it. File changes on disk will be kept.',
-          { count }
+          'Discard this message and everything after it? The message returns to the composer so you can edit and resend it. File changes on disk are kept.'
         ),
-        confirmLabel: translate('components.native-chat.rewind.confirm', 'Discard messages'),
+        confirmLabel: translate('components.native-chat.rewind.confirm', 'Discard and edit'),
         cancelLabel: translate('components.native-chat.rewind.cancel', 'Cancel'),
         confirmVariant: 'destructive',
         cancelVariant: 'ghost'
       })
-      if (!confirmed) {
-        return
-      }
       const current = latest.current
-      if (!active.current || current.sessionId !== captured.sessionId) {
+      if (!confirmed || !active.current || current.sessionId !== captured.sessionId) {
         return
       }
       if (
         current.state.epoch !== expectedEpoch ||
         current.state.cursor?.sequence !== captured.state.cursor?.sequence
       ) {
-        setError(nativeChatRewindReasonCopy('stale-epoch'))
+        toast.error(nativeChatRewindReasonCopy('stale-epoch'))
         return
       }
       const blocked = blockedReason(current)
       if (blocked) {
-        setError(blocked)
+        toast.error(blocked)
         return
       }
+      blockedRef.current = true
+      setSending(true)
       const outcome = await current.send({ itemId, expectedEpoch })
       if (!active.current || latest.current.sessionId !== captured.sessionId) {
         return
       }
-      if (outcome.kind === 'done') {
-        const target = captured.state.items.find((item) => item.itemId === itemId)
-        if (captured.composerScopeKey && target?.body.kind === 'message') {
-          returnMessageToComposer(
-            captured.composerScopeKey,
-            `rewound-${itemId}`,
-            target.body.blocks
-          )
+      const reset = latest.current.state.epoch !== expectedEpoch
+      const giveBack = () => {
+        if (returnTargetToComposer(captured, itemId)) {
+          latest.current.onMessageReturned?.()
         }
-        keepBlocked = latest.current.state.epoch === expectedEpoch
-        setSettlement({
-          sessionId: captured.sessionId,
-          epoch: expectedEpoch,
-          nextEpoch: outcome.value.epoch
-        })
+      }
+      if (outcome.kind === 'done') {
+        giveBack()
+        keepBlocked = !reset
+        setAwaiting(reset ? null : { sessionId: captured.sessionId, epoch: expectedEpoch })
         return
       }
-      if (outcome.kind === 'dropped' || latest.current.state.epoch !== expectedEpoch) {
+      if (outcome.kind === 'dropped') {
         return
       }
       const reason = rewindFailureReason(outcome.failure)
-      setError(nativeChatRewindReasonCopy(reason))
+      // A rewind that may have run must never lose the message; a duplicate draft is harmless.
       if (reason === 'outcome-unknown') {
-        keepBlocked = true
-        setSettlement({ sessionId: captured.sessionId, epoch: expectedEpoch })
+        giveBack()
+      }
+      if (reset) {
+        return
       }
+      toast.error(
+        reason === 'outcome-unknown' && captured.composerScopeKey
+          ? nativeChatRewindReturnedUnknownCopy()
+          : nativeChatRewindReasonCopy(reason)
+      )
     } finally {
       inFlight.current = false
-      blockedRef.current = keepBlocked || Boolean(latest.current.hostBlockedReason)
-      setPending(false)
+      blockedRef.current = keepBlocked
+      setSending(false)
     }
   }, [])
-  /** Runs an action only while no rewind is pending or unresolved. */
+  /** Runs an action only while no confirmed rewind is in flight. */
   const unlessBlocked = useCallback(
     <A extends unknown[]>(run: (...input: A) => void) =>
       (...input: A): void => {
@@ -230,28 +250,42 @@ export function useNativeChatRewind(input: RewindInput) {
       },
     []
   )
-  return {
-    request,
-    unlessBlocked,
-    disabledReason,
-    pending: pending || awaitingReset || Boolean(input.hostBlockedReason),
-    blockedRef,
-    error
-  }
+  const offered = nativeChatRewindOffered(input.support)
+  // Rows re-render only when this changes; none get the action where the provider can never rewind.
+  const surface = useMemo<NativeChatRewindSurface | undefined>(
+    () => (offered ? { disabledReason, request } : undefined),
+    [offered, disabledReason, request]
+  )
+  return { request, unlessBlocked, surface, disabledReason, pending, blockedRef }
+}
+
+/** What the pane hosting a structured session tells its rewind. */
+export type NativeChatRewindHost = {
+  /** The host's in-doubt latch, from its status feed. */
+  hostBlockedReason?: AgentSessionRewindReason | null
+  onMessageReturned?: () => void
 }
 
 /** The rewind a structured session's user rows offer, sent through the session's own writes. */
 export function useStructuredAgentSessionRewind(
-  args: Omit<RewindInput, 'hostBlockedReason' | 'send'> & {
-    hostBlockedReason: AgentSessionRewindReason | null
-    write: StructuredAgentSessionWrite
-  }
+  args: Omit<RewindInput, 'hostBlockedReason' | 'onMessageReturned' | 'send'> &
+    NativeChatRewindHost & { write: StructuredAgentSessionWrite }
 ) {
-  const { blocked, composerScopeKey, hostBlockedReason, sessionId, state, support, write } = args
+  const {
+    blocked,
+    composerScopeKey,
+    hostBlockedReason,
+    onMessageReturned,
+    sessionId,
+    state,
+    support,
+    write
+  } = args
   const input = useMemo<RewindInput>(
     () => ({
       sessionId,
       composerScopeKey,
+      onMessageReturned,
       hostBlockedReason: hostBlockedReason ?? undefined,
       state,
       support,
@@ -259,7 +293,16 @@ export function useStructuredAgentSessionRewind(
       send: (fields) =>
         write<AgentSessionRewindResult>('agentSession.rewind', 'agentSession.rewind', fields)
     }),
-    [blocked, composerScopeKey, hostBlockedReason, sessionId, state, support, write]
+    [
+      blocked,
+      composerScopeKey,
+      hostBlockedReason,
+      onMessageReturned,
+      sessionId,
+      state,
+      support,
+      write
+    ]
   )
   return useNativeChatRewind(input)
 }
diff --git a/src/renderer/src/components/native-chat/use-structured-agent-session.rewind-outbox.test.tsx b/src/renderer/src/components/native-chat/use-structured-agent-session.rewind-outbox.test.tsx
index 1c2a1157d7b5..5ac9a1c695c5 100644
--- a/src/renderer/src/components/native-chat/use-structured-agent-session.rewind-outbox.test.tsx
+++ b/src/renderer/src/components/native-chat/use-structured-agent-session.rewind-outbox.test.tsx
@@ -9,7 +9,7 @@ import {
   writeOutbox
 } from './structured-agent-session-outbox-storage'
 
-const mocks = vi.hoisted(() => ({ call: vi.fn(), blocked: true }))
+const mocks = vi.hoisted(() => ({ call: vi.fn() }))
 const state = {
   ...EMPTY_STRUCTURED_AGENT_SESSION,
   epoch: 'epoch-1',
@@ -36,12 +36,11 @@ const args = {
   isVisible: true
 }
 
-describe('rewind recovery outbox suspension', () => {
+describe("the host's in-doubt rewind latch and the outbox", () => {
   beforeEach(() => {
     vi.useFakeTimers()
     vi.clearAllMocks()
     localStorage.clear()
-    mocks.blocked = true
     mocks.call.mockImplementation((_target, method) =>
       method === 'agentSession.send'
         ? new Promise(() => {})
@@ -50,37 +49,29 @@ describe('rewind recovery outbox suspension', () => {
   })
   afterEach(() => vi.useRealTimers())
 
+  // The host recovers an in-doubt rewind on the next send, so holding sends here would deadlock it.
   it.each(['queued', 'unconfirmed'] as const)(
-    'suspends a restored %s message, probes, and manual retry until the host clears recovery',
+    'keeps delivering a restored %s message and new sends while the latch is set',
     async (entryState) => {
       const entry = enqueueStructuredAgentSessionLaunchPrompt(args.sessionId, 'Pending prompt')!
       writeOutbox(args.sessionId, [{ ...entry, state: entryState }])
       const view = renderHook(() =>
-        useStructuredAgentSession({
-          ...args,
-          rewindBlockedReason: mocks.blocked ? 'outcome-unknown' : null
-        })
+        useStructuredAgentSession({ ...args, rewind: { hostBlockedReason: 'outcome-unknown' } })
       )
       await act(async () => {
-        view.result.current.retry(entry.clientMessageId)
+        if (entryState === 'unconfirmed') {
+          view.result.current.retry(entry.clientMessageId)
+        }
         await vi.advanceTimersByTimeAsync(60_000)
       })
-
-      expect(mocks.call.mock.calls.filter(([, method]) => method === 'agentSession.send')).toEqual(
-        []
-      )
-      expect(readOutbox(args.sessionId)[0]?.state).toBe(entryState)
-      expect(view.result.current.send('New prompt', [])).toBe(false)
-      expect(view.result.current.error).toContain('The rewind may have completed')
-
-      mocks.blocked = false
-      await act(async () => view.rerender())
-      if (entryState === 'unconfirmed') {
-        await act(async () => view.result.current.retry(entry.clientMessageId))
-      }
-      expect(
+      const sends = () =>
         mocks.call.mock.calls.filter(([, method]) => method === 'agentSession.send')
-      ).toHaveLength(1)
+      expect(sends()).toHaveLength(1)
+      expect(view.result.current.send('New prompt', [])).toBe(true)
+      expect(view.result.current.error).toBeNull()
+      expect(readOutbox(args.sessionId).map((queued) => queued.clientMessageId)).toContain(
+        entry.clientMessageId
+      )
       view.unmount()
     }
   )
diff --git a/src/renderer/src/components/native-chat/use-structured-agent-session.rewind.test.tsx b/src/renderer/src/components/native-chat/use-structured-agent-session.rewind.test.tsx
index 57e8e3cbb76b..07529de90cc5 100644
--- a/src/renderer/src/components/native-chat/use-structured-agent-session.rewind.test.tsx
+++ b/src/renderer/src/components/native-chat/use-structured-agent-session.rewind.test.tsx
@@ -6,7 +6,9 @@ import { beforeEach, describe, expect, it, vi } from 'vitest'
 const mocks = vi.hoisted(() => ({
   call: vi.fn(),
   operationId: vi.fn(),
-  toastError: vi.fn()
+  toastError: vi.fn(),
+  outboxSend: vi.fn(),
+  outboxRetry: vi.fn()
 }))
 
 vi.mock('sonner', () => ({ toast: { error: mocks.toastError, message: vi.fn() } }))
@@ -14,6 +16,7 @@ let fence = 3
 let epoch = 'epoch-1'
 let items: AgentJournalRenderItem[] = []
 let submissions: AgentJournalSubmission[] = []
+let queuedMessages: AgentSessionQueuedMessage[] | null = null
 
 vi.mock('@/runtime/structured-agent-session-client', () => ({
   callStructuredAgentSession: mocks.call,
@@ -32,6 +35,7 @@ vi.mock('./use-structured-agent-session-read', () => ({
       cursor: { epoch, sequence: 2 },
       items,
       submissions,
+      queuedMessages,
       status: 'ready',
       error: null,
       hasOlder: false
@@ -46,8 +50,8 @@ vi.mock('./use-structured-agent-session-outbox', () => ({
   useStructuredAgentSessionOutbox: () => ({
     outbox: [],
     error: null,
-    send: vi.fn(),
-    retry: vi.fn()
+    send: mocks.outboxSend,
+    retry: mocks.outboxRetry
   })
 }))
 
@@ -55,9 +59,14 @@ import type {
   AgentJournalRenderItem,
   AgentJournalSubmission
 } from '../../../../shared/agent-session-journal-types'
+import type { AgentSessionQueuedMessage } from '../../../../shared/agent-session-queued-message-wire'
 import { RuntimeRpcCallError } from '@/runtime/runtime-rpc-result'
 import { useStructuredAgentSession } from './use-structured-agent-session'
 import { readNativeChatDraftCache, writeNativeChatDraftCache } from './native-chat-draft-cache'
+import {
+  nativeChatRewindReasonCopy,
+  nativeChatRewindReturnedUnknownCopy
+} from './native-chat-rewind-copy'
 
 const LOCAL_TARGET = { kind: 'local' } as const
 
@@ -80,6 +89,7 @@ describe('useStructuredAgentSession rewind RPC', () => {
     fence = 3
     epoch = 'epoch-1'
     submissions = []
+    queuedMessages = null
     items = [
       {
         itemId: 'user-1',
@@ -99,7 +109,7 @@ describe('useStructuredAgentSession rewind RPC', () => {
     )
   })
 
-  it('sends the agreed verb and fingerprint to the execution host and blocks the composer until reset', async () => {
+  it('sends the agreed verb and fingerprint to the execution host and holds sends until reset', async () => {
     const target = { kind: 'environment' as const, environmentId: 'ssh-host' }
     const view = renderHook(() =>
       useStructuredAgentSession({ sessionId: 'session-1', target, agent: 'codex', isVisible: true })
@@ -155,7 +165,10 @@ describe('useStructuredAgentSession rewind RPC', () => {
     )
     await waitFor(() => expect(view.result.current.rewind.disabledReason).toBeNull())
     await act(() => view.result.current.rewind.request('user-1', async () => true))
-    expect(view.result.current.error).toContain('could not verify the conversation boundary')
+    expect(mocks.toastError).toHaveBeenCalledExactlyOnceWith(
+      nativeChatRewindReasonCopy('proof-mismatch')
+    )
+    expect(view.result.current.error).toBeNull()
   })
 
   it('explains an older host missing the RPC without claiming an uncertain rewind occurred', async () => {
@@ -181,9 +194,84 @@ describe('useStructuredAgentSession rewind RPC', () => {
     )
     await waitFor(() => expect(view.result.current.rewind.disabledReason).toBeNull())
     await act(() => view.result.current.rewind.request('user-1', async () => true))
-    expect(view.result.current.error).toContain('does not support rewinding')
+    expect(mocks.toastError).toHaveBeenCalledExactlyOnceWith(
+      nativeChatRewindReasonCopy('unsupported')
+    )
     expect(view.result.current.rewind.pending).toBe(false)
   })
+
+  it('an unknown outcome leaves sending open and returns the message to the composer', async () => {
+    // A remote host without the capability throws before anything is sent: the outcome reads unknown.
+    mocks.call.mockImplementation((_target, method) =>
+      method === 'agentSession.rewind'
+        ? Promise.reject(new Error('Rewinding requires a newer Orca server.'))
+        : Promise.resolve({ ...OPTIONS, rewind: { supported: true } })
+    )
+    const onMessageReturned = vi.fn()
+    const view = renderHook(() =>
+      useStructuredAgentSession({
+        sessionId: 'session-1',
+        target: LOCAL_TARGET,
+        agent: 'codex',
+        isVisible: true,
+        composerScopeKey: 'unknown-scope',
+        rewind: { onMessageReturned }
+      })
+    )
+    await waitFor(() => expect(view.result.current.rewind.disabledReason).toBeNull())
+    await act(() => view.result.current.rewind.request('user-1', async () => true))
+    expect(readNativeChatDraftCache('unknown-scope')).toContain('Prompt')
+    expect(onMessageReturned).toHaveBeenCalledOnce()
+    expect(mocks.toastError).toHaveBeenCalledExactlyOnceWith(nativeChatRewindReturnedUnknownCopy())
+    expect(view.result.current.error).toBeNull()
+    view.result.current.send('Prompt', [])
+    view.result.current.retry('message-1')
+    expect(mocks.outboxSend).toHaveBeenCalledOnce()
+    expect(mocks.outboxRetry).toHaveBeenCalledOnce()
+  })
+
+  it("lets the host's in-doubt latch disable only the action", async () => {
+    mocks.call.mockResolvedValue({ ...OPTIONS, rewind: { supported: true } })
+    const view = renderHook(() =>
+      useStructuredAgentSession({
+        sessionId: 'session-1',
+        target: LOCAL_TARGET,
+        agent: 'codex',
+        isVisible: true,
+        rewind: { hostBlockedReason: 'outcome-unknown' }
+      })
+    )
+    await waitFor(() => expect(view.result.current.rewind.surface).toBeDefined())
+    expect(view.result.current.rewind.surface?.disabledReason).toBe(
+      nativeChatRewindReasonCopy('outcome-unknown')
+    )
+    view.result.current.send('Next prompt', [])
+    expect(mocks.outboxSend).toHaveBeenCalledOnce()
+    expect(view.result.current.error).toBeNull()
+  })
+
+  it("holds the action behind the host's queued cards", async () => {
+    mocks.call.mockResolvedValue({ ...OPTIONS, rewind: { supported: true } })
+    queuedMessages = [
+      {
+        messageId: 'queued-1',
+        position: 0,
+        state: 'waiting',
+        paused: true,
+        body: { kind: 'message', role: 'user', blocks: [{ type: 'text', text: 'Held' }] }
+      }
+    ]
+    const view = renderHook(() =>
+      useStructuredAgentSession({
+        sessionId: 'session-1',
+        target: LOCAL_TARGET,
+        agent: 'codex',
+        isVisible: true
+      })
+    )
+    await waitFor(() => expect(view.result.current.rewind.surface).toBeDefined())
+    expect(view.result.current.rewind.disabledReason).toBe(nativeChatRewindReasonCopy('busy'))
+  })
 })
 
 describe('useStructuredAgentSession rewind support and composer return', () => {
@@ -192,6 +280,7 @@ describe('useStructuredAgentSession rewind support and composer return', () => {
     fence = 3
     epoch = 'epoch-1'
     submissions = []
+    queuedMessages = null
     items = [
       {
         itemId: 'user-1',
@@ -204,7 +293,7 @@ describe('useStructuredAgentSession rewind support and composer return', () => {
     mocks.operationId.mockReset().mockReturnValue('rewind-operation')
   })
 
-  it('treats a host whose options name no rewind as unsupported', async () => {
+  it('offers no action on a host whose options name no rewind', async () => {
     mocks.call.mockResolvedValue(OPTIONS)
     const view = renderHook(() =>
       useStructuredAgentSession({
@@ -215,8 +304,11 @@ describe('useStructuredAgentSession rewind support and composer return', () => {
       })
     )
     await waitFor(() =>
-      expect(view.result.current.rewind.disabledReason).toContain('does not support rewinding')
+      expect(view.result.current.rewind.disabledReason).toBe(
+        nativeChatRewindReasonCopy('unsupported')
+      )
     )
+    expect(view.result.current.rewind.surface).toBeUndefined()
   })
 
   it('returns the discarded message to the composer after the existing draft', async () => {
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 cec5fa3e26a9..1bd761b77cd8 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
@@ -42,7 +42,7 @@ import { pendingPromptsAllUnanswerableHere } from '../../../../shared/agent-sess
 import { withNativeChatCutTurnNotices } from '../../../../shared/native-chat-cut-turn-notice'
 import { TUI_AGENT_DISPLAY_NAMES } from '../../../../shared/tui-agent-display-names'
 import { useStructuredAgentSessionRewind } from './use-native-chat-rewind'
-import type { AgentSessionRewindReason } from '../../../../shared/agent-session-rewind'
+import type { NativeChatRewindHost } from './use-native-chat-rewind'
 
 export type { StructuredPromptItem } from './structured-agent-session-message-projection'
 
@@ -62,8 +62,8 @@ export function useStructuredAgentSession(args: {
   composerScopeKey?: string
   /** The chat-wide "queue follow-ups" setting; off keeps mid-turn sends immediate. */
   queueFollowUps?: boolean
-  /** The host's rewind recovery latch, from its status feed. */
-  rewindBlockedReason?: AgentSessionRewindReason | null
+  /** The host's rewind latch and what follows a message returned by a rewind. */
+  rewind?: NativeChatRewindHost
 }) {
   const {
     agent,
@@ -72,7 +72,6 @@ export function useStructuredAgentSession(args: {
     launch,
     providerStarting = false,
     queueFollowUps = true,
-    rewindBlockedReason = null,
     sessionId,
     target,
     transportEnabled = true
@@ -132,11 +131,11 @@ export function useStructuredAgentSession(args: {
     () => ({ capability: queueCapability, enabled: queueEnabled }),
     [queueCapability, queueEnabled]
   )
-  // A rewind the host could not confirm holds the outbox until the host recovers it.
   const outboxController = useStructuredAgentSessionOutbox({
     sessionId,
     target,
-    fence: rewindBlockedReason ? null : transportState.fence,
+    // Never held for an in-doubt rewind: the host recovers it on the next send.
+    fence: transportState.fence,
     submissions: transportState.submissions,
     journalItems: transportState.journalItems,
     composerScopeKey,
@@ -172,10 +171,11 @@ export function useStructuredAgentSession(args: {
   const rewind = useStructuredAgentSessionRewind({
     sessionId,
     composerScopeKey,
-    hostBlockedReason: rewindBlockedReason,
+    ...args.rewind,
     state,
     support: transportEnabled ? rewindSupport : undefined,
-    blocked: conversationBusy || commandPending.current,
+    // The host also refuses a rewind behind its queued cards, paused ones included.
+    blocked: conversationBusy || commandPending.current || queuedMessageIds.length > 0,
     write
   })
   // A host that takes a Stop naming no turn gets Stop from the send until the work settles; every
@@ -239,7 +239,7 @@ export function useStructuredAgentSession(args: {
     messages,
     status: transportEnabled ? state.status : 'ready',
     /** The outbox's own line; a failed read is worded from `readRefusal`, never its text. */
-    error: rewind.error ?? outboxController.error,
+    error: outboxController.error,
     /** The refusal the failed read met, while `status` is `error`. */
     readRefusal: transportEnabled ? state.readRefusal : undefined,
     hasOlder: transportEnabled && state.hasOlder,
diff --git a/src/renderer/src/i18n/locales/en.json b/src/renderer/src/i18n/locales/en.json
index 9bf65d885c5d..a034eed53f0a 100644
--- a/src/renderer/src/i18n/locales/en.json
+++ b/src/renderer/src/i18n/locales/en.json
@@ -18151,23 +18151,25 @@
         "pendingWork": "Wait for pending work and messages to finish before using this command."
       },
       "rewind": {
-        "unsupported": "This session does not support rewinding conversation history.",
-        "historyNotPaginated": "This older Codex conversation does not support rewinding. Start a new conversation to use rewind.",
-        "busy": "Wait for the current turn, pending messages, approvals, and background work to finish before rewinding.",
-        "staleEpoch": "The conversation changed. Review the latest messages before rewinding.",
-        "invalidTarget": "This message is no longer a valid rewind point. Review the latest conversation.",
-        "historyLimit": "This conversation is too large to rewind safely. Nothing was changed.",
-        "providerRefused": "The agent refused to rewind this conversation.",
-        "proofMismatch": "Orca could not verify the conversation boundary. Reload the session before trying again.",
-        "outcomeUnknown": "The rewind may have completed, but Orca could not confirm it. Sending is blocked until the outcome is resolved.",
-        "refused": "Orca could not rewind this conversation. Reload the session to check its current state.",
-        "unavailable": "Reconnect to a writable chat session before rewinding.",
-        "pending": "Rewind is in progress. Wait for the conversation to reload.",
-        "title": "Revert to here?",
-        "confirmation": "Discard this message and every later message ({{count}} in total)? This cannot be undone. The message returns to the composer so you can edit and resend it. File changes on disk will be kept.",
-        "confirm": "Discard messages",
+        "unsupported": "This chat can't go back to an earlier message.",
+        "historyNotPaginated": "This older Codex chat can't go back to an earlier message. Start a new chat to use Edit from here.",
+        "busy": "Wait for the current turn, queued messages, approvals, and background work to finish first.",
+        "staleEpoch": "The conversation changed. Review the latest messages and try again.",
+        "invalidTarget": "The conversation can't go back to this message. Nothing was changed.",
+        "historyLimit": "This conversation is too long to go back in. Nothing was changed.",
+        "providerRefused": "The agent couldn't go back to this message.",
+        "proofMismatch": "The agent's history didn't match this chat. Check the conversation before continuing.",
+        "outcomeUnknown": "Orca couldn't confirm whether the conversation went back to an earlier message. It checks before your next message is sent.",
+        "outcomeUnknownReturned": "Orca couldn't confirm whether the conversation went back to this message. Your message is back in the composer, and Orca checks the conversation before your next message is sent.",
+        "timeout": "Orca couldn't confirm in time that the conversation went back to this message. Check the conversation before continuing.",
+        "refused": "Orca couldn't go back to this message. Check the conversation before continuing.",
+        "unavailable": "Wait for the chat to finish connecting.",
+        "pending": "Wait for the conversation to go back to the earlier message.",
+        "title": "Edit from here?",
+        "confirmation": "Discard this message and everything after it? The message returns to the composer so you can edit and resend it. File changes on disk are kept.",
+        "confirm": "Discard and edit",
         "cancel": "Cancel",
-        "action": "Revert to here"
+        "action": "Edit from here"
       },
       "drop": {
         "title": "Drop to attach to this chat",
diff --git a/src/renderer/src/runtime/structured-agent-session-client.test.ts b/src/renderer/src/runtime/structured-agent-session-client.test.ts
index 19e89d83ecb7..2ecb463d1adf 100644
--- a/src/renderer/src/runtime/structured-agent-session-client.test.ts
+++ b/src/renderer/src/runtime/structured-agent-session-client.test.ts
@@ -101,7 +101,10 @@ describe('callStructuredAgentSession rewind capability', () => {
       'env-1',
       AGENT_SESSION_REWIND_RUNTIME_CAPABILITY
     )
-    expect(mocks.call).toHaveBeenCalledExactlyOnceWith(target, 'agentSession.rewind', params)
+    // As long as a command's: the host may start an agent at rest first.
+    expect(mocks.call).toHaveBeenCalledExactlyOnceWith(target, 'agentSession.rewind', params, {
+      timeoutMs: 195_000
+    })
   })
 
   it('does not dispatch rewind when host capability cannot be verified', async () => {
@@ -118,7 +121,9 @@ describe('callStructuredAgentSession rewind capability', () => {
     await callStructuredAgentSession(target, 'agentSession.send', params)
 
     expect(mocks.supportsCapability).not.toHaveBeenCalled()
-    expect(mocks.call).toHaveBeenCalledWith({ kind: 'local' }, 'agentSession.rewind', params)
+    expect(mocks.call).toHaveBeenCalledWith({ kind: 'local' }, 'agentSession.rewind', params, {
+      timeoutMs: 195_000
+    })
     expect(mocks.call).toHaveBeenCalledWith(target, 'agentSession.send', params)
   })
 })
diff --git a/src/renderer/src/runtime/structured-agent-session-client.ts b/src/renderer/src/runtime/structured-agent-session-client.ts
index d0e2aca691c7..42320bdb7849 100644
--- a/src/renderer/src/runtime/structured-agent-session-client.ts
+++ b/src/renderer/src/runtime/structured-agent-session-client.ts
@@ -87,6 +87,8 @@ export async function readStructuredAgentSessionConversationOutline(
 
 const STRUCTURED_AGENT_SESSION_METHOD_TIMEOUT_MS: ReadonlyMap<string, number> = new Map([
   ['agentSession.conversationCommand', 195_000],
+  // The host may start an agent at rest before rewinding it, as it does for a command.
+  ['agentSession.rewind', 195_000],
   // A waiting catalog read lasts as long as the host's listing: Claude's is 60 s, after up to 15 s
   // for an account switch to settle and 5 s of login-shell environment.
   ['agentSession.modelCatalog', 90_000]
diff --git a/src/shared/native-chat-types.ts b/src/shared/native-chat-types.ts
index f48a31f7f38b..8645daf71db8 100644
--- a/src/shared/native-chat-types.ts
+++ b/src/shared/native-chat-types.ts
@@ -222,6 +222,8 @@ export type NativeChatMessage = AgentJournalProducerLinkage & {
   parentId?: string
   /** How a user message was delivered when it was not an ordinary prompt. */
   sentAs?: AgentJournalMessageSendMode
+  /** On a conversation command the user sent, such as `/compact`: the command it names. */
+  command?: { name: string }
   /** Accepted but not yet handed to the agent: drawn after everything the agent has done. */
   queued?: true
   /** Shown as not sent: in no turn, so a newer turn's bar and clock never land on it. Drawn where
diff --git a/src/shared/structured-agent-session-projection.ts b/src/shared/structured-agent-session-projection.ts
index 0c2173c0a2dc..97920e8bce9c 100644
--- a/src/shared/structured-agent-session-projection.ts
+++ b/src/shared/structured-agent-session-projection.ts
@@ -163,6 +163,7 @@ export function projectStructuredItemToNativeChat(
   // Reducer updates replace journal items, so unchanged rows keep their render caches.
   const projected = itemBlocks(item)
   const sentAs = item.body.kind === 'message' ? item.body.sentAs : undefined
+  const command = item.body.kind === 'message' ? item.body.command : undefined
   const message: NativeChatMessage | null = projected
     ? {
         ...agentJournalItemRowOrigin(item),
@@ -170,7 +171,8 @@ export function projectStructuredItemToNativeChat(
         role: projected.role,
         blocks: projected.blocks,
         // A send mode this build cannot name renders as an ordinary message.
-        ...(sentAs !== undefined && isAgentJournalMessageSendMode(sentAs) ? { sentAs } : {})
+        ...(sentAs !== undefined && isAgentJournalMessageSendMode(sentAs) ? { sentAs } : {}),
+        ...(command ? { command } : {})
       }
     : null
   projectedItems.set(item, message)

From 7eda73ea28907454c1491ccee3618d36534502de Mon Sep 17 00:00:00 2001
From: Brennan Benson <79079362+brennanb2025@users.noreply.github.com>
Date: Mon, 5 Oct 2026 15:35:18 -0700
Subject: [PATCH 14/22] fix(native-chat): say why a send waits while a rewind
 is in flight

---
 .../native-chat/use-native-chat-rewind.ts           | 13 ++++++++++---
 .../use-structured-agent-session.rewind.test.tsx    |  6 +++++-
 .../native-chat/use-structured-agent-session.ts     |  2 +-
 3 files changed, 16 insertions(+), 5 deletions(-)

diff --git a/src/renderer/src/components/native-chat/use-native-chat-rewind.ts b/src/renderer/src/components/native-chat/use-native-chat-rewind.ts
index 55481b70181e..97e1c6990f25 100644
--- a/src/renderer/src/components/native-chat/use-native-chat-rewind.ts
+++ b/src/renderer/src/components/native-chat/use-native-chat-rewind.ts
@@ -240,15 +240,22 @@ export function useNativeChatRewind(input: RewindInput) {
       setSending(false)
     }
   }, [])
+  /** Whether a send may go now; one refused during a confirmed rewind says why. */
+  const admitsSend = useCallback((): boolean => {
+    if (blockedRef.current) {
+      toast.message(nativeChatRewindPendingCopy())
+    }
+    return !blockedRef.current
+  }, [])
   /** Runs an action only while no confirmed rewind is in flight. */
   const unlessBlocked = useCallback(
     <A extends unknown[]>(run: (...input: A) => void) =>
       (...input: A): void => {
-        if (!blockedRef.current) {
+        if (admitsSend()) {
           run(...input)
         }
       },
-    []
+    [admitsSend]
   )
   const offered = nativeChatRewindOffered(input.support)
   // Rows re-render only when this changes; none get the action where the provider can never rewind.
@@ -256,7 +263,7 @@ export function useNativeChatRewind(input: RewindInput) {
     () => (offered ? { disabledReason, request } : undefined),
     [offered, disabledReason, request]
   )
-  return { request, unlessBlocked, surface, disabledReason, pending, blockedRef }
+  return { request, admitsSend, unlessBlocked, surface, disabledReason, pending, blockedRef }
 }
 
 /** What the pane hosting a structured session tells its rewind. */
diff --git a/src/renderer/src/components/native-chat/use-structured-agent-session.rewind.test.tsx b/src/renderer/src/components/native-chat/use-structured-agent-session.rewind.test.tsx
index 07529de90cc5..31ad4a887c1e 100644
--- a/src/renderer/src/components/native-chat/use-structured-agent-session.rewind.test.tsx
+++ b/src/renderer/src/components/native-chat/use-structured-agent-session.rewind.test.tsx
@@ -7,11 +7,12 @@ const mocks = vi.hoisted(() => ({
   call: vi.fn(),
   operationId: vi.fn(),
   toastError: vi.fn(),
+  toastMessage: vi.fn(),
   outboxSend: vi.fn(),
   outboxRetry: vi.fn()
 }))
 
-vi.mock('sonner', () => ({ toast: { error: mocks.toastError, message: vi.fn() } }))
+vi.mock('sonner', () => ({ toast: { error: mocks.toastError, message: mocks.toastMessage } }))
 let fence = 3
 let epoch = 'epoch-1'
 let items: AgentJournalRenderItem[] = []
@@ -133,6 +134,9 @@ describe('useStructuredAgentSession rewind RPC', () => {
       expectedEpoch: 'epoch-1'
     })
     expect(view.result.current.send('stale composer text', [])).toBe(false)
+    expect(mocks.toastMessage).toHaveBeenCalledWith(
+      'Wait for the conversation to go back to the earlier message.'
+    )
     epoch = 'epoch-2'
     items = []
     view.rerender()
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 1bd761b77cd8..bfdea39cf8f1 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
@@ -258,7 +258,7 @@ export function useStructuredAgentSession(args: {
     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.blockedRef.current &&
+      rewind.admitsSend() &&
       outboxController.send(...input),
     retry: rewind.unlessBlocked(outboxController.retry),
     isWorking: transportState.isWorking,

From a393fea9962fd215744bba39cf632ba2e47c42ea Mon Sep 17 00:00:00 2001
From: Brennan Benson <79079362+brennanb2025@users.noreply.github.com>
Date: Mon, 5 Oct 2026 16:11:33 -0700
Subject: [PATCH 15/22] fix(native-chat): settle an in-doubt rewind on the next
 send, even with the agent running

- Host: a send (or /clear, /compact) that finds a rewind in doubt with the agent already running
  now runs the same provider recovery an attach would. Proven: the conversation is replaced and
  the send proceeds; proven not done: the record is refused and the send proceeds; still unknown:
  the send is refused as before, but before the ledger records it, so a Retry of the same id is
  decided afresh instead of replaying the refusal for a day.
- Client: a confirmed rewind whose pane was hidden during the wait lets go silently (a hidden pane
  reads nothing); the timeout and busy copy say what happened and what is needed.
---
 ...red-agent-session-rewind-live-send.test.ts | 238 ++++++++++++++++++
 .../structured-agent-session-rewind.test.ts   |   4 +-
 ...ructured-agent-session-send-preparation.ts |  74 +++++-
 .../NativeChatStructuredSession.tsx           |   6 +-
 .../native-chat/native-chat-rewind-copy.ts    |   4 +-
 .../use-native-chat-rewind.test.tsx           |  24 ++
 .../native-chat/use-native-chat-rewind.ts     |  21 +-
 src/renderer/src/i18n/locales/en.json         |   4 +-
 8 files changed, 356 insertions(+), 19 deletions(-)
 create mode 100644 src/main/native-chat/agent-session-wire/structured-agent-session-rewind-live-send.test.ts

diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-rewind-live-send.test.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-rewind-live-send.test.ts
new file mode 100644
index 000000000000..ce7eef0120c0
--- /dev/null
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-rewind-live-send.test.ts
@@ -0,0 +1,238 @@
+import {
+  AGENT_JOURNAL_THREAD_SCOPE,
+  type AgentJournalRenderItem
+} from '../../../shared/agent-session-journal-types'
+// A Codex rewind left in doubt while its agent keeps running: no attach comes to settle it, so the
+// next send asks the provider as an attach would, and a send refused meanwhile never poisons its id.
+
+import { mkdtemp, rm } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import { agentJournalItemKey } from '../../../shared/agent-session-journal-item-key'
+import { computeAgentSessionPayloadFingerprint } from '../../../shared/agent-session-mutation-envelope'
+import type { AgentSessionRecordStore } from '../../runtime/agent-session-record-store'
+import { openTestAgentSessionRecordStore } from '../../runtime/agent-session-record-store-test-harness'
+import type {
+  AgentSessionDispatchOutcome,
+  StructuredAgentSessionAdapter
+} from './structured-agent-session-adapter'
+import { StructuredAgentSessionHost } from './structured-agent-session-host'
+import type { StructuredAgentSessionEventSink } from './structured-agent-session-event-sink'
+import {
+  HOST_TEST_NOW,
+  HOST_TEST_SESSION as SESSION,
+  HOST_TEST_THREAD as THREAD,
+  hostTestAttachParams,
+  hostTestMessage,
+  hostTestOperationId,
+  resetHostTestOperationIds
+} from './structured-agent-session-host-test-data'
+import { openTestJournalHostDatabase } from '../agent-session-journal/journal-host-database-test-support'
+import { createStructuredAgentSessionLogger } from './structured-agent-session-logger'
+
+const caller = { callerKey: 'desktop' }
+const KEPT = { provider: 'codex' as const, threadId: THREAD, turnId: 'kept', ordinal: 0 }
+
+let directory: string
+let store: AgentSessionRecordStore
+let host: StructuredAgentSessionHost
+let sink: StructuredAgentSessionEventSink
+let acquires = 0
+const rewind = vi.fn<NonNullable<StructuredAgentSessionAdapter['rewind']>>()
+const recoverRewind = vi.fn<NonNullable<StructuredAgentSessionAdapter['recoverRewind']>>()
+const rewindSupport = vi.fn<NonNullable<StructuredAgentSessionAdapter['rewindSupport']>>()
+const dispatch = vi.fn<StructuredAgentSessionAdapter['dispatch']>()
+
+function adapter(): StructuredAgentSessionAdapter {
+  return {
+    supportsCreate: (_location, agent) => agent === 'codex',
+    supportsLocation: () => true,
+    acquire: async (input) => {
+      acquires += 1
+      sink = input.events!
+      return {
+        process: {
+          hostId: 'local',
+          pid: 4000 + acquires,
+          processStartTimeMs: HOST_TEST_NOW,
+          spawnToken: input.spawnToken
+        },
+        acquisitionGeneration: `generation-${acquires}`,
+        link: {
+          linkId: `link-${acquires}`,
+          mintedAtFence: input.fence,
+          observedAt: HOST_TEST_NOW,
+          origin: acquires === 1 ? 'created' : 'resumed',
+          handle: { provider: 'codex', threadId: THREAD }
+        }
+      }
+    },
+    dispatch,
+    cancelTurn: async () => ({ cancelled: false }),
+    answerPrompt: async () => {},
+    setOption: async () => {},
+    rewindSupport,
+    rewind,
+    recoverRewind,
+    releaseAcquisition: async () => true,
+    closeSession: async () => true
+  }
+}
+
+function openHost(): StructuredAgentSessionHost {
+  return new StructuredAgentSessionHost({
+    logger: createStructuredAgentSessionLogger(),
+    store,
+    adapter: adapter(),
+    journalDatabase: openTestJournalHostDatabase(directory),
+    claimKeyId: 'key',
+    now: () => HOST_TEST_NOW,
+    probeOwner: async () => ({ outcome: 'exit-observed' }),
+    idleSweep: { intervalMs: 3_600_000 }
+  })
+}
+
+beforeEach(async () => {
+  resetHostTestOperationIds()
+  acquires = 0
+  rewind.mockReset()
+  recoverRewind.mockReset().mockResolvedValue({
+    ok: true,
+    items: [{ identity: KEPT, body: hostTestMessage('verified history') }]
+  })
+  rewindSupport.mockReset().mockReturnValue({ supported: true })
+  dispatch.mockReset().mockImplementation(async (input): Promise<AgentSessionDispatchOutcome> => ({
+    state: 'accepted',
+    providerIdentity: {
+      provider: 'codex',
+      threadId: THREAD,
+      turnId: input.clientMessageId,
+      ordinal: 1
+    }
+  }))
+  directory = await mkdtemp(join(tmpdir(), 'orca-rewind-live-'))
+  store = await openTestAgentSessionRecordStore(directory)
+  host = openHost()
+})
+
+afterEach(async () => {
+  await host.flushAllStreamedEvents()
+  await rm(directory, { recursive: true, force: true })
+})
+
+function fence(): number {
+  return store.getRecord(SESSION)!.lease.runtimeFence
+}
+
+function rewindParams(itemId: string, expectedEpoch: string) {
+  return {
+    itemId,
+    expectedEpoch,
+    envelope: {
+      sessionId: SESSION,
+      clientOperationId: hostTestOperationId(),
+      expectedRuntimeFence: fence(),
+      payloadFingerprint: computeAgentSessionPayloadFingerprint({
+        method: 'agentSession.rewind',
+        sessionId: SESSION,
+        fields: { itemId, expectedEpoch }
+      })
+    }
+  }
+}
+
+function sendParams(text: string, clientOperationId = hostTestOperationId()) {
+  const body = hostTestMessage(text)
+  return {
+    body,
+    envelope: {
+      sessionId: SESSION,
+      clientOperationId,
+      expectedRuntimeFence: fence(),
+      payloadFingerprint: computeAgentSessionPayloadFingerprint({
+        method: 'agentSession.send',
+        sessionId: SESSION,
+        fields: { body }
+      })
+    }
+  }
+}
+
+/** A rewind whose provider call threw while the agent stays running. */
+async function rewindInDoubtWithLiveChild(): Promise<void> {
+  expect(await host.attach(caller, hostTestAttachParams(null))).toMatchObject({ ok: true })
+  const drop = { ...KEPT, turnId: 'drop' }
+  sink.appendItem(KEPT, hostTestMessage('verified history'), {
+    turnScope: AGENT_JOURNAL_THREAD_SCOPE
+  })
+  sink.appendItem(drop, hostTestMessage('to be rewound'), { turnScope: AGENT_JOURNAL_THREAD_SCOPE })
+  await host.flushStreamedEvents(SESSION)
+  rewind.mockRejectedValue(new Error('provider reply lost'))
+  const epoch = (await host.journalSnapshot(SESSION)).cursor.epoch
+  await expect(host.rewind(caller, rewindParams(agentJournalItemKey(drop), epoch))).rejects.toThrow(
+    'provider reply lost'
+  )
+  expect(store.getRecord(SESSION)?.rewind).toMatchObject({ phase: 'prepared' })
+  expect(host.hasSession(SESSION)).toBe(true)
+}
+
+function sentTexts(items: readonly AgentJournalRenderItem[]): string[] {
+  return items.flatMap((item) =>
+    item.body.kind === 'message'
+      ? item.body.blocks.flatMap((block) => (block.type === 'text' ? [block.text] : []))
+      : []
+  )
+}
+
+describe('a rewind in doubt while its agent keeps running', () => {
+  it('is settled by the next send, which is then delivered', async () => {
+    await rewindInDoubtWithLiveChild()
+    const before = acquires
+
+    expect(await host.send(caller, sendParams('after the rewind'))).toMatchObject({ ok: true })
+    expect(acquires).toBe(before)
+    expect(recoverRewind).toHaveBeenCalledOnce()
+    expect(store.getRecord(SESSION)?.rewind?.phase).toBe('completed')
+    await vi.waitFor(() => expect(dispatch).toHaveBeenCalledOnce())
+    expect(sentTexts((await host.journalSnapshot(SESSION)).items)).toEqual([
+      'verified history',
+      'after the rewind'
+    ])
+  })
+
+  it('lets the send through when the provider proves the rewind never happened', async () => {
+    await rewindInDoubtWithLiveChild()
+    recoverRewind.mockResolvedValueOnce({ ok: false, reason: 'provider-refused' })
+
+    expect(await host.send(caller, sendParams('after the refused rewind'))).toMatchObject({
+      ok: true
+    })
+    expect(store.getRecord(SESSION)?.rewind?.phase).toBe('refused')
+    await vi.waitFor(() => expect(dispatch).toHaveBeenCalledOnce())
+  })
+
+  it('refuses the send while recovery stays unknown, and decides its Retry afresh once settled', async () => {
+    await rewindInDoubtWithLiveChild()
+    recoverRewind.mockResolvedValueOnce({ ok: false, reason: 'outcome-unknown' })
+    const id = hostTestOperationId()
+
+    expect(await host.send(caller, sendParams('typed during the doubt', id))).toMatchObject({
+      ok: false,
+      refusal: {
+        code: 'agent_session_operation_unknown',
+        details: { reason: 'rewindUnconfirmed', rewindReason: 'outcome-unknown' }
+      }
+    })
+    expect(store.getRecord(SESSION)?.rewind?.phase).toBe('prepared')
+    expect(dispatch).not.toHaveBeenCalled()
+
+    // The Retry keeps the id; the provider now answers, so the same id is sent.
+    expect(await host.send(caller, sendParams('typed during the doubt', id))).toMatchObject({
+      ok: true,
+      replayed: false
+    })
+    expect(store.getRecord(SESSION)?.rewind?.phase).toBe('completed')
+    await vi.waitFor(() => expect(dispatch).toHaveBeenCalledOnce())
+  })
+})
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-rewind.test.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-rewind.test.ts
index 5a359deebad3..0c44a5deb2a9 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-rewind.test.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-rewind.test.ts
@@ -311,7 +311,7 @@ describe('host rewind', () => {
     })
     expect(rewind).not.toHaveBeenCalled()
   })
-  it('keeps a failed hydration epoch intact and blocks sends and duplicate rewind', async () => {
+  it('keeps a failed hydration epoch intact and blocks sends and duplicate rewind while it stays unknown', async () => {
     const target = await seed()
     const request = await params(target)
     const before = await host.journalSnapshot(HOST_TEST_SESSION)
@@ -322,6 +322,8 @@ describe('host rewind', () => {
       ok: false,
       refusal: { code: 'agent_session_operation_unknown' }
     })
+    // The send asks the provider first; it still cannot say.
+    recoverRewind.mockResolvedValueOnce({ ok: false, reason: 'outcome-unknown' })
     const body = hostTestMessage('new prompt')
     const envelope = {
       ...(await params(target)).envelope,
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-send-preparation.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-send-preparation.ts
index 62ac5fc644ee..b122012c02b7 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-send-preparation.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-send-preparation.ts
@@ -24,16 +24,22 @@ import {
 } from './structured-agent-session-mutation-admission'
 import { agentSessionOperationOutcomeUnknown } from './structured-agent-session-replay-outcome'
 import { rewindRefusal } from './structured-rewind-refusal'
+import { recoverStructuredRewind } from './structured-rewind-recovery'
+import { structuredAgentSessionConversationFence } from './structured-agent-session-provider-child'
 import { conversationCommandInFlight } from './structured-conversation-command-admission'
 import type { StructuredAgentSessionMutationContext } from './structured-agent-session-host-mutations'
 import type { StructuredAgentSessionLogger } from './structured-agent-session-logger'
 
+function rewindInDoubt(record: AgentSessionRecord | null | undefined): boolean {
+  const phase = record?.rewind?.phase
+  return phase === 'prepared' || phase === 'provider-succeeded'
+}
+
 /** Why the record refuses any send right now, whoever owns it; null when a send may run. */
 export function structuredAgentSessionSendBlock(
   record: AgentSessionRecord | null
 ): { ok: false; refusal: AgentSessionWireRefusal } | null {
-  const rewind = record?.rewind
-  if (rewind?.phase === 'prepared' || rewind?.phase === 'provider-succeeded') {
+  if (rewindInDoubt(record)) {
     return rewindRefusal('outcome-unknown')
   }
   const command = record?.conversationCommand
@@ -134,13 +140,48 @@ export function openWithAgent(
   }
 }
 
+/** The recovery an attach runs, for a child already running: no attach comes for it. A recovery
+ *  that stays unknown leaves the record as it was. */
+async function recoverRewindOnLiveChild(
+  context: Pick<StructuredAgentSessionMutationContext, 'deps' | 'sessions' | 'publish' | 'now'>,
+  sessionId: string
+): Promise<void> {
+  const journal = context.sessions.get(sessionId)?.journal
+  if (!journal) {
+    return
+  }
+  try {
+    await recoverStructuredRewind(
+      context.deps,
+      sessionId,
+      journal,
+      structuredAgentSessionConversationFence(context.deps.store, sessionId),
+      context.deps.adapter,
+      context.now
+    )
+  } catch (error) {
+    context.deps.logger.warn('settling a rewind in doubt before a send failed', {
+      scope: 'rewind-recovery',
+      sessionId,
+      error
+    })
+    return
+  }
+  context.publish(sessionId, journal)
+}
+
 /** A rewind still in doubt once the conversation is open is one only its provider can settle —
- *  the open settles every other — so a send starts the agent, whose attach recovers it. A resend
- *  of a recorded id needs only the conversation, its answer's source: it starts nothing, and an
- *  open that fails leaves that answer unknown, never refused. `clearInFlight`: a /clear was running
- *  when this send arrived, which refuses only its first run. */
+ *  the open settles every other — so a send settles it first: an agent at rest is started, whose
+ *  attach recovers it, and a running one is asked as that attach would. One still in doubt refuses
+ *  the send here, before the ledger records it, so a Retry of the same id is decided afresh. A
+ *  resend of a recorded id needs only the conversation, its answer's source: it starts nothing,
+ *  and an open that fails leaves that answer unknown, never refused. `clearInFlight`: a /clear was
+ *  running when this send arrived, which refuses only its first run. */
 export function sendPreparation(
-  context: Pick<StructuredAgentSessionMutationContext, 'openConversation' | 'ensureAgent' | 'deps'>,
+  context: Pick<
+    StructuredAgentSessionMutationContext,
+    'openConversation' | 'ensureAgent' | 'deps' | 'sessions' | 'publish' | 'now'
+  >,
   envelope: AgentSessionMutationEnvelope,
   arrival: { clearInFlight?: boolean } = {}
 ): (ledger: 'admit' | 'replay') => Promise<AgentSessionMutationSessionPreparation> {
@@ -158,10 +199,21 @@ export function sendPreparation(
         ? opened
         : { ok: false, refusal: agentSessionOperationOutcomeUnknown(envelope.clientOperationId) }
     }
-    const phase = context.deps.store.getRecord(envelope.sessionId)?.rewind?.phase
-    return opened.ok && (phase === 'prepared' || phase === 'provider-succeeded')
-      ? context.ensureAgent(envelope.sessionId)
-      : opened
+    const { sessionId } = envelope
+    if (!opened.ok || !rewindInDoubt(context.deps.store.getRecord(sessionId))) {
+      return opened
+    }
+    const running = Boolean(context.sessions.get(sessionId)?.child)
+    const ensured = await context.ensureAgent(sessionId)
+    if (!ensured.ok) {
+      return ensured
+    }
+    if (running) {
+      await recoverRewindOnLiveChild(context, sessionId)
+    }
+    return rewindInDoubt(context.deps.store.getRecord(sessionId))
+      ? rewindRefusal('outcome-unknown')
+      : ensured
   }
 }
 
diff --git a/src/renderer/src/components/native-chat/NativeChatStructuredSession.tsx b/src/renderer/src/components/native-chat/NativeChatStructuredSession.tsx
index 663b32c4ae3f..378a78830589 100644
--- a/src/renderer/src/components/native-chat/NativeChatStructuredSession.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatStructuredSession.tsx
@@ -65,7 +65,11 @@ export function NativeChatStructuredSession(
     composerScopeKey: paneKey,
     queueFollowUps,
     providerStarting: startupPhase === 'starting',
-    rewind: { hostBlockedReason: rewindBlockedReason, onMessageReturned: focusComposer },
+    rewind: {
+      hostBlockedReason: rewindBlockedReason,
+      onMessageReturned: focusComposer,
+      isVisible: props.isVisible
+    },
     transportEnabled: provisionalLaunch.transportEnabled,
     ...(provisionalLaunch.launch ? { launch: provisionalLaunch.launch } : {})
   })
diff --git a/src/renderer/src/components/native-chat/native-chat-rewind-copy.ts b/src/renderer/src/components/native-chat/native-chat-rewind-copy.ts
index 3e34332e1623..a4ebf9a7b747 100644
--- a/src/renderer/src/components/native-chat/native-chat-rewind-copy.ts
+++ b/src/renderer/src/components/native-chat/native-chat-rewind-copy.ts
@@ -18,7 +18,7 @@ const reasonCopy = {
   busy: () =>
     translate(
       'components.native-chat.rewind.busy',
-      'Wait for the current turn, queued messages, approvals, and background work to finish first.'
+      'Available once the agent is idle and nothing in this chat is waiting on you.'
     ),
   'stale-epoch': () =>
     translate(
@@ -80,7 +80,7 @@ export function nativeChatRewindReturnedUnknownCopy(): string {
 export function nativeChatRewindTimeoutCopy(): string {
   return translate(
     'components.native-chat.rewind.timeout',
-    "Orca couldn't confirm in time that the conversation went back to this message. Check the conversation before continuing."
+    "The chat didn't update after going back to this message. Reopen it to see the latest."
   )
 }
 
diff --git a/src/renderer/src/components/native-chat/use-native-chat-rewind.test.tsx b/src/renderer/src/components/native-chat/use-native-chat-rewind.test.tsx
index b0c08beeb8e5..92fb90b244c5 100644
--- a/src/renderer/src/components/native-chat/use-native-chat-rewind.test.tsx
+++ b/src/renderer/src/components/native-chat/use-native-chat-rewind.test.tsx
@@ -313,6 +313,30 @@ describe('structured chat rewind', () => {
     }
   })
 
+  it.each(['hidden throughout', 'hidden part way'] as const)(
+    'lets go silently when the pane was %s, since a hidden pane reads nothing',
+    async (mode) => {
+      vi.useFakeTimers()
+      try {
+        const props: Input = { ...input(), isVisible: mode !== 'hidden throughout' }
+        const view = render(props)
+        await act(() => view.result.current.request('user', async () => true))
+        expect(view.result.current.blockedRef.current).toBe(true)
+        if (mode === 'hidden part way') {
+          await act(() => vi.advanceTimersByTimeAsync(1_000))
+          view.rerender({ ...props, isVisible: false })
+          view.rerender({ ...props, isVisible: true })
+        }
+        await act(() => vi.advanceTimersByTimeAsync(NATIVE_CHAT_REWIND_RESET_TIMEOUT_MS))
+        expect(view.result.current.pending).toBe(false)
+        expect(view.result.current.blockedRef.current).toBe(false)
+        expect(toastError).not.toHaveBeenCalled()
+      } finally {
+        vi.useRealTimers()
+      }
+    }
+  )
+
   it.each([...AGENT_SESSION_REWIND_REASONS.filter((r) => r !== 'outcome-unknown'), 'future'])(
     'toasts refusal %s once, unblocks, and keeps the message where it is',
     async (rewindReason) => {
diff --git a/src/renderer/src/components/native-chat/use-native-chat-rewind.ts b/src/renderer/src/components/native-chat/use-native-chat-rewind.ts
index 97e1c6990f25..885b276b53a5 100644
--- a/src/renderer/src/components/native-chat/use-native-chat-rewind.ts
+++ b/src/renderer/src/components/native-chat/use-native-chat-rewind.ts
@@ -37,6 +37,8 @@ type RewindInput = {
   composerScopeKey?: string
   /** Called once the discarded message is back in the composer. */
   onMessageReturned?: () => void
+  /** Whether the pane is shown, and so reading; absent means shown. */
+  isVisible?: boolean
   state: StructuredAgentSessionState
   /** Undefined until the host has answered for the current runtime. */
   support: AgentSessionRewindSupport | undefined
@@ -142,13 +144,24 @@ export function useNativeChatRewind(input: RewindInput) {
   const [awaiting, setAwaiting] = useState<{ sessionId: string; epoch: string } | null>(null)
   const awaitingReset =
     awaiting?.sessionId === input.sessionId && awaiting.epoch === input.state.epoch
+  // A hidden pane stops reading, so its new conversation cannot arrive; that is no failure to report.
+  const hiddenWhileAwaiting = useRef(false)
+  const visible = input.isVisible !== false
+  useLayoutEffect(() => {
+    if (!visible) {
+      hiddenWhileAwaiting.current = true
+    }
+  }, [visible])
   useEffect(() => {
     if (!awaitingReset) {
       return
     }
+    hiddenWhileAwaiting.current = latest.current.isVisible === false
     const timer = setTimeout(() => {
       setAwaiting(null)
-      toast.error(nativeChatRewindTimeoutCopy())
+      if (!hiddenWhileAwaiting.current) {
+        toast.error(nativeChatRewindTimeoutCopy())
+      }
     }, NATIVE_CHAT_REWIND_RESET_TIMEOUT_MS)
     return () => clearTimeout(timer)
   }, [awaitingReset])
@@ -271,17 +284,19 @@ export type NativeChatRewindHost = {
   /** The host's in-doubt latch, from its status feed. */
   hostBlockedReason?: AgentSessionRewindReason | null
   onMessageReturned?: () => void
+  isVisible?: boolean
 }
 
 /** The rewind a structured session's user rows offer, sent through the session's own writes. */
 export function useStructuredAgentSessionRewind(
-  args: Omit<RewindInput, 'hostBlockedReason' | 'onMessageReturned' | 'send'> &
+  args: Omit<RewindInput, keyof NativeChatRewindHost | 'send'> &
     NativeChatRewindHost & { write: StructuredAgentSessionWrite }
 ) {
   const {
     blocked,
     composerScopeKey,
     hostBlockedReason,
+    isVisible,
     onMessageReturned,
     sessionId,
     state,
@@ -293,6 +308,7 @@ export function useStructuredAgentSessionRewind(
       sessionId,
       composerScopeKey,
       onMessageReturned,
+      isVisible,
       hostBlockedReason: hostBlockedReason ?? undefined,
       state,
       support,
@@ -304,6 +320,7 @@ export function useStructuredAgentSessionRewind(
       blocked,
       composerScopeKey,
       hostBlockedReason,
+      isVisible,
       onMessageReturned,
       sessionId,
       state,
diff --git a/src/renderer/src/i18n/locales/en.json b/src/renderer/src/i18n/locales/en.json
index a034eed53f0a..e501fe35f900 100644
--- a/src/renderer/src/i18n/locales/en.json
+++ b/src/renderer/src/i18n/locales/en.json
@@ -18153,7 +18153,7 @@
       "rewind": {
         "unsupported": "This chat can't go back to an earlier message.",
         "historyNotPaginated": "This older Codex chat can't go back to an earlier message. Start a new chat to use Edit from here.",
-        "busy": "Wait for the current turn, queued messages, approvals, and background work to finish first.",
+        "busy": "Available once the agent is idle and nothing in this chat is waiting on you.",
         "staleEpoch": "The conversation changed. Review the latest messages and try again.",
         "invalidTarget": "The conversation can't go back to this message. Nothing was changed.",
         "historyLimit": "This conversation is too long to go back in. Nothing was changed.",
@@ -18161,7 +18161,7 @@
         "proofMismatch": "The agent's history didn't match this chat. Check the conversation before continuing.",
         "outcomeUnknown": "Orca couldn't confirm whether the conversation went back to an earlier message. It checks before your next message is sent.",
         "outcomeUnknownReturned": "Orca couldn't confirm whether the conversation went back to this message. Your message is back in the composer, and Orca checks the conversation before your next message is sent.",
-        "timeout": "Orca couldn't confirm in time that the conversation went back to this message. Check the conversation before continuing.",
+        "timeout": "The chat didn't update after going back to this message. Reopen it to see the latest.",
         "refused": "Orca couldn't go back to this message. Check the conversation before continuing.",
         "unavailable": "Wait for the chat to finish connecting.",
         "pending": "Wait for the conversation to go back to the earlier message.",

From c77299b85029777996c9098e6d426eb7fde221b9 Mon Sep 17 00:00:00 2001
From: Brennan Benson <79079362+brennanb2025@users.noreply.github.com>
Date: Mon, 5 Oct 2026 16:52:37 -0700
Subject: [PATCH 16/22] fix(native-chat): keep /clear's settled refusal while a
 rewind is in doubt; type the live-send test fixture

---
 ...red-agent-session-rewind-live-send.test.ts | 25 ++++++++++++++++++-
 ...ructured-agent-session-send-preparation.ts |  8 +++---
 .../structured-conversation-command.ts        |  2 +-
 3 files changed, 30 insertions(+), 5 deletions(-)

diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-rewind-live-send.test.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-rewind-live-send.test.ts
index ce7eef0120c0..2a34e0f16a74 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-rewind-live-send.test.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-rewind-live-send.test.ts
@@ -10,6 +10,7 @@ import { tmpdir } from 'node:os'
 import { join } from 'node:path'
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 import { agentJournalItemKey } from '../../../shared/agent-session-journal-item-key'
+import { codexProviderHandle } from '../../../shared/agent-session-provider-handle-encoding'
 import { computeAgentSessionPayloadFingerprint } from '../../../shared/agent-session-mutation-envelope'
 import type { AgentSessionRecordStore } from '../../runtime/agent-session-record-store'
 import { openTestAgentSessionRecordStore } from '../../runtime/agent-session-record-store-test-harness'
@@ -64,7 +65,7 @@ function adapter(): StructuredAgentSessionAdapter {
           mintedAtFence: input.fence,
           observedAt: HOST_TEST_NOW,
           origin: acquires === 1 ? 'created' : 'resumed',
-          handle: { provider: 'codex', threadId: THREAD }
+          handle: codexProviderHandle(THREAD)
         }
       }
     },
@@ -235,4 +236,26 @@ describe('a rewind in doubt while its agent keeps running', () => {
     expect(store.getRecord(SESSION)?.rewind?.phase).toBe('completed')
     await vi.waitFor(() => expect(dispatch).toHaveBeenCalledOnce())
   })
+
+  it('leaves /clear its own settled refusal: nothing ran, and it mints a fresh id per attempt', async () => {
+    await rewindInDoubtWithLiveChild()
+    recoverRewind.mockResolvedValue({ ok: false, reason: 'outcome-unknown' })
+    const result = await host.conversationCommand(caller, {
+      command: 'clear',
+      envelope: {
+        sessionId: SESSION,
+        clientOperationId: hostTestOperationId(),
+        expectedRuntimeFence: fence(),
+        payloadFingerprint: computeAgentSessionPayloadFingerprint({
+          method: 'agentSession.conversationCommand',
+          sessionId: SESSION,
+          fields: { command: 'clear' }
+        })
+      }
+    })
+    expect(result).toMatchObject({
+      ok: false,
+      refusal: { code: 'agent_session_operation_invalid' }
+    })
+  })
 })
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-send-preparation.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-send-preparation.ts
index b122012c02b7..0b0712ee6b96 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-send-preparation.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-send-preparation.ts
@@ -176,14 +176,16 @@ async function recoverRewindOnLiveChild(
  *  the send here, before the ledger records it, so a Retry of the same id is decided afresh. A
  *  resend of a recorded id needs only the conversation, its answer's source: it starts nothing,
  *  and an open that fails leaves that answer unknown, never refused. `clearInFlight`: a /clear was
- *  running when this send arrived, which refuses only its first run. */
+ *  running when this send arrived, which refuses only its first run. `refusesInRun`: the caller's
+ *  own run refuses a rewind in doubt with a settled answer and mints a fresh id per attempt (/clear),
+ *  so preparation leaves that refusal to it. */
 export function sendPreparation(
   context: Pick<
     StructuredAgentSessionMutationContext,
     'openConversation' | 'ensureAgent' | 'deps' | 'sessions' | 'publish' | 'now'
   >,
   envelope: AgentSessionMutationEnvelope,
-  arrival: { clearInFlight?: boolean } = {}
+  arrival: { clearInFlight?: boolean; refusesInRun?: boolean } = {}
 ): (ledger: 'admit' | 'replay') => Promise<AgentSessionMutationSessionPreparation> {
   return async (ledger) => {
     if (ledger === 'admit' && arrival.clearInFlight) {
@@ -211,7 +213,7 @@ export function sendPreparation(
     if (running) {
       await recoverRewindOnLiveChild(context, sessionId)
     }
-    return rewindInDoubt(context.deps.store.getRecord(sessionId))
+    return !arrival.refusesInRun && rewindInDoubt(context.deps.store.getRecord(sessionId))
       ? rewindRefusal('outcome-unknown')
       : ensured
   }
diff --git a/src/main/native-chat/agent-session-wire/structured-conversation-command.ts b/src/main/native-chat/agent-session-wire/structured-conversation-command.ts
index 73093da47447..e6f22ae54e3a 100644
--- a/src/main/native-chat/agent-session-wire/structured-conversation-command.ts
+++ b/src/main/native-chat/agent-session-wire/structured-conversation-command.ts
@@ -109,7 +109,7 @@ export function runStructuredConversationCommand(
       callerKey: caller.callerKey,
       envelope,
       // Starts the agent only to settle a rewind in doubt, as a send does; a /clear itself starts nothing.
-      prepareSession: sendPreparation(context, envelope),
+      prepareSession: sendPreparation(context, envelope, { refusesInRun: true }),
       journal: () => context.sessions.get(sessionId)?.journal,
       publish: (journal) => context.publish(sessionId, journal),
       now: context.now,

From 1e60d945f5969c972223b7a2a10dc932dd07b9a1 Mon Sep 17 00:00:00 2001
From: Brennan Benson <79079362+brennanb2025@users.noreply.github.com>
Date: Mon, 5 Oct 2026 22:11:56 -0700
Subject: [PATCH 17/22] test(native-chat): give the live-send rewind host the
 declared agents main now requires

---
 .../structured-agent-session-rewind-live-send.test.ts           | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-rewind-live-send.test.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-rewind-live-send.test.ts
index 2a34e0f16a74..85247148f863 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-rewind-live-send.test.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-rewind-live-send.test.ts
@@ -11,6 +11,7 @@ import { join } from 'node:path'
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 import { agentJournalItemKey } from '../../../shared/agent-session-journal-item-key'
 import { codexProviderHandle } from '../../../shared/agent-session-provider-handle-encoding'
+import { claudeAndCodexDeclared } from './structured-agent-session-adapter-router-test-support'
 import { computeAgentSessionPayloadFingerprint } from '../../../shared/agent-session-mutation-envelope'
 import type { AgentSessionRecordStore } from '../../runtime/agent-session-record-store'
 import { openTestAgentSessionRecordStore } from '../../runtime/agent-session-record-store-test-harness'
@@ -86,6 +87,7 @@ function openHost(): StructuredAgentSessionHost {
     logger: createStructuredAgentSessionLogger(),
     store,
     adapter: adapter(),
+    agents: claudeAndCodexDeclared(),
     journalDatabase: openTestJournalHostDatabase(directory),
     claimKeyId: 'key',
     now: () => HOST_TEST_NOW,

From f75f9368e23ceb09e8d1079faef71d08c8450fb6 Mon Sep 17 00:00:00 2001
From: Brennan Benson <79079362+brennanb2025@users.noreply.github.com>
Date: Mon, 5 Oct 2026 23:57:16 -0700
Subject: [PATCH 18/22] fix(native-chat): offer Edit from here only where the
 next send settles a rewind, and never on URL images

- New runtime capability agent-session.rewind-send-recovery.v1, advertised by this host: the
  rewind UI hands an in-doubt prompt back for the next send to settle, which hosts with only the
  rewind RPC refuse while the agent runs. The action is hidden until the host (local or remote)
  advertises it, and while that is unknown.
- A prompt with an image that has no local file is not offered: the image could not go back to
  the composer after the rewind discards it.
- Row and provider eligibility move to native-chat-rewind-eligibility.ts.
---
 .../NativeChatRewindAction.target.test.tsx    |  8 +-
 .../native-chat/NativeChatTranscriptRow.tsx   |  3 +-
 .../native-chat-rewind-eligibility.ts         | 30 ++++++++
 .../use-native-chat-rewind.test.tsx           | 23 ++++--
 .../native-chat/use-native-chat-rewind.ts     | 38 +++-------
 ...e-structured-agent-session.rewind.test.tsx | 73 ++++++++++++++++++-
 .../use-structured-agent-session.ts           |  1 +
 ...red-agent-session-host-capability.test.tsx | 37 +++++++++-
 ...tructured-agent-session-host-capability.ts | 12 +++
 src/shared/protocol-version.ts                |  5 ++
 10 files changed, 192 insertions(+), 38 deletions(-)
 create mode 100644 src/renderer/src/components/native-chat/native-chat-rewind-eligibility.ts

diff --git a/src/renderer/src/components/native-chat/NativeChatRewindAction.target.test.tsx b/src/renderer/src/components/native-chat/NativeChatRewindAction.target.test.tsx
index 8f0a266df0e9..9174aa67c26e 100644
--- a/src/renderer/src/components/native-chat/NativeChatRewindAction.target.test.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatRewindAction.target.test.tsx
@@ -38,11 +38,14 @@ vi.mock('./use-structured-agent-session-read', () => ({
 }))
 
 import { useStructuredAgentSession } from './use-structured-agent-session'
+import { setLocalRuntimeCapabilitiesForTests } from '@/runtime/local-runtime-capabilities'
+import { AGENT_SESSION_REWIND_SEND_RECOVERY_RUNTIME_CAPABILITY } from '../../../../shared/protocol-version'
 
 const target = { kind: 'local' } as const
 
 describe('rewind target after send acceptance', () => {
   beforeEach(() => {
+    setLocalRuntimeCapabilitiesForTests([AGENT_SESSION_REWIND_SEND_RECOVERY_RUNTIME_CAPABILITY])
     vi.clearAllMocks()
     localStorage.clear()
     state = {
@@ -63,7 +66,10 @@ describe('rewind target after send acceptance', () => {
       )
     })
   })
-  afterEach(cleanup)
+  afterEach(() => {
+    cleanup()
+    setLocalRuntimeCapabilitiesForTests(null)
+  })
 
   it.each([
     ['codex', 'orca'],
diff --git a/src/renderer/src/components/native-chat/NativeChatTranscriptRow.tsx b/src/renderer/src/components/native-chat/NativeChatTranscriptRow.tsx
index fa57ed66db9d..6e70635ed421 100644
--- a/src/renderer/src/components/native-chat/NativeChatTranscriptRow.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatTranscriptRow.tsx
@@ -12,7 +12,8 @@ import type { NativeChatSubagentDisclosure } from './native-chat-subagent-sectio
 import type { NativeChatTaskListPredecessors } from './native-chat-task-list-history'
 import type { NativeChatTranscriptSlot } from './native-chat-transcript-slots'
 import type { NativeChatDiffReveal, NativeChatDiffTarget } from './native-chat-turn-diffs'
-import { nativeChatRowOffersRewind, type NativeChatRewindSurface } from './use-native-chat-rewind'
+import type { NativeChatRewindSurface } from './use-native-chat-rewind'
+import { nativeChatRowOffersRewind } from './native-chat-rewind-eligibility'
 
 /** Everything a row needs that is the same for every row. Held as one memoized
  *  object so a row's props change only when that row's own slot does. */
diff --git a/src/renderer/src/components/native-chat/native-chat-rewind-eligibility.ts b/src/renderer/src/components/native-chat/native-chat-rewind-eligibility.ts
new file mode 100644
index 000000000000..3f7492b74234
--- /dev/null
+++ b/src/renderer/src/components/native-chat/native-chat-rewind-eligibility.ts
@@ -0,0 +1,30 @@
+// Where "Edit from here" is offered: which providers can rewind, and which transcript rows.
+
+import type { AgentSessionRewindSupport } from '../../../../shared/agent-session-rewind'
+import type { NativeChatMessage } from '../../../../shared/native-chat-types'
+
+/** Whether the provider can rewind at all. An in-doubt read is still capable: the status feed's
+ *  live latch, not this cached read, says when it resolves. */
+export function nativeChatRewindOffered(support: AgentSessionRewindSupport | undefined): boolean {
+  return support !== undefined && (support.supported || support.reason === 'outcome-unknown')
+}
+
+/** A sent prompt that opened its own turn, outside any subagent's section. Codex rewinds whole
+ *  turns, so a steer would also discard its turn's opener; unsent, queued, command and goal rows
+ *  have no turn to go back to. An image with no local file could not go back to the composer. */
+export function nativeChatRowOffersRewind(
+  message: NativeChatMessage,
+  slot: { depth: number; turnKey: string | undefined },
+  hasDeliveryNotice: boolean
+): boolean {
+  return (
+    message.role === 'user' &&
+    slot.depth === 0 &&
+    slot.turnKey === message.id &&
+    !hasDeliveryNotice &&
+    message.queued !== true &&
+    message.command === undefined &&
+    message.sentAs === undefined &&
+    message.blocks.every((block) => block.type !== 'image-ref' || Boolean(block.path))
+  )
+}
diff --git a/src/renderer/src/components/native-chat/use-native-chat-rewind.test.tsx b/src/renderer/src/components/native-chat/use-native-chat-rewind.test.tsx
index 92fb90b244c5..cfd40b444b63 100644
--- a/src/renderer/src/components/native-chat/use-native-chat-rewind.test.tsx
+++ b/src/renderer/src/components/native-chat/use-native-chat-rewind.test.tsx
@@ -9,11 +9,8 @@ import { AGENT_SESSION_REWIND_REASONS } from '../../../../shared/agent-session-r
 import { EMPTY_STRUCTURED_AGENT_SESSION } from '../../../../shared/structured-agent-session-reducer'
 import type { AgentJournalRenderItem } from '../../../../shared/agent-session-journal-types'
 import type { NativeChatMessage } from '../../../../shared/native-chat-types'
-import {
-  NATIVE_CHAT_REWIND_RESET_TIMEOUT_MS,
-  nativeChatRowOffersRewind,
-  useNativeChatRewind
-} from './use-native-chat-rewind'
+import { NATIVE_CHAT_REWIND_RESET_TIMEOUT_MS, useNativeChatRewind } from './use-native-chat-rewind'
+import { nativeChatRowOffersRewind } from './native-chat-rewind-eligibility'
 import {
   nativeChatRewindPendingCopy,
   nativeChatRewindReasonCopy,
@@ -433,6 +430,16 @@ describe('which rows offer rewind', () => {
     expect(nativeChatRowOffersRewind(message(), opens, false)).toBe(true)
   })
 
+  it('offers a prompt whose image is a local file, which can go back to the composer', () => {
+    const withFile = message({
+      blocks: [
+        { type: 'text', text: 'Look' },
+        { type: 'image-ref', path: '/tmp/shot.png' }
+      ]
+    })
+    expect(nativeChatRowOffersRewind(withFile, opens, false)).toBe(true)
+  })
+
   it.each([
     ['a steer into a running turn', message(), { depth: 0, turnKey: 'earlier-opener' }, false],
     ['an unsent row', message({ unsent: true }), { depth: 0, turnKey: undefined }, false],
@@ -440,6 +447,12 @@ describe('which rows offer rewind', () => {
     ['a queued row', message({ queued: true }), opens, false],
     ['a /compact row', message({ command: { name: 'compact' } }), opens, false],
     ['a goal', message({ sentAs: 'goal' }), opens, false],
+    [
+      'a prompt with a URL image, which could not go back to the composer',
+      message({ blocks: [{ type: 'image-ref', url: 'https://example.com/shot.png' }] }),
+      opens,
+      false
+    ],
     ['a subagent prompt', message(), { depth: 1, turnKey: 'opener' }, false],
     ['an assistant row', message({ role: 'assistant' }), opens, false]
   ] as const)('never offers %s', (_label, row, slot, notice) => {
diff --git a/src/renderer/src/components/native-chat/use-native-chat-rewind.ts b/src/renderer/src/components/native-chat/use-native-chat-rewind.ts
index 885b276b53a5..3dcebcc501bd 100644
--- a/src/renderer/src/components/native-chat/use-native-chat-rewind.ts
+++ b/src/renderer/src/components/native-chat/use-native-chat-rewind.ts
@@ -9,7 +9,6 @@ import type {
 } from '../../../../shared/agent-session-rewind'
 import type { AgentSessionWriteFailure } from '../../../../shared/agent-session-write-failure'
 import type { StructuredAgentSessionState } from '../../../../shared/structured-agent-session-reducer'
-import type { NativeChatMessage } from '../../../../shared/native-chat-types'
 import {
   nativeChatRewindPendingCopy,
   nativeChatRewindReasonCopy,
@@ -22,6 +21,9 @@ import type {
   StructuredAgentSessionWriteOutcome
 } from './use-structured-agent-session-mutate'
 import { returnMessageToComposer } from './structured-agent-session-withdrawn-message-restore'
+import { nativeChatRewindOffered } from './native-chat-rewind-eligibility'
+import type { RuntimeClientTarget } from '@/runtime/runtime-client-target'
+import { useStructuredAgentSessionHostRecoversRewindOnSend } from '@/runtime/structured-agent-session-host-capability'
 
 export type NativeChatRewindSurface = {
   disabledReason: string | null
@@ -70,31 +72,6 @@ function rewindFailureReason(failure: AgentSessionWriteFailure): string | undefi
     : undefined
 }
 
-/** Whether the provider can rewind at all. An in-doubt read is still capable: the status feed's
- *  live latch, not this cached read, says when it resolves. */
-export function nativeChatRewindOffered(support: AgentSessionRewindSupport | undefined): boolean {
-  return support !== undefined && (support.supported || support.reason === 'outcome-unknown')
-}
-
-/** A sent prompt that opened its own turn, outside any subagent's section. Codex rewinds whole
- *  turns, so a steer would also discard its turn's opener; unsent, queued, command and goal rows
- *  have no turn to go back to. */
-export function nativeChatRowOffersRewind(
-  message: NativeChatMessage,
-  slot: { depth: number; turnKey: string | undefined },
-  hasDeliveryNotice: boolean
-): boolean {
-  return (
-    message.role === 'user' &&
-    slot.depth === 0 &&
-    slot.turnKey === message.id &&
-    !hasDeliveryNotice &&
-    message.queued !== true &&
-    message.command === undefined &&
-    message.sentAs === undefined
-  )
-}
-
 function isRewindTarget(state: StructuredAgentSessionState, itemId: string): boolean {
   return state.items.some(
     (item) => item.itemId === itemId && item.body.kind === 'message' && item.body.role === 'user'
@@ -290,7 +267,7 @@ export type NativeChatRewindHost = {
 /** The rewind a structured session's user rows offer, sent through the session's own writes. */
 export function useStructuredAgentSessionRewind(
   args: Omit<RewindInput, keyof NativeChatRewindHost | 'send'> &
-    NativeChatRewindHost & { write: StructuredAgentSessionWrite }
+    NativeChatRewindHost & { target: RuntimeClientTarget; write: StructuredAgentSessionWrite }
 ) {
   const {
     blocked,
@@ -300,9 +277,14 @@ export function useStructuredAgentSessionRewind(
     onMessageReturned,
     sessionId,
     state,
-    support,
+    target,
     write
   } = args
+  // An in-doubt rewind returns the prompt for the next send to settle; only a host that settles it
+  // on a send may offer one. Unknown hides it, as unresolved support does.
+  const support = useStructuredAgentSessionHostRecoversRewindOnSend(target)
+    ? args.support
+    : undefined
   const input = useMemo<RewindInput>(
     () => ({
       sessionId,
diff --git a/src/renderer/src/components/native-chat/use-structured-agent-session.rewind.test.tsx b/src/renderer/src/components/native-chat/use-structured-agent-session.rewind.test.tsx
index 31ad4a887c1e..b3d9eb523483 100644
--- a/src/renderer/src/components/native-chat/use-structured-agent-session.rewind.test.tsx
+++ b/src/renderer/src/components/native-chat/use-structured-agent-session.rewind.test.tsx
@@ -1,7 +1,9 @@
 // @vitest-environment happy-dom
 
 import { act, renderHook, waitFor } from '@testing-library/react'
-import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import type * as RuntimeRpcClient from '@/runtime/runtime-rpc-client'
+import { AGENT_SESSION_REWIND_SEND_RECOVERY_RUNTIME_CAPABILITY as RECOVERY } from '../../../../shared/protocol-version'
 
 const mocks = vi.hoisted(() => ({
   call: vi.fn(),
@@ -9,7 +11,14 @@ const mocks = vi.hoisted(() => ({
   toastError: vi.fn(),
   toastMessage: vi.fn(),
   outboxSend: vi.fn(),
-  outboxRetry: vi.fn()
+  outboxRetry: vi.fn(),
+  remoteCapabilities: new Set<string>()
+}))
+
+vi.mock('@/runtime/runtime-rpc-client', async (importOriginal) => ({
+  ...(await importOriginal<typeof RuntimeRpcClient>()),
+  runtimeEnvironmentSupportsCapability: async (_environmentId: string, capability: string) =>
+    mocks.remoteCapabilities.has(capability)
 }))
 
 vi.mock('sonner', () => ({ toast: { error: mocks.toastError, message: mocks.toastMessage } }))
@@ -64,6 +73,7 @@ import type { AgentSessionQueuedMessage } from '../../../../shared/agent-session
 import { RuntimeRpcCallError } from '@/runtime/runtime-rpc-result'
 import { useStructuredAgentSession } from './use-structured-agent-session'
 import { readNativeChatDraftCache, writeNativeChatDraftCache } from './native-chat-draft-cache'
+import { setLocalRuntimeCapabilitiesForTests } from '@/runtime/local-runtime-capabilities'
 import {
   nativeChatRewindReasonCopy,
   nativeChatRewindReturnedUnknownCopy
@@ -71,6 +81,13 @@ import {
 
 const LOCAL_TARGET = { kind: 'local' } as const
 
+// This build's host settles an in-doubt rewind on the next send; an older one is tested below.
+beforeEach(() => {
+  setLocalRuntimeCapabilitiesForTests([RECOVERY])
+  mocks.remoteCapabilities = new Set([RECOVERY])
+})
+afterEach(() => setLocalRuntimeCapabilitiesForTests(null))
+
 const OPTIONS = {
   models: [
     {
@@ -339,3 +356,55 @@ describe('useStructuredAgentSession rewind support and composer return', () => {
     expect(readNativeChatDraftCache('rewind-scope')).toContain('Fix the bug')
   })
 })
+
+describe('offering rewind only where the next send settles an in-doubt one', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    fence = 3
+    epoch = 'epoch-1'
+    submissions = []
+    queuedMessages = null
+    items = [
+      {
+        itemId: 'user-1',
+        sequence: 1,
+        revision: 1,
+        observedAt: 1,
+        body: { kind: 'message', role: 'user', blocks: [{ type: 'text', text: 'Prompt' }] }
+      }
+    ]
+    mocks.call.mockResolvedValue({ ...OPTIONS, rewind: { supported: true } })
+  })
+
+  const remote = { kind: 'environment' as const, environmentId: 'ssh-host' }
+  const render = (target: typeof remote | typeof LOCAL_TARGET) =>
+    renderHook(() =>
+      useStructuredAgentSession({ sessionId: 'session-1', target, agent: 'codex', isVisible: true })
+    )
+
+  it('offers it on a remote host that advertises the recovery', async () => {
+    const view = render(remote)
+    await waitFor(() => expect(view.result.current.rewind.surface).toBeDefined())
+  })
+
+  it('offers none on a remote host that rewinds but predates the recovery', async () => {
+    mocks.remoteCapabilities = new Set()
+    const view = render(remote)
+    await waitFor(() =>
+      expect(mocks.call).toHaveBeenCalledWith(remote, 'agentSession.options', expect.anything())
+    )
+    await act(async () => {})
+    expect(view.result.current.rewind.surface).toBeUndefined()
+  })
+
+  it('offers it locally once the runtime answers, and none while it has not', async () => {
+    expect(render(LOCAL_TARGET).result.current.rewind.surface).toBeUndefined()
+    const view = render(LOCAL_TARGET)
+    await waitFor(() => expect(view.result.current.rewind.surface).toBeDefined())
+    setLocalRuntimeCapabilitiesForTests(null)
+    const unanswered = render(LOCAL_TARGET)
+    await waitFor(() => expect(mocks.call).toHaveBeenCalled())
+    await act(async () => {})
+    expect(unanswered.result.current.rewind.surface).toBeUndefined()
+  })
+})
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 13cf424039c2..3768a56a5b84 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
@@ -169,6 +169,7 @@ export function useStructuredAgentSession(args: {
   )
   const rewind = useStructuredAgentSessionRewind({
     sessionId,
+    target,
     composerScopeKey,
     ...args.rewind,
     state,
diff --git a/src/renderer/src/runtime/structured-agent-session-host-capability.test.tsx b/src/renderer/src/runtime/structured-agent-session-host-capability.test.tsx
index 22ceb0b49793..c141f6fea75c 100644
--- a/src/renderer/src/runtime/structured-agent-session-host-capability.test.tsx
+++ b/src/renderer/src/runtime/structured-agent-session-host-capability.test.tsx
@@ -5,7 +5,9 @@ import { afterEach, describe, expect, it, vi } from 'vitest'
 import {
   AGENT_SESSION_ACCEPTED_SEND_RUNTIME_CAPABILITY,
   AGENT_SESSION_CONVERSATION_STOP_RUNTIME_CAPABILITY,
-  AGENT_SESSION_QUEUED_MESSAGES_RUNTIME_CAPABILITY
+  AGENT_SESSION_QUEUED_MESSAGES_RUNTIME_CAPABILITY,
+  AGENT_SESSION_REWIND_RUNTIME_CAPABILITY,
+  AGENT_SESSION_REWIND_SEND_RECOVERY_RUNTIME_CAPABILITY
 } from '../../../shared/protocol-version'
 
 const mocks = vi.hoisted(() => ({
@@ -27,6 +29,7 @@ vi.mock('./runtime-host-contact-regained', () => ({
 import { setLocalRuntimeCapabilitiesForTests } from './local-runtime-capabilities'
 import {
   useStructuredAgentSessionHostQueuesMessagesState,
+  useStructuredAgentSessionHostRecoversRewindOnSend,
   useStructuredAgentSessionHostStopsConversation
 } from './structured-agent-session-host-capability'
 
@@ -97,3 +100,35 @@ describe('the queued-messages capability, three-state', () => {
     expect(result.current).toBe('unknown')
   })
 })
+
+describe('whether a host settles an in-doubt rewind on the next send', () => {
+  it('reads the local runtime, which only rewinding is not enough for', () => {
+    setLocalRuntimeCapabilitiesForTests([AGENT_SESSION_REWIND_RUNTIME_CAPABILITY])
+    expect(
+      renderHook(() => useStructuredAgentSessionHostRecoversRewindOnSend({ kind: 'local' })).result
+        .current
+    ).toBe(false)
+    setLocalRuntimeCapabilitiesForTests([AGENT_SESSION_REWIND_SEND_RECOVERY_RUNTIME_CAPABILITY])
+    expect(
+      renderHook(() => useStructuredAgentSessionHostRecoversRewindOnSend({ kind: 'local' })).result
+        .current
+    ).toBe(true)
+  })
+
+  it.each([true, false])('asks a remote host, which answers %s', async (supported) => {
+    mocks.supports.mockResolvedValueOnce(supported)
+    const { result } = renderHook(() =>
+      useStructuredAgentSessionHostRecoversRewindOnSend({
+        kind: 'environment',
+        environmentId: 'env-1'
+      })
+    )
+    await waitFor(() =>
+      expect(mocks.supports).toHaveBeenCalledWith(
+        'env-1',
+        AGENT_SESSION_REWIND_SEND_RECOVERY_RUNTIME_CAPABILITY
+      )
+    )
+    await waitFor(() => expect(result.current).toBe(supported))
+  })
+})
diff --git a/src/renderer/src/runtime/structured-agent-session-host-capability.ts b/src/renderer/src/runtime/structured-agent-session-host-capability.ts
index 2b1a76d2c5b4..04b437fd5d3c 100644
--- a/src/renderer/src/runtime/structured-agent-session-host-capability.ts
+++ b/src/renderer/src/runtime/structured-agent-session-host-capability.ts
@@ -2,6 +2,7 @@ import { useEffect, useState } from 'react'
 import {
   AGENT_SESSION_CONVERSATION_STOP_RUNTIME_CAPABILITY,
   AGENT_SESSION_QUEUED_MESSAGES_RUNTIME_CAPABILITY,
+  AGENT_SESSION_REWIND_SEND_RECOVERY_RUNTIME_CAPABILITY,
   type RuntimeCapability
 } from '../../../shared/protocol-version'
 import type { RuntimeClientTarget } from './runtime-client-target'
@@ -93,6 +94,17 @@ export function useStructuredAgentSessionHostStopsConversation(
   )
 }
 
+/** Whether the host settles a rewind left in doubt on the next send, agent running or not: only
+ *  then may a client offer a rewind, which hands an in-doubt prompt back for that send. */
+export function useStructuredAgentSessionHostRecoversRewindOnSend(
+  target: RuntimeClientTarget
+): boolean {
+  return useStructuredAgentSessionHostCapability(
+    target,
+    AGENT_SESSION_REWIND_SEND_RECOVERY_RUNTIME_CAPABILITY
+  )
+}
+
 /** Whether the host holds mid-turn sends as drafts: only then may a client send `delivery`
  *  or call the queuedMessage RPCs. */
 export function useStructuredAgentSessionHostQueuesMessages(target: RuntimeClientTarget): boolean {
diff --git a/src/shared/protocol-version.ts b/src/shared/protocol-version.ts
index 4715f220a46b..d8508c45eb5d 100644
--- a/src/shared/protocol-version.ts
+++ b/src/shared/protocol-version.ts
@@ -260,6 +260,10 @@ export const AGENT_SESSION_CONVERSATION_OUTLINE_RUNTIME_CAPABILITY =
   'agent-session.conversation-outline.v1' as const
 // The RPC is registered unconditionally; per-session rewind support is a separate check.
 export const AGENT_SESSION_REWIND_RUNTIME_CAPABILITY = 'agent-session.rewind.v1' as const
+// Why: the rewind UI returns an in-doubt prompt and relies on the next send to settle the rewind,
+// even with the agent running; hosts with only the rewind RPC refuse that send until a restart.
+export const AGENT_SESSION_REWIND_SEND_RECOVERY_RUNTIME_CAPABILITY =
+  'agent-session.rewind-send-recovery.v1' as const
 // Readers must understand a monitoring roster with no available stop control.
 // Why: a `turn` journal item replaced the status row that used to carry a turn's lifecycle. A
 // client that predates it would render the unknown kind as text, so the host publishes the legacy
@@ -403,6 +407,7 @@ export const RUNTIME_CAPABILITIES = [
   AGENT_SESSION_STATUS_FEED_RUNTIME_CAPABILITY,
   AGENT_SESSION_TURN_COMPLETION_RUNTIME_CAPABILITY,
   AGENT_SESSION_REWIND_RUNTIME_CAPABILITY,
+  AGENT_SESSION_REWIND_SEND_RECOVERY_RUNTIME_CAPABILITY,
   AGENT_SESSION_CONVERSATION_OUTLINE_RUNTIME_CAPABILITY,
   AGENT_SESSION_BACKGROUND_TASK_STOP_CAPABILITY,
   AGENT_SESSION_QUESTION_ANSWERS_RUNTIME_CAPABILITY,

From 6e8894a0cc3ec276ad0b1b78376bfa5596fefe58 Mon Sep 17 00:00:00 2001
From: Brennan Benson <79079362+brennanb2025@users.noreply.github.com>
Date: Tue, 6 Oct 2026 00:02:22 -0700
Subject: [PATCH 19/22] fix(native-chat): keep when each kept message was first
 seen across a rewind

A rewind rebuilt the provider's kept items with the rewind's own time, so every kept message
showed the rewind time. The merge already carried a held row's scope and producer onto the
provider item; it now carries its first-seen time too, for the rewind and its recovery alike.
---
 .../structured-agent-session-rewind.test.ts    | 18 +++++++++++++++++-
 ...tructured-rewind-retained-host-rows.test.ts |  3 ++-
 .../structured-rewind-retained-host-rows.ts    |  8 +++++---
 3 files changed, 24 insertions(+), 5 deletions(-)

diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-rewind.test.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-rewind.test.ts
index 14a96a86b24a..1d2cfeba5898 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-rewind.test.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-rewind.test.ts
@@ -37,6 +37,7 @@ import { codexProviderHandle } from '../../../shared/agent-session-provider-hand
 import { claudeAndCodexDeclared } from './structured-agent-session-adapter-router-test-support'
 
 const caller = { callerKey: 'desktop' }
+let clock = HOST_TEST_NOW
 let directory: string
 let store: AgentSessionRecordStore
 let host: StructuredAgentSessionHost
@@ -47,6 +48,7 @@ const rewind = vi.fn<NonNullable<StructuredAgentSessionAdapter['rewind']>>()
 const recoverRewind = vi.fn<NonNullable<StructuredAgentSessionAdapter['recoverRewind']>>()
 
 beforeEach(async () => {
+  clock = HOST_TEST_NOW
   resetHostTestOperationIds()
   rewind.mockReset().mockResolvedValue({ ok: true })
   recoverRewind.mockReset().mockResolvedValue({
@@ -104,7 +106,7 @@ beforeEach(async () => {
     adapter,
     journalDatabase: openTestJournalHostDatabase(directory),
     claimKeyId: 'key',
-    now: () => HOST_TEST_NOW,
+    now: () => clock,
     probeOwner: async () => ({ outcome: 'exit-observed' })
   })
 })
@@ -269,6 +271,20 @@ describe('host rewind', () => {
     expect(await host.rewind(caller, request)).toMatchObject({ ok: true, replayed: true })
     expect(rewind).toHaveBeenCalledTimes(1)
   })
+  it('keeps when each kept message was first seen, not when the rewind re-read it', async () => {
+    const target = await seed()
+    const kept = (await host.journalSnapshot(HOST_TEST_SESSION)).items[0]!
+    const identity = { provider: 'codex' as const, threadId: HOST_TEST_THREAD, turnId: 'kept' }
+    rewind.mockResolvedValueOnce({
+      ok: true,
+      items: [{ identity: { ...identity, ordinal: 0 }, body: kept.body }]
+    })
+    clock = HOST_TEST_NOW + 60_000
+    expect(await host.rewind(caller, await params(target))).toMatchObject({ ok: true })
+    const [after] = (await host.journalSnapshot(HOST_TEST_SESSION)).items
+    expect(after).toMatchObject({ itemId: kept.itemId, observedAt: kept.observedAt })
+    expect(after!.observedAt).not.toBe(clock)
+  })
   // The stream's failure is the stream's to recover from; its stale error is not the rewind's.
   it("rewinds after the chat's event sink failed, its error never failing the rewind", async () => {
     const target = await seed()
diff --git a/src/main/native-chat/agent-session-wire/structured-rewind-retained-host-rows.test.ts b/src/main/native-chat/agent-session-wire/structured-rewind-retained-host-rows.test.ts
index 43a2beee24c1..3fb9495501e8 100644
--- a/src/main/native-chat/agent-session-wire/structured-rewind-retained-host-rows.test.ts
+++ b/src/main/native-chat/agent-session-wire/structured-rewind-retained-host-rows.test.ts
@@ -65,7 +65,8 @@ describe('rewind keeps each retained row attributed', () => {
       agentId: 'child-thread',
       parentAgentId: 'root',
       producerKind: 'agent',
-      observedAt: 2
+      // When the row was first seen, not when the rewind re-read it.
+      observedAt: 1
     })
   })
 
diff --git a/src/main/native-chat/agent-session-wire/structured-rewind-retained-host-rows.ts b/src/main/native-chat/agent-session-wire/structured-rewind-retained-host-rows.ts
index f3e725787097..b1cbbe22b74a 100644
--- a/src/main/native-chat/agent-session-wire/structured-rewind-retained-host-rows.ts
+++ b/src/main/native-chat/agent-session-wire/structured-rewind-retained-host-rows.ts
@@ -1,8 +1,8 @@
 // Provider preflight returns provider items only. The host's lifecycle rows are its own record, so
 // a rewind that takes the provider list as the new epoch must splice those rows back beside the
 // provider item each one followed; so is an item of a kind a newer Orca wrote, which no provider
-// holds. Provider items carry neither turn scope nor producer, so each keeps the ones its retained
-// row held.
+// holds. Provider items carry neither turn scope, producer nor the time the row was first seen, so
+// each keeps the ones its retained row held.
 
 import { parseCodexGoalJournalItemId } from '../../codex/codex-goal-journal-identity'
 import { parseAgentJournalItemKey } from '../../../shared/agent-session-journal-item-key'
@@ -92,11 +92,13 @@ export function retainedRowReplacement(row: RetainedRow): AgentJournalProducerLi
   }
 }
 
+/** A provider item the old epoch held keeps that row's scope, producer and first-seen time; only
+ *  its body is the provider's. */
 function withHeldAttribution(item: RetainedRow, held: RetainedRow | undefined): RetainedRow {
   if (!held) {
     return item
   }
-  const { itemId: _itemId, body: _body, observedAt: _observedAt, ...attribution } = held
+  const { itemId: _itemId, body: _body, ...attribution } = held
   return { ...item, ...attribution }
 }
 

From 81278e4e02743d32aa5ebc8c6646cb03add79ec2 Mon Sep 17 00:00:00 2001
From: Brennan Benson <79079362+brennanb2025@users.noreply.github.com>
Date: Tue, 6 Oct 2026 00:16:42 -0700
Subject: [PATCH 20/22] fix(native-chat): hand rows the rewind through context
 so the list and pane stay within their line budgets after main's appearance
 changes

---
 ...NativeChatMessageList.rewind-rows.test.tsx | 43 ++++++------
 .../native-chat/NativeChatMessageList.tsx     |  9 +--
 .../NativeChatStructuredSession.tsx           | 66 ++++++++-----------
 .../native-chat/NativeChatTranscriptRow.tsx   | 10 +--
 .../native-chat/native-chat-rewind-context.ts |  5 ++
 .../use-native-chat-rewind-host.ts            | 24 +++++++
 6 files changed, 86 insertions(+), 71 deletions(-)
 create mode 100644 src/renderer/src/components/native-chat/native-chat-rewind-context.ts
 create mode 100644 src/renderer/src/components/native-chat/use-native-chat-rewind-host.ts

diff --git a/src/renderer/src/components/native-chat/NativeChatMessageList.rewind-rows.test.tsx b/src/renderer/src/components/native-chat/NativeChatMessageList.rewind-rows.test.tsx
index e6b9d37d0163..1cb82864e657 100644
--- a/src/renderer/src/components/native-chat/NativeChatMessageList.rewind-rows.test.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatMessageList.rewind-rows.test.tsx
@@ -16,6 +16,7 @@ import type {
 } from '../../../../shared/agent-session-journal-types'
 import { projectStructuredAgentSessionMessages } from '../../../../shared/structured-agent-session-message-projection'
 import { TooltipProvider } from '@/components/ui/tooltip'
+import { NativeChatRewindContext } from './native-chat-rewind-context'
 import { NativeChatMessageList } from './NativeChatMessageList'
 import { installNativeChatMessageListTestViewport } from './native-chat-message-list-test-viewport'
 
@@ -88,27 +89,27 @@ describe('which transcript rows offer Edit from here', () => {
     ]
     render(
       <TooltipProvider>
-        <NativeChatMessageList
-          session={{
-            messages: projectStructuredAgentSessionMessages(items, [], submissions, {
-              rejectedInPlace: true
-            }),
-            status: 'ready',
-            sessionId: 'session-1',
-            agent: 'codex',
-            hasMore: false,
-            loadingEarlier: false,
-            olderHistoryGeneration: 0,
-            loadEarlier: vi.fn(),
-            readPhase: 'ready'
-          }}
-          journalItems={items}
-          journalSubmissions={submissions}
-          isWorking={false}
-          expandSignal={false}
-          fontScale={1}
-          rewind={{ disabledReason: null, request: vi.fn() }}
-        />
+        <NativeChatRewindContext.Provider value={{ disabledReason: null, request: vi.fn() }}>
+          <NativeChatMessageList
+            session={{
+              messages: projectStructuredAgentSessionMessages(items, [], submissions, {
+                rejectedInPlace: true
+              }),
+              status: 'ready',
+              sessionId: 'session-1',
+              agent: 'codex',
+              hasMore: false,
+              loadingEarlier: false,
+              olderHistoryGeneration: 0,
+              loadEarlier: vi.fn(),
+              readPhase: 'ready'
+            }}
+            journalItems={items}
+            journalSubmissions={submissions}
+            isWorking={false}
+            expandSignal={false}
+          />
+        </NativeChatRewindContext.Provider>
       </TooltipProvider>
     )
     expect(screen.getByText('Make it four')).toBeInTheDocument()
diff --git a/src/renderer/src/components/native-chat/NativeChatMessageList.tsx b/src/renderer/src/components/native-chat/NativeChatMessageList.tsx
index 73e8b5da8a7f..5e406876a564 100644
--- a/src/renderer/src/components/native-chat/NativeChatMessageList.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatMessageList.tsx
@@ -1,4 +1,3 @@
-import type { NativeChatRewindSurface } from './use-native-chat-rewind'
 import {
   NATIVE_CHAT_TRANSCRIPT_OUTER_CLASS,
   NATIVE_CHAT_TRANSCRIPT_COLUMN_CLASS
@@ -88,8 +87,7 @@ export function NativeChatMessageList({
   deliveryNotices,
   awaitingInput = null,
   turnActivity,
-  runtimeContext,
-  rewind
+  runtimeContext
 }: {
   session: NativeChatLiveSession
   journalItems?: readonly AgentJournalRenderItem[]
@@ -114,7 +112,6 @@ export function NativeChatMessageList({
   awaitingInput?: NativeChatAwaitingInput | null
   turnActivity?: NativeChatTurnActivity | null
   runtimeContext?: RuntimeFileOperationArgs | null
-  rewind?: NativeChatRewindSurface
 }): React.JSX.Element {
   const [navigationRequest, setNavigationRequest] = useState<NativeChatNavigationRequest | null>(
     null
@@ -348,11 +345,9 @@ export function NativeChatMessageList({
       onToggleExpandedTurn: toggleExpandedTurn,
       subagentDisclosure,
       onScrollMessageToTop: scrollMessageToTop,
-      onRevealDiff: revealDiff,
-      rewind
+      onRevealDiff: revealDiff
     }),
     [
-      rewind,
       allowFileUriLinks,
       expandSignal,
       expandedTurnIds,
diff --git a/src/renderer/src/components/native-chat/NativeChatStructuredSession.tsx b/src/renderer/src/components/native-chat/NativeChatStructuredSession.tsx
index 812b66d3c64d..8f43b043c81a 100644
--- a/src/renderer/src/components/native-chat/NativeChatStructuredSession.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatStructuredSession.tsx
@@ -3,7 +3,7 @@ import {
   NATIVE_CHAT_APPEARANCE_ROOT_CLASS,
   useNativeChatAppearanceStyle
 } from './native-chat-appearance-style'
-import { useCallback, useMemo, useRef, useState } from 'react'
+import { useMemo, useRef, useState } from 'react'
 import { agentSessionPromptQuestions } from '../../../../shared/agent-session-question-answer'
 import { dispatchStructuredAgentSessionComposerCommand } from '../../../../shared/structured-agent-session-composer'
 import { structuredAgentSessionPaneKey } from '../../../../shared/structured-agent-session-projection'
@@ -29,10 +29,9 @@ import { NativeChatStructuredSessionStatus } from './NativeChatStructuredSession
 import { useNativeChatLaunchDraftSignal } from './use-native-chat-launch-draft-adoption'
 import { NativeChatLaunchRetry } from './NativeChatLaunchRetry'
 import { useNativeChatProvisionalLaunch } from './use-native-chat-provisional-launch'
-import {
-  useStructuredAgentSessionHostExecutionPhase,
-  useStructuredAgentSessionRewindBlockedReason
-} from './StructuredAgentSessionStatusBridge'
+import { useStructuredAgentSessionHostExecutionPhase } from './StructuredAgentSessionStatusBridge'
+import { useNativeChatRewindHost } from './use-native-chat-rewind-host'
+import { NativeChatRewindContext } from './native-chat-rewind-context'
 import { NativeChatQueuedMessageList } from './NativeChatQueuedMessageList'
 import { useAppStore } from '../../store'
 import { structuredAgentLabel } from '@/lib/structured-agent-session-launch-label'
@@ -52,10 +51,6 @@ export function NativeChatStructuredSession(
   const { sendThroughRelaunch } = provisionalLaunch
   // The host's own word on whether the provider child has answered startup yet.
   const startupPhase = useStructuredAgentSessionHostExecutionPhase(props.sessionId, props.target)
-  const rewindBlockedReason = useStructuredAgentSessionRewindBlockedReason(
-    props.sessionId,
-    props.target
-  )
   const paneKey = useMemo(
     () => structuredAgentSessionPaneKey(props.tabId, props.sessionId),
     [props.sessionId, props.tabId]
@@ -63,20 +58,14 @@ export function NativeChatStructuredSession(
   // Chat-wide: absent means on; only an explicit off keeps mid-turn sends immediate.
   const queueFollowUps = useAppStore((store) => store.settings?.nativeChatQueueFollowUps !== false)
   const composerRef = useRef<NativeChatComposerHandle>(null)
-  const focusComposer = useCallback(() => {
-    composerRef.current?.focus()
-  }, [])
+  const { rewindHost, focusComposer } = useNativeChatRewindHost(props, composerRef)
   const controller = useStructuredAgentSession({
     ...props,
     // Why: Stop and a queued card's Edit give text back to the conversation's draft, as the composer keeps it.
     composerScopeKey: structuredAgentSessionDraftScopeKey(props.sessionId),
     queueFollowUps,
     providerStarting: startupPhase === 'starting',
-    rewind: {
-      hostBlockedReason: rewindBlockedReason,
-      onMessageReturned: focusComposer,
-      isVisible: props.isVisible
-    },
+    rewind: rewindHost,
     transportEnabled: provisionalLaunch.transportEnabled,
     ...(provisionalLaunch.launch ? { launch: provisionalLaunch.launch } : {})
   })
@@ -291,27 +280,28 @@ export function NativeChatStructuredSession(
         ) : viewState.kind === 'empty' ? (
           <NativeChatEmptyState kind="empty" agent={props.agent} />
         ) : (
-          <NativeChatMessageList
-            // A rewind replaces the conversation; nothing the old transcript held carries over.
-            key={controller.epoch ?? undefined}
-            rewind={controller.rewind.surface}
-            session={session}
-            journalItems={controller.journalItems}
-            journalSubmissions={controller.submissions}
-            subagentRoster={controller.subagentRoster}
-            railOutline={controller.railOutline}
-            isVisible={props.isVisible}
-            isWorking={controller.isWorking}
-            expandSignal={false}
-            workingStartedAt={controller.workingStartedAt}
-            settledTurns={controller.settledTurns}
-            awaitingInput={prompt === null ? null : 'shown'}
-            turnActivity={controller.turnActivity}
-            onLinkClick={onLinkClick}
-            allowFileUriLinks={onLinkClick !== undefined}
-            runtimeContext={imageRuntimeContext}
-            deliveryNotices={deliveryNotices}
-          />
+          <NativeChatRewindContext.Provider value={controller.rewind.surface}>
+            <NativeChatMessageList
+              // A rewind replaces the conversation; nothing the old transcript held carries over.
+              key={controller.epoch ?? undefined}
+              session={session}
+              journalItems={controller.journalItems}
+              journalSubmissions={controller.submissions}
+              subagentRoster={controller.subagentRoster}
+              railOutline={controller.railOutline}
+              isVisible={props.isVisible}
+              isWorking={controller.isWorking}
+              expandSignal={false}
+              workingStartedAt={controller.workingStartedAt}
+              settledTurns={controller.settledTurns}
+              awaitingInput={prompt === null ? null : 'shown'}
+              turnActivity={controller.turnActivity}
+              onLinkClick={onLinkClick}
+              allowFileUriLinks={onLinkClick !== undefined}
+              runtimeContext={imageRuntimeContext}
+              deliveryNotices={deliveryNotices}
+            />
+          </NativeChatRewindContext.Provider>
         )}
       </div>
       {readFailedFinally ? null : (
diff --git a/src/renderer/src/components/native-chat/NativeChatTranscriptRow.tsx b/src/renderer/src/components/native-chat/NativeChatTranscriptRow.tsx
index 6e70635ed421..bcb3841cbb9c 100644
--- a/src/renderer/src/components/native-chat/NativeChatTranscriptRow.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatTranscriptRow.tsx
@@ -1,4 +1,4 @@
-import { memo } from 'react'
+import { memo, useContext } from 'react'
 import type { CommentMarkdownLinkClickHandler } from '@/components/sidebar/CommentMarkdown'
 import { cn } from '@/lib/utils'
 import type { RuntimeFileOperationArgs } from '@/runtime/runtime-file-client'
@@ -12,7 +12,7 @@ import type { NativeChatSubagentDisclosure } from './native-chat-subagent-sectio
 import type { NativeChatTaskListPredecessors } from './native-chat-task-list-history'
 import type { NativeChatTranscriptSlot } from './native-chat-transcript-slots'
 import type { NativeChatDiffReveal, NativeChatDiffTarget } from './native-chat-turn-diffs'
-import type { NativeChatRewindSurface } from './use-native-chat-rewind'
+import { NativeChatRewindContext } from './native-chat-rewind-context'
 import { nativeChatRowOffersRewind } from './native-chat-rewind-eligibility'
 
 /** Everything a row needs that is the same for every row. Held as one memoized
@@ -31,8 +31,6 @@ export type NativeChatTranscriptRowContext = {
   subagentDisclosure: NativeChatSubagentDisclosure
   onScrollMessageToTop: (element: HTMLElement) => void
   onRevealDiff: (target: NativeChatDiffTarget) => void
-  /** Offered on the conversation's own turn-opening prompts (`nativeChatRowOffersRewind`). */
-  rewind?: NativeChatRewindSurface
 }
 
 /** One transcript row: the message (or the receipt standing in for it), the turn
@@ -48,6 +46,8 @@ export const NativeChatTranscriptRow = memo(function NativeChatTranscriptRow({
   slot: NativeChatTranscriptSlot
   context: NativeChatTranscriptRowContext
 }): React.JSX.Element {
+  // Offered only on the conversation's own turn-opening prompts (`nativeChatRowOffersRewind`).
+  const rewind = useContext(NativeChatRewindContext)
   // A subagent's section is set off from the conversation it sits in.
   const sectionClassName = cn(
     slot.depth > 0 && 'border-l-2 border-border/60 pl-3',
@@ -119,7 +119,7 @@ export const NativeChatTranscriptRow = memo(function NativeChatTranscriptRow({
           runtimeContext={context.runtimeContext}
           rewind={
             nativeChatRowOffersRewind(message, slot, deliveryNotice !== undefined)
-              ? context.rewind
+              ? rewind
               : undefined
           }
         />
diff --git a/src/renderer/src/components/native-chat/native-chat-rewind-context.ts b/src/renderer/src/components/native-chat/native-chat-rewind-context.ts
new file mode 100644
index 000000000000..f5369196567d
--- /dev/null
+++ b/src/renderer/src/components/native-chat/native-chat-rewind-context.ts
@@ -0,0 +1,5 @@
+import { createContext } from 'react'
+import type { NativeChatRewindSurface } from './use-native-chat-rewind'
+
+/** The rewind the pane's user rows offer; absent where the chat cannot rewind. */
+export const NativeChatRewindContext = createContext<NativeChatRewindSurface | undefined>(undefined)
diff --git a/src/renderer/src/components/native-chat/use-native-chat-rewind-host.ts b/src/renderer/src/components/native-chat/use-native-chat-rewind-host.ts
new file mode 100644
index 000000000000..9a1fe3bf0a62
--- /dev/null
+++ b/src/renderer/src/components/native-chat/use-native-chat-rewind-host.ts
@@ -0,0 +1,24 @@
+import { useCallback, type RefObject } from 'react'
+import type { RuntimeClientTarget } from '@/runtime/runtime-rpc-client'
+import { useStructuredAgentSessionRewindBlockedReason } from './StructuredAgentSessionStatusBridge'
+import type { NativeChatComposerHandle } from './NativeChatComposer'
+import type { NativeChatRewindHost } from './use-native-chat-rewind'
+
+/** What a pane hands its session's rewind: the host's in-doubt latch, its visibility, and where a
+ *  returned message lands. `focusComposer` is the same focus the pane's other give-backs use. */
+export function useNativeChatRewindHost(
+  pane: { sessionId: string; target: RuntimeClientTarget; isVisible: boolean },
+  composerRef: RefObject<NativeChatComposerHandle | null>
+): { rewindHost: NativeChatRewindHost; focusComposer: () => void } {
+  const hostBlockedReason = useStructuredAgentSessionRewindBlockedReason(
+    pane.sessionId,
+    pane.target
+  )
+  const focusComposer = useCallback(() => {
+    composerRef.current?.focus()
+  }, [composerRef])
+  return {
+    rewindHost: { hostBlockedReason, onMessageReturned: focusComposer, isVisible: pane.isVisible },
+    focusComposer
+  }
+}

From e563c40dbe38fe9ed6e6eb086152db5ebba60b5d Mon Sep 17 00:00:00 2001
From: Brennan Benson <79079362+brennanb2025@users.noreply.github.com>
Date: Tue, 6 Oct 2026 00:25:57 -0700
Subject: [PATCH 21/22] fix(native-chat): fit the rewind recovery capability
 within protocol-version's line budget; hoist a test context value

---
 .../NativeChatMessageList.rewind-rows.test.tsx           | 4 +++-
 .../native-chat/NativeChatRewindAction.target.test.tsx   | 4 ++--
 .../use-structured-agent-session.rewind.test.tsx         | 2 +-
 .../structured-agent-session-host-capability.test.tsx    | 9 +++------
 .../runtime/structured-agent-session-host-capability.ts  | 7 ++-----
 src/shared/protocol-version.ts                           | 8 +++-----
 6 files changed, 14 insertions(+), 20 deletions(-)

diff --git a/src/renderer/src/components/native-chat/NativeChatMessageList.rewind-rows.test.tsx b/src/renderer/src/components/native-chat/NativeChatMessageList.rewind-rows.test.tsx
index 1cb82864e657..0ea41b1be3d7 100644
--- a/src/renderer/src/components/native-chat/NativeChatMessageList.rewind-rows.test.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatMessageList.rewind-rows.test.tsx
@@ -60,6 +60,8 @@ const settledTurn = (itemId: string, userItemId: string, start: number) =>
     completedAt: start + 1_000
   })
 
+const REWIND = { disabledReason: null, request: vi.fn() }
+
 describe('which transcript rows offer Edit from here', () => {
   it('offers it only on prompts that opened their own turn', () => {
     const steer = agentJournalSubmissionKey('steer')
@@ -89,7 +91,7 @@ describe('which transcript rows offer Edit from here', () => {
     ]
     render(
       <TooltipProvider>
-        <NativeChatRewindContext.Provider value={{ disabledReason: null, request: vi.fn() }}>
+        <NativeChatRewindContext.Provider value={REWIND}>
           <NativeChatMessageList
             session={{
               messages: projectStructuredAgentSessionMessages(items, [], submissions, {
diff --git a/src/renderer/src/components/native-chat/NativeChatRewindAction.target.test.tsx b/src/renderer/src/components/native-chat/NativeChatRewindAction.target.test.tsx
index 9174aa67c26e..11aa5dc2079c 100644
--- a/src/renderer/src/components/native-chat/NativeChatRewindAction.target.test.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatRewindAction.target.test.tsx
@@ -39,13 +39,13 @@ vi.mock('./use-structured-agent-session-read', () => ({
 
 import { useStructuredAgentSession } from './use-structured-agent-session'
 import { setLocalRuntimeCapabilitiesForTests } from '@/runtime/local-runtime-capabilities'
-import { AGENT_SESSION_REWIND_SEND_RECOVERY_RUNTIME_CAPABILITY } from '../../../../shared/protocol-version'
+import { AGENT_SESSION_REWIND_RECOVERY_CAPABILITY } from '../../../../shared/protocol-version'
 
 const target = { kind: 'local' } as const
 
 describe('rewind target after send acceptance', () => {
   beforeEach(() => {
-    setLocalRuntimeCapabilitiesForTests([AGENT_SESSION_REWIND_SEND_RECOVERY_RUNTIME_CAPABILITY])
+    setLocalRuntimeCapabilitiesForTests([AGENT_SESSION_REWIND_RECOVERY_CAPABILITY])
     vi.clearAllMocks()
     localStorage.clear()
     state = {
diff --git a/src/renderer/src/components/native-chat/use-structured-agent-session.rewind.test.tsx b/src/renderer/src/components/native-chat/use-structured-agent-session.rewind.test.tsx
index b3d9eb523483..34ae77bcb4ce 100644
--- a/src/renderer/src/components/native-chat/use-structured-agent-session.rewind.test.tsx
+++ b/src/renderer/src/components/native-chat/use-structured-agent-session.rewind.test.tsx
@@ -3,7 +3,7 @@
 import { act, renderHook, waitFor } from '@testing-library/react'
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 import type * as RuntimeRpcClient from '@/runtime/runtime-rpc-client'
-import { AGENT_SESSION_REWIND_SEND_RECOVERY_RUNTIME_CAPABILITY as RECOVERY } from '../../../../shared/protocol-version'
+import { AGENT_SESSION_REWIND_RECOVERY_CAPABILITY as RECOVERY } from '../../../../shared/protocol-version'
 
 const mocks = vi.hoisted(() => ({
   call: vi.fn(),
diff --git a/src/renderer/src/runtime/structured-agent-session-host-capability.test.tsx b/src/renderer/src/runtime/structured-agent-session-host-capability.test.tsx
index c141f6fea75c..7c8a0d4e3424 100644
--- a/src/renderer/src/runtime/structured-agent-session-host-capability.test.tsx
+++ b/src/renderer/src/runtime/structured-agent-session-host-capability.test.tsx
@@ -7,7 +7,7 @@ import {
   AGENT_SESSION_CONVERSATION_STOP_RUNTIME_CAPABILITY,
   AGENT_SESSION_QUEUED_MESSAGES_RUNTIME_CAPABILITY,
   AGENT_SESSION_REWIND_RUNTIME_CAPABILITY,
-  AGENT_SESSION_REWIND_SEND_RECOVERY_RUNTIME_CAPABILITY
+  AGENT_SESSION_REWIND_RECOVERY_CAPABILITY
 } from '../../../shared/protocol-version'
 
 const mocks = vi.hoisted(() => ({
@@ -108,7 +108,7 @@ describe('whether a host settles an in-doubt rewind on the next send', () => {
       renderHook(() => useStructuredAgentSessionHostRecoversRewindOnSend({ kind: 'local' })).result
         .current
     ).toBe(false)
-    setLocalRuntimeCapabilitiesForTests([AGENT_SESSION_REWIND_SEND_RECOVERY_RUNTIME_CAPABILITY])
+    setLocalRuntimeCapabilitiesForTests([AGENT_SESSION_REWIND_RECOVERY_CAPABILITY])
     expect(
       renderHook(() => useStructuredAgentSessionHostRecoversRewindOnSend({ kind: 'local' })).result
         .current
@@ -124,10 +124,7 @@ describe('whether a host settles an in-doubt rewind on the next send', () => {
       })
     )
     await waitFor(() =>
-      expect(mocks.supports).toHaveBeenCalledWith(
-        'env-1',
-        AGENT_SESSION_REWIND_SEND_RECOVERY_RUNTIME_CAPABILITY
-      )
+      expect(mocks.supports).toHaveBeenCalledWith('env-1', AGENT_SESSION_REWIND_RECOVERY_CAPABILITY)
     )
     await waitFor(() => expect(result.current).toBe(supported))
   })
diff --git a/src/renderer/src/runtime/structured-agent-session-host-capability.ts b/src/renderer/src/runtime/structured-agent-session-host-capability.ts
index 04b437fd5d3c..e083eadb57a9 100644
--- a/src/renderer/src/runtime/structured-agent-session-host-capability.ts
+++ b/src/renderer/src/runtime/structured-agent-session-host-capability.ts
@@ -2,7 +2,7 @@ import { useEffect, useState } from 'react'
 import {
   AGENT_SESSION_CONVERSATION_STOP_RUNTIME_CAPABILITY,
   AGENT_SESSION_QUEUED_MESSAGES_RUNTIME_CAPABILITY,
-  AGENT_SESSION_REWIND_SEND_RECOVERY_RUNTIME_CAPABILITY,
+  AGENT_SESSION_REWIND_RECOVERY_CAPABILITY,
   type RuntimeCapability
 } from '../../../shared/protocol-version'
 import type { RuntimeClientTarget } from './runtime-client-target'
@@ -99,10 +99,7 @@ export function useStructuredAgentSessionHostStopsConversation(
 export function useStructuredAgentSessionHostRecoversRewindOnSend(
   target: RuntimeClientTarget
 ): boolean {
-  return useStructuredAgentSessionHostCapability(
-    target,
-    AGENT_SESSION_REWIND_SEND_RECOVERY_RUNTIME_CAPABILITY
-  )
+  return useStructuredAgentSessionHostCapability(target, AGENT_SESSION_REWIND_RECOVERY_CAPABILITY)
 }
 
 /** Whether the host holds mid-turn sends as drafts: only then may a client send `delivery`
diff --git a/src/shared/protocol-version.ts b/src/shared/protocol-version.ts
index b96958c4de7f..df9b645d10f5 100644
--- a/src/shared/protocol-version.ts
+++ b/src/shared/protocol-version.ts
@@ -263,10 +263,8 @@ export const AGENT_SESSION_CONVERSATION_OUTLINE_RUNTIME_CAPABILITY =
   'agent-session.conversation-outline.v1' as const
 // The RPC is registered unconditionally; per-session rewind support is a separate check.
 export const AGENT_SESSION_REWIND_RUNTIME_CAPABILITY = 'agent-session.rewind.v1' as const
-// Why: the rewind UI returns an in-doubt prompt and relies on the next send to settle the rewind,
-// even with the agent running; hosts with only the rewind RPC refuse that send until a restart.
-export const AGENT_SESSION_REWIND_SEND_RECOVERY_RUNTIME_CAPABILITY =
-  'agent-session.rewind-send-recovery.v1' as const
+// Why: the rewind UI relies on the next send settling an in-doubt rewind, even with the agent up.
+export const AGENT_SESSION_REWIND_RECOVERY_CAPABILITY = 'agent-session.rewind-recovery.v1' as const
 // Readers must understand a monitoring roster with no available stop control.
 // Why: a `turn` journal item replaced the status row that used to carry a turn's lifecycle. A
 // client that predates it would render the unknown kind as text, so the host publishes the legacy
@@ -412,7 +410,7 @@ export const RUNTIME_CAPABILITIES = [
   AGENT_SESSION_STATUS_FEED_RUNTIME_CAPABILITY,
   AGENT_SESSION_TURN_COMPLETION_RUNTIME_CAPABILITY,
   AGENT_SESSION_REWIND_RUNTIME_CAPABILITY,
-  AGENT_SESSION_REWIND_SEND_RECOVERY_RUNTIME_CAPABILITY,
+  AGENT_SESSION_REWIND_RECOVERY_CAPABILITY,
   AGENT_SESSION_CONVERSATION_OUTLINE_RUNTIME_CAPABILITY,
   AGENT_SESSION_BACKGROUND_TASK_STOP_CAPABILITY,
   AGENT_SESSION_QUESTION_ANSWERS_RUNTIME_CAPABILITY,

From e423c0751184d65a6f3a387c58544aac79a1a703 Mon Sep 17 00:00:00 2001
From: Brennan Benson <79079362+brennanb2025@users.noreply.github.com>
Date: Tue, 6 Oct 2026 02:09:05 -0700
Subject: [PATCH 22/22] fix(native-chat): label the action "Rewind to here"

---
 .../NativeChatMessageList.rewind-rows.test.tsx            | 4 ++--
 .../components/native-chat/NativeChatMessageRow.test.tsx  | 2 +-
 .../native-chat/NativeChatRewindAction.target.test.tsx    | 6 +++---
 .../native-chat/NativeChatRewindAction.test.tsx           | 8 ++++----
 .../src/components/native-chat/NativeChatRewindAction.tsx | 2 +-
 .../src/components/native-chat/native-chat-rewind-copy.ts | 2 +-
 .../native-chat/native-chat-rewind-eligibility.ts         | 2 +-
 .../native-chat/use-native-chat-rewind.test.tsx           | 4 ++--
 .../src/components/native-chat/use-native-chat-rewind.ts  | 4 ++--
 src/renderer/src/i18n/locales/en.json                     | 8 ++++----
 10 files changed, 21 insertions(+), 21 deletions(-)

diff --git a/src/renderer/src/components/native-chat/NativeChatMessageList.rewind-rows.test.tsx b/src/renderer/src/components/native-chat/NativeChatMessageList.rewind-rows.test.tsx
index 0ea41b1be3d7..c25d4c294fd0 100644
--- a/src/renderer/src/components/native-chat/NativeChatMessageList.rewind-rows.test.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatMessageList.rewind-rows.test.tsx
@@ -62,7 +62,7 @@ const settledTurn = (itemId: string, userItemId: string, start: number) =>
 
 const REWIND = { disabledReason: null, request: vi.fn() }
 
-describe('which transcript rows offer Edit from here', () => {
+describe('which transcript rows offer Rewind to here', () => {
   it('offers it only on prompts that opened their own turn', () => {
     const steer = agentJournalSubmissionKey('steer')
     const compact = agentJournalItemKey({ provider: 'orca', clientMessageId: 'cmd-1' })
@@ -116,7 +116,7 @@ describe('which transcript rows offer Edit from here', () => {
     )
     expect(screen.getByText('Make it four')).toBeInTheDocument()
     expect(screen.getByText('/compact')).toBeInTheDocument()
-    const offered = screen.getAllByRole('button', { name: 'Edit from here' })
+    const offered = screen.getAllByRole('button', { name: 'Rewind to here' })
     const after = (later: Element, earlier: Element) =>
       Boolean(earlier.compareDocumentPosition(later) & Node.DOCUMENT_POSITION_FOLLOWING)
     // The opener's and the last prompt's; the steer and the /compact row get none.
diff --git a/src/renderer/src/components/native-chat/NativeChatMessageRow.test.tsx b/src/renderer/src/components/native-chat/NativeChatMessageRow.test.tsx
index 8190805cd630..01c5b890b9c0 100644
--- a/src/renderer/src/components/native-chat/NativeChatMessageRow.test.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatMessageRow.test.tsx
@@ -69,7 +69,7 @@ describe('MessageRow control visibility', () => {
     renderMessage('user', 0, { disabledReason: null, request })
     const copy = screen.getByRole('button', { name: 'Copy message' })
     const time = screen.getByRole('time')
-    const edit = screen.getByRole('button', { name: 'Edit from here' })
+    const edit = screen.getByRole('button', { name: 'Rewind to here' })
     expect(Array.from(copy.parentElement!.children)).toEqual([copy, time, edit])
     expect(copy.parentElement).toHaveClass('can-hover:opacity-0', 'group-hover:opacity-100')
     edit.focus()
diff --git a/src/renderer/src/components/native-chat/NativeChatRewindAction.target.test.tsx b/src/renderer/src/components/native-chat/NativeChatRewindAction.target.test.tsx
index 11aa5dc2079c..5fee5da21435 100644
--- a/src/renderer/src/components/native-chat/NativeChatRewindAction.target.test.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatRewindAction.target.test.tsx
@@ -101,7 +101,7 @@ describe('rewind target after send acceptance', () => {
       </TooltipProvider>
     )
     const view = render(row())
-    fireEvent.click(screen.getByRole('button', { name: 'Edit from here' }))
+    fireEvent.click(screen.getByRole('button', { name: 'Rewind to here' }))
     expect(confirm).not.toHaveBeenCalled()
 
     const providerItemId = agentJournalItemKey(
@@ -137,7 +137,7 @@ describe('rewind target after send acceptance', () => {
     }
 
     view.rerender(row())
-    fireEvent.click(screen.getByRole('button', { name: 'Edit from here' }))
+    fireEvent.click(screen.getByRole('button', { name: 'Rewind to here' }))
     await waitFor(() =>
       expect(mocks.call).toHaveBeenCalledWith(
         target,
@@ -146,6 +146,6 @@ describe('rewind target after send acceptance', () => {
       )
     )
     expect(confirm).toHaveBeenCalledOnce()
-    expect(confirm).toHaveBeenCalledWith(expect.objectContaining({ title: 'Edit from here?' }))
+    expect(confirm).toHaveBeenCalledWith(expect.objectContaining({ title: 'Rewind to here?' }))
   })
 })
diff --git a/src/renderer/src/components/native-chat/NativeChatRewindAction.test.tsx b/src/renderer/src/components/native-chat/NativeChatRewindAction.test.tsx
index 5d9780c036fc..c0e4318c4e9b 100644
--- a/src/renderer/src/components/native-chat/NativeChatRewindAction.test.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatRewindAction.test.tsx
@@ -39,7 +39,7 @@ function row(
 describe('user-row rewind affordance', () => {
   it('is keyboard reachable and calls the selected user item from the hover strip', () => {
     const request = row('user')
-    const button = screen.getByRole('button', { name: 'Edit from here' })
+    const button = screen.getByRole('button', { name: 'Rewind to here' })
     button.focus()
     expect(button).toHaveFocus()
     expect(button.parentElement).toHaveClass(
@@ -51,7 +51,7 @@ describe('user-row rewind affordance', () => {
   })
   it('exposes the disabled reason to keyboard users and cannot invoke rewind', async () => {
     const request = row('user', 'Wait for the current turn to finish first.')
-    const button = screen.getByRole('button', { name: 'Edit from here' })
+    const button = screen.getByRole('button', { name: 'Rewind to here' })
     expect(button).toHaveAttribute('aria-disabled', 'true')
     expect(button).toHaveAttribute('aria-description', 'Wait for the current turn to finish first.')
     act(() => button.focus())
@@ -64,10 +64,10 @@ describe('user-row rewind affordance', () => {
   })
   it.each(['assistant', 'reasoning', 'system'] as const)('omits rewind for %s', (role) => {
     row(role)
-    expect(screen.queryByRole('button', { name: 'Edit from here' })).toBeNull()
+    expect(screen.queryByRole('button', { name: 'Rewind to here' })).toBeNull()
   })
   it('renders nothing where the row is offered no rewind', () => {
     row('user', null, false)
-    expect(screen.queryByRole('button', { name: 'Edit from here' })).toBeNull()
+    expect(screen.queryByRole('button', { name: 'Rewind to here' })).toBeNull()
   })
 })
diff --git a/src/renderer/src/components/native-chat/NativeChatRewindAction.tsx b/src/renderer/src/components/native-chat/NativeChatRewindAction.tsx
index 26eebad91839..19e3c79747d2 100644
--- a/src/renderer/src/components/native-chat/NativeChatRewindAction.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatRewindAction.tsx
@@ -12,7 +12,7 @@ export function NativeChatRewindAction({
   rewind: NativeChatRewindSurface
 }) {
   const confirm = useConfirmationDialog()
-  const label = translate('components.native-chat.rewind.action', 'Edit from here')
+  const label = translate('components.native-chat.rewind.action', 'Rewind to here')
   return (
     <Tooltip>
       <TooltipTrigger asChild>
diff --git a/src/renderer/src/components/native-chat/native-chat-rewind-copy.ts b/src/renderer/src/components/native-chat/native-chat-rewind-copy.ts
index a4ebf9a7b747..2599f84bf26e 100644
--- a/src/renderer/src/components/native-chat/native-chat-rewind-copy.ts
+++ b/src/renderer/src/components/native-chat/native-chat-rewind-copy.ts
@@ -13,7 +13,7 @@ const reasonCopy = {
   'history-not-paginated': () =>
     translate(
       'components.native-chat.rewind.historyNotPaginated',
-      "This older Codex chat can't go back to an earlier message. Start a new chat to use Edit from here."
+      "This older Codex chat can't go back to an earlier message. Start a new chat to use Rewind to here."
     ),
   busy: () =>
     translate(
diff --git a/src/renderer/src/components/native-chat/native-chat-rewind-eligibility.ts b/src/renderer/src/components/native-chat/native-chat-rewind-eligibility.ts
index 3f7492b74234..b9bf366fcd0e 100644
--- a/src/renderer/src/components/native-chat/native-chat-rewind-eligibility.ts
+++ b/src/renderer/src/components/native-chat/native-chat-rewind-eligibility.ts
@@ -1,4 +1,4 @@
-// Where "Edit from here" is offered: which providers can rewind, and which transcript rows.
+// Where "Rewind to here" is offered: which providers can rewind, and which transcript rows.
 
 import type { AgentSessionRewindSupport } from '../../../../shared/agent-session-rewind'
 import type { NativeChatMessage } from '../../../../shared/native-chat-types'
diff --git a/src/renderer/src/components/native-chat/use-native-chat-rewind.test.tsx b/src/renderer/src/components/native-chat/use-native-chat-rewind.test.tsx
index cfd40b444b63..16a59098f778 100644
--- a/src/renderer/src/components/native-chat/use-native-chat-rewind.test.tsx
+++ b/src/renderer/src/components/native-chat/use-native-chat-rewind.test.tsx
@@ -89,8 +89,8 @@ describe('structured chat rewind', () => {
     await act(() => view.result.current.request('user', confirm))
     expect(confirm).toHaveBeenCalledWith(
       expect.objectContaining({
-        title: 'Edit from here?',
-        confirmLabel: 'Discard and edit',
+        title: 'Rewind to here?',
+        confirmLabel: 'Rewind',
         confirmVariant: 'destructive',
         description: expect.not.stringMatching(/in total/)
       })
diff --git a/src/renderer/src/components/native-chat/use-native-chat-rewind.ts b/src/renderer/src/components/native-chat/use-native-chat-rewind.ts
index 3dcebcc501bd..6a979be407b4 100644
--- a/src/renderer/src/components/native-chat/use-native-chat-rewind.ts
+++ b/src/renderer/src/components/native-chat/use-native-chat-rewind.ts
@@ -164,12 +164,12 @@ export function useNativeChatRewind(input: RewindInput) {
     let keepBlocked = false
     try {
       const confirmed = await confirm({
-        title: translate('components.native-chat.rewind.title', 'Edit from here?'),
+        title: translate('components.native-chat.rewind.title', 'Rewind to here?'),
         description: translate(
           'components.native-chat.rewind.confirmation',
           'Discard this message and everything after it? The message returns to the composer so you can edit and resend it. File changes on disk are kept.'
         ),
-        confirmLabel: translate('components.native-chat.rewind.confirm', 'Discard and edit'),
+        confirmLabel: translate('components.native-chat.rewind.confirm', 'Rewind'),
         cancelLabel: translate('components.native-chat.rewind.cancel', 'Cancel'),
         confirmVariant: 'destructive',
         cancelVariant: 'ghost'
diff --git a/src/renderer/src/i18n/locales/en.json b/src/renderer/src/i18n/locales/en.json
index 017e05e5abbb..775000c63335 100644
--- a/src/renderer/src/i18n/locales/en.json
+++ b/src/renderer/src/i18n/locales/en.json
@@ -18226,7 +18226,7 @@
       },
       "rewind": {
         "unsupported": "This chat can't go back to an earlier message.",
-        "historyNotPaginated": "This older Codex chat can't go back to an earlier message. Start a new chat to use Edit from here.",
+        "historyNotPaginated": "This older Codex chat can't go back to an earlier message. Start a new chat to use Rewind to here.",
         "busy": "Available once the agent is idle and nothing in this chat is waiting on you.",
         "staleEpoch": "The conversation changed. Review the latest messages and try again.",
         "invalidTarget": "The conversation can't go back to this message. Nothing was changed.",
@@ -18239,11 +18239,11 @@
         "refused": "Orca couldn't go back to this message. Check the conversation before continuing.",
         "unavailable": "Wait for the chat to finish connecting.",
         "pending": "Wait for the conversation to go back to the earlier message.",
-        "title": "Edit from here?",
+        "title": "Rewind to here?",
         "confirmation": "Discard this message and everything after it? The message returns to the composer so you can edit and resend it. File changes on disk are kept.",
-        "confirm": "Discard and edit",
+        "confirm": "Rewind",
         "cancel": "Cancel",
-        "action": "Edit from here"
+        "action": "Rewind to here"
       },
       "drop": {
         "title": "Drop to attach to this chat",