From 641a7f36d98af01d9ebf53ceceae6a3fe0ba2b10 Mon Sep 17 00:00:00 2001
From: Brennan Benson <79079362+brennanb2025@users.noreply.github.com>
Date: Wed, 23 Sep 2026 10:49:04 -0700
Subject: [PATCH] fix(native-chat): keep one live tool-run header from a call's
 start to the turn's end (#22432)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* fix(native-chat): keep one live tool-run header from a call's start to the turn's end

The collapsed tool run's header was two elements, one for "a call is running"
and one for "nothing is", chosen call by call. Every call start and end
remounted it, the count disappeared while a call ran and came back one
higher, and a call that finished inside a frame still bought the whole swap.
That is the 42→43 flicker in the report.

The header is now one element whose live state belongs to the turn, not to
any call: it stays live from the run's first call until the agent moves past
it (prose, a further run, or the turn's end), and settles in place. While
live the sentence speaks in the present tense and counts the call in flight
("Running 3 commands"), with the latest call's command beside it as a muted
preview; once settled it reads as before ("Ran 3 commands ✓"). The category
glyph is the run's in both states, and the completion mark only appears once
settled, so nothing pops between calls.

Which run is live is derived where the transcript is sliced into rows: the
last row that speaks or acts is the trailing one. A reasoning aside after it
leaves it live; an answer or a further run settles it.

Present-tense forms for the ten sentence categories are added to the shared
copy and the English catalog. The transcript-file lane, which renders with
the structured activity UI off, is unchanged.

* fix(native-chat): settle a run blocked on the reader, keep it live past an approval

- A run whose question is awaiting the reader's answer no longer pulses
  "Reading 1 file" while the agent is blocked; it falls back to its calls.
- An approval's receipt no longer moves past the run above it, so the call
  it just approved reads as running while it runs.
- The header button is the live region, so the count is announced too.
- Drop the unused live option and record from the shared English sentence;
  nothing renders it yet.

* fix(native-chat): stop the settled run's check from fading in on every mount

Windowing remounts settled rows as the reader scrolls, and a restored transcript
mounts them all at once, so the fade replayed where nothing had changed. Also
pin that the live header counts the next call on the same element.
---
 .../NativeChatMessageList.test.tsx            |  53 ++++++++-
 ...iveChatMessageList.turn-indicator.test.tsx |  26 +++--
 .../native-chat/NativeChatMessageRow.tsx      |   4 +
 .../NativeChatToolRun.ask-row.test.tsx        |   7 +-
 .../native-chat/NativeChatToolRun.test.tsx    | 104 +++++++++++++----
 .../native-chat/NativeChatToolRun.tsx         |  85 ++++++++------
 .../native-chat/NativeChatTranscriptRow.tsx   |   1 +
 .../native-chat-tool-activity-label.ts        |  20 ----
 .../native-chat/native-chat-tool-run-label.ts | 107 +++++++++++++++++-
 .../native-chat-transcript-slots.test.ts      |  50 ++++++++
 .../native-chat-transcript-slots.ts           |  17 +++
 ...ve-chat-transcript-window.options.test.tsx |   1 +
 src/renderer/src/i18n/locales/en.json         |  22 +++-
 src/shared/native-chat-tool-activity.ts       |  17 ++-
 14 files changed, 419 insertions(+), 95 deletions(-)
 delete mode 100644 src/renderer/src/components/native-chat/native-chat-tool-activity-label.ts

diff --git a/src/renderer/src/components/native-chat/NativeChatMessageList.test.tsx b/src/renderer/src/components/native-chat/NativeChatMessageList.test.tsx
index 426493ee3ba..19a3eff4d09 100644
--- a/src/renderer/src/components/native-chat/NativeChatMessageList.test.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatMessageList.test.tsx
@@ -90,11 +90,59 @@ describe('NativeChatMessageList assistant messages', () => {
       />
     )
 
-    expect(screen.getByText('Running sleep 5')).toBeInTheDocument()
+    expect(screen.getByText('Running 1 command')).toBeInTheDocument()
+    expect(screen.getByText('sleep 5')).toBeInTheDocument()
     expect(screen.queryByText('1×')).toBeNull()
     expect(document.querySelector('.text-destructive')).toBeNull()
   })
 
+  // Only the turn's trailing run is live. Once the agent has said something
+  // after it, that run is done whatever its last call still reports; a
+  // reasoning aside is not "after it" — the agent is still inside the batch.
+  it('settles a run once prose follows it, but not for a reasoning aside', () => {
+    const run = {
+      id: 'assistant-tool-1',
+      role: 'assistant' as const,
+      blocks: [
+        {
+          type: 'tool-call' as const,
+          name: 'shell',
+          input: { command: 'sleep 5' },
+          state: 'running' as const
+        }
+      ],
+      timestamp: 1,
+      source: 'transcript' as const
+    }
+    const after = (role: 'assistant' | 'reasoning') => ({
+      id: `after-${role}`,
+      role,
+      blocks: [{ type: 'text' as const, text: 'Looking at the output.' }],
+      timestamp: 2,
+      source: 'transcript' as const
+    })
+    const { rerender } = render(
+      <NativeChatMessageList
+        session={{ ...session, status: 'working', messages: [run, after('reasoning')] }}
+        isWorking
+        expandSignal={false}
+        fontScale={1}
+      />
+    )
+    expect(screen.getByText('Running 1 command')).toBeInTheDocument()
+
+    rerender(
+      <NativeChatMessageList
+        session={{ ...session, status: 'working', messages: [run, after('assistant')] }}
+        isWorking
+        expandSignal={false}
+        fontScale={1}
+      />
+    )
+    expect(screen.queryByText('Running 1 command')).toBeNull()
+    expect(screen.getByText('sleep 5')).toBeInTheDocument()
+  })
+
   it('keeps the current tool live when a stale completed lifecycle meets active hook state', () => {
     render(
       <NativeChatMessageList
@@ -125,7 +173,8 @@ describe('NativeChatMessageList assistant messages', () => {
       />
     )
 
-    expect(screen.getByText('Running sleep 5')).toBeInTheDocument()
+    expect(screen.getByText('Running 1 command')).toBeInTheDocument()
+    expect(screen.getByText('sleep 5')).toBeInTheDocument()
   })
 })
 
diff --git a/src/renderer/src/components/native-chat/NativeChatMessageList.turn-indicator.test.tsx b/src/renderer/src/components/native-chat/NativeChatMessageList.turn-indicator.test.tsx
index 061076aa967..0b0aa932a2d 100644
--- a/src/renderer/src/components/native-chat/NativeChatMessageList.turn-indicator.test.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatMessageList.turn-indicator.test.tsx
@@ -126,9 +126,10 @@ describe('NativeChatMessageList turn indicator', () => {
       />
     )
 
-    const toolLabel = screen.getByText('Running pnpm test')
+    const toolLabel = screen.getByText('Running 1 command')
     expect(toolLabel).toHaveClass('animate-pulse')
-    expect(screen.getAllByText('Running pnpm test')).toHaveLength(1)
+    expect(screen.getAllByText('Running 1 command')).toHaveLength(1)
+    expect(screen.getByText('pnpm test')).toBeInTheDocument()
     const activity = screen.getByText('Working for 0s')
     expect(activity.textContent).not.toBe(toolLabel.textContent)
     expect(activity).not.toHaveTextContent('shell')
@@ -172,7 +173,7 @@ describe('NativeChatMessageList turn indicator', () => {
     expect(container.querySelector('[data-native-chat-turn-activity]')).toBeNull()
     expect(screen.queryByText(/Working for/)).toBeNull()
     expect(screen.queryByText('Thinking')).toBeNull()
-    expect(screen.getByText('Running pnpm test')).toHaveClass('animate-pulse')
+    expect(screen.getByText('Running 1 command')).toHaveClass('animate-pulse')
   })
 
   it('keeps the live row up after a tool settles', () => {
@@ -217,7 +218,10 @@ describe('NativeChatMessageList turn indicator', () => {
     )
   })
 
-  it('keeps a completed tool row static while the turn tail spins, then removes the tail', () => {
+  // The run is the turn's trailing one, so it stays live between calls and only
+  // settles with the turn. Its motion is its own — the tail's spinner never
+  // migrates onto it — and both are gone once the turn is.
+  it('keeps the trailing run live while the turn tail spins, then settles both', () => {
     const workingSession: NativeChatLiveSession = {
       ...session,
       status: 'working',
@@ -249,10 +253,11 @@ describe('NativeChatMessageList turn indicator', () => {
       />
     )
 
-    const settledTool = screen.getByText('pnpm test')
-    expect(settledTool).toHaveTextContent('pnpm test')
-    expect(settledTool.closest('button')?.querySelector('.animate-pulse')).toBeNull()
-    expect(settledTool.closest('button')?.querySelector('.lucide-check')).toBeInTheDocument()
+    const liveRun = screen.getByText('Running 1 command').closest('button')
+    expect(liveRun).toHaveTextContent('pnpm test')
+    expect(liveRun?.querySelector('.animate-pulse')).toBeInTheDocument()
+    expect(liveRun?.querySelector('.animate-spin')).toBeNull()
+    expect(liveRun?.querySelector('.lucide-check')).toBeNull()
     const activity = screen.getByText('Preparing the answer')
     expect(activity).not.toHaveClass('animate-pulse', 'animate-spin')
     expect(activity.closest('[data-native-chat-turn-activity]')?.querySelector('svg')).toHaveClass(
@@ -272,6 +277,11 @@ describe('NativeChatMessageList turn indicator', () => {
     expect(container.querySelector('[data-native-chat-turn-activity]')).toBeNull()
     expect(container.querySelector('.animate-pulse')).toBeNull()
     expect(container.querySelector('.animate-spin')).toBeNull()
+    // Same element, now settled: the lone command names it, marked done.
+    expect(liveRun).toBeInTheDocument()
+    expect(liveRun).toHaveTextContent('pnpm test')
+    expect(liveRun).not.toHaveTextContent('Running')
+    expect(liveRun?.querySelector('.lucide-check')).toBeInTheDocument()
   })
 
   it('keeps bridge chats on the legacy activity chrome', () => {
diff --git a/src/renderer/src/components/native-chat/NativeChatMessageRow.tsx b/src/renderer/src/components/native-chat/NativeChatMessageRow.tsx
index 3388fa79082..3d82417e8ce 100644
--- a/src/renderer/src/components/native-chat/NativeChatMessageRow.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatMessageRow.tsx
@@ -34,6 +34,7 @@ export const MessageRow = memo(function MessageRow({
   revealedDiff,
   expandSignal,
   activeTurnIsWorking,
+  trailingRun,
   onScrollMessageToTop,
   onLinkClick,
   allowFileUriLinks = false,
@@ -48,6 +49,8 @@ export const MessageRow = memo(function MessageRow({
   revealedDiff?: NativeChatDiffReveal
   expandSignal: boolean
   activeTurnIsWorking?: boolean
+  /** This row's tool run is the turn's last, so it is the one still live. */
+  trailingRun?: boolean
   /** Align this message's top to the top of the scroll viewport. */
   onScrollMessageToTop: (el: HTMLElement) => void
   onLinkClick?: CommentMarkdownLinkClickHandler
@@ -214,6 +217,7 @@ export const MessageRow = memo(function MessageRow({
           backgroundTasks={backgroundTasks}
           expandSignal={expandSignal}
           activeTurnIsWorking={activeTurnIsWorking}
+          trailing={trailingRun}
           structuredActivityUi={structuredActivityUi}
           disclosureId={message.id}
         />
diff --git a/src/renderer/src/components/native-chat/NativeChatToolRun.ask-row.test.tsx b/src/renderer/src/components/native-chat/NativeChatToolRun.ask-row.test.tsx
index 6efe920c20e..4de5a0d214b 100644
--- a/src/renderer/src/components/native-chat/NativeChatToolRun.ask-row.test.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatToolRun.ask-row.test.tsx
@@ -37,7 +37,8 @@ describe('NativeChatToolRun awaiting-input row', () => {
       />
     )
     expect(screen.getByText('Awaiting user input:')).toBeInTheDocument()
-    expect(screen.getByText(/Running Read/)).toBeInTheDocument()
+    expect(screen.getByText('Reading 1 file')).toBeInTheDocument()
+    expect(screen.getByText('Read a.ts')).toBeInTheDocument()
   })
 
   it('preserves errors from failed question calls', () => {
@@ -91,8 +92,10 @@ describe('NativeChatToolRun awaiting-input row', () => {
     render(<NativeChatToolRun blocks={blocks} expandSignal activeTurnIsWorking />)
 
     expect(screen.getByText('Awaiting user input:')).toBeInTheDocument()
-    // One call ran; being asked a question is not work to summarize.
+    // One call ran; being asked a question is not work to summarize. The agent
+    // is blocked on the reader, so the run reads settled, not in progress.
     expect(screen.getByText('Read 1 file')).toBeInTheDocument()
+    expect(screen.queryByText('Reading 1 file')).toBeNull()
   })
 
   it('draws the row from the tool name when the payload names no question', () => {
diff --git a/src/renderer/src/components/native-chat/NativeChatToolRun.test.tsx b/src/renderer/src/components/native-chat/NativeChatToolRun.test.tsx
index c491c3d6ad4..f40a4963f25 100644
--- a/src/renderer/src/components/native-chat/NativeChatToolRun.test.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatToolRun.test.tsx
@@ -379,12 +379,18 @@ describe('NativeChatToolRun', () => {
 
     const { container } = render(<NativeChatToolRun blocks={blocks} expandSignal={false} />)
 
-    const activeLabel = screen.getByText('Running cat package.json')
-    expect(activeLabel).toBeInTheDocument()
-    expect(activeLabel).toHaveClass('animate-pulse', 'motion-reduce:animate-none')
-    expect(screen.queryByText('Running date')).toBeNull()
-    expect(screen.queryByText('Running pwd')).toBeNull()
-    expect(screen.queryByText('Ran 3 commands and used 1 tool')).toBeNull()
+    // The sentence counts the call in flight and speaks in the present; the
+    // latest call sits beside it. Earlier calls are one click away, not here.
+    const header = runHeader(container)
+    expect(header).toHaveTextContent('Running 3 commands')
+    expect(header).toHaveTextContent('cat package.json')
+    expect(header).not.toHaveTextContent('date')
+    expect(header).not.toHaveTextContent('pwd')
+    expect(screen.getByText('Running 3 commands')).toHaveClass(
+      'animate-pulse',
+      'motion-reduce:animate-none'
+    )
+    expect(header.querySelector('.lucide-check')).toBeNull()
     expect(container.querySelector('.animate-spin')).toBeNull()
   })
 
@@ -397,7 +403,8 @@ describe('NativeChatToolRun', () => {
       />
     )
 
-    expect(screen.getByText('Running sleep 5')).toBeInTheDocument()
+    expect(screen.getByText('Running 1 command')).toBeInTheDocument()
+    expect(screen.getByText('sleep 5')).toBeInTheDocument()
   })
 
   it('keeps a completed tool payload collapsed until the run is expanded', () => {
@@ -415,28 +422,77 @@ describe('NativeChatToolRun', () => {
     expect(screen.queryByText('hello')).toBeNull()
   })
 
-  it('replaces the live row with a compact result when the active call settles', () => {
-    const runningBlocks: NativeChatBlock[] = [
+  // The reported defect: the header was two elements, one per state, chosen by
+  // whether a call was mid-flight. Every call start and end remounted it, the
+  // count vanished while a call ran, and a call that finished inside a frame
+  // still bought the whole swap. Live is the turn's state, and the header is one
+  // element from the first call to the turn's end.
+  it('keeps one header element from a call starting until its turn ends', () => {
+    const running: NativeChatBlock[] = [
       { type: 'tool-call', name: 'shell', input: { command: 'sleep 1' }, state: 'running' }
     ]
+    const settled: NativeChatBlock[] = [
+      { type: 'tool-call', name: 'shell', input: { command: 'sleep 1' }, state: 'completed' },
+      { type: 'tool-result', output: 'done' }
+    ]
     const { rerender, container } = render(
-      <NativeChatToolRun blocks={runningBlocks} expandSignal={false} />
+      <NativeChatToolRun blocks={running} expandSignal={false} activeTurnIsWorking />
     )
+    const header = runHeader(container)
+    expect(header).toHaveAttribute('data-native-chat-tool-run-state', 'live')
+    expect(header).toHaveTextContent('Running 1 command')
+    expect(header).toHaveTextContent('sleep 1')
 
-    expect(screen.getByText('Running sleep 1')).toBeInTheDocument()
+    // The call settles; the turn has not. Same element, same words, no mark.
+    rerender(<NativeChatToolRun blocks={settled} expandSignal={false} activeTurnIsWorking />)
+    expect(runHeader(container)).toBe(header)
+    expect(header).toHaveAttribute('data-native-chat-tool-run-state', 'live')
+    expect(header).toHaveTextContent('Running 1 command')
+    expect(header.querySelector('.lucide-check')).toBeNull()
 
-    rerender(
+    // The next call starts: still the same element, now counting it.
+    const next: NativeChatBlock[] = [
+      ...settled,
+      { type: 'tool-call', name: 'shell', input: { command: 'sleep 2' }, state: 'running' }
+    ]
+    rerender(<NativeChatToolRun blocks={next} expandSignal={false} activeTurnIsWorking />)
+    expect(runHeader(container)).toBe(header)
+    expect(header).toHaveTextContent('Running 2 commands')
+    expect(header).toHaveTextContent('sleep 2')
+
+    // The turn ends: the same element settles in place.
+    const done: NativeChatBlock[] = [
+      ...settled,
+      { type: 'tool-call', name: 'shell', input: { command: 'sleep 2' }, state: 'completed' },
+      { type: 'tool-result', output: 'done' }
+    ]
+    rerender(<NativeChatToolRun blocks={done} expandSignal={false} activeTurnIsWorking={false} />)
+    expect(runHeader(container)).toBe(header)
+    expect(header).toHaveAttribute('data-native-chat-tool-run-state', 'settled')
+    expect(header).toHaveTextContent('Ran 2 commands')
+    expect(header).not.toHaveTextContent('Running')
+    expect(header.querySelector('.lucide-check')).toBeInTheDocument()
+    expect(header.querySelector('.animate-pulse')).toBeNull()
+  })
+
+  it('settles a run the agent has moved past even while its last call still reports', () => {
+    const { container } = render(
       <NativeChatToolRun
         blocks={[
-          { type: 'tool-call', name: 'shell', input: { command: 'sleep 1' }, state: 'completed' },
-          { type: 'tool-result', output: 'done' }
+          { type: 'tool-call', name: 'shell', input: { command: 'sleep 1' }, state: 'running' }
         ]}
         expandSignal={false}
+        activeTurnIsWorking
+        trailing={false}
       />
     )
 
-    expect(screen.queryByText('Running sleep 1')).toBeNull()
-    expect(runHeader(container)).toHaveTextContent('sleep 1')
+    const header = runHeader(container)
+    expect(header).toHaveAttribute('data-native-chat-tool-run-state', 'settled')
+    expect(header).not.toHaveTextContent('Running')
+    expect(header.querySelector('.animate-pulse')).toBeNull()
+    // Still not a stated success: the call has not finished.
+    expect(header.querySelector('.lucide-check')).toBeNull()
   })
 
   it('never animates a settled tool row with its completion check', () => {
@@ -447,13 +503,15 @@ describe('NativeChatToolRun', () => {
           { type: 'tool-result', output: 'passed' }
         ]}
         expandSignal={false}
-        activeTurnIsWorking
+        activeTurnIsWorking={false}
       />
     )
 
     const settledRow = runHeader(container)
     expect(settledRow).toHaveTextContent('pnpm test')
     expect(settledRow.querySelector('.lucide-check')).toBeInTheDocument()
+    // Windowing remounts settled rows on scroll; a mark that faded in would replay.
+    expect(settledRow.querySelector('.lucide-check')).not.toHaveClass('animate-in')
     expect(settledRow.querySelector('.animate-pulse')).toBeNull()
     expect(container.querySelector('.animate-pulse')).toBeNull()
   })
@@ -789,18 +847,22 @@ describe('NativeChatToolRun', () => {
       expect(leadingGlyphs(container)).toEqual(['lucide-check', 'lucide-chevron-right'])
     })
 
-    it('keeps naming the active call while the run is still running', () => {
+    it('holds the run glyph across live and settled', () => {
       const blocks: NativeChatBlock[] = [
         call('read', { command: "sed -n '1,50p' a.ts", path: 'a.ts' }),
         { type: 'tool-call', name: 'shell', input: { command: 'npm test' }, state: 'running' }
       ]
 
-      const { container } = render(
+      const { container, rerender } = render(
         <NativeChatToolRun blocks={blocks} expandSignal activeTurnIsWorking />
       )
 
-      // The running header names one call, so its glyph is that call's.
-      expect(leadingGlyphs(container)[0]).toBe('lucide-square-terminal')
+      // The header speaks for the whole run in both states, so its glyph is the
+      // run's, never the latest call's — a glyph that swapped as calls came and
+      // went read as a change of identity.
+      expect(leadingGlyphs(container)[0]).toBe('lucide-wrench')
+      rerender(<NativeChatToolRun blocks={blocks} expandSignal activeTurnIsWorking={false} />)
+      expect(leadingGlyphs(container)[0]).toBe('lucide-wrench')
     })
   })
 
diff --git a/src/renderer/src/components/native-chat/NativeChatToolRun.tsx b/src/renderer/src/components/native-chat/NativeChatToolRun.tsx
index 7a050148064..bb8d9f96302 100644
--- a/src/renderer/src/components/native-chat/NativeChatToolRun.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatToolRun.tsx
@@ -23,6 +23,7 @@ import {
   pairNativeChatToolResults
 } from '../../../../shared/native-chat-tool-pairing'
 import {
+  describeLatestToolCall,
   NATIVE_CHAT_TOOL_ACTIVITY_COPY,
   selectActiveToolCall
 } from '../../../../shared/native-chat-tool-activity'
@@ -37,8 +38,7 @@ import { NativeChatTaskList } from './NativeChatTaskList'
 import { buildNativeChatTaskListRows } from './native-chat-task-list-history'
 import { NativeChatBackgroundTaskRun } from './NativeChatBackgroundTaskRun'
 import { NativeChatSubagentRun } from './NativeChatSubagentRun'
-import { NativeChatToolIcon, NativeChatToolRunIcon } from './NativeChatToolIcon'
-import { nativeChatToolActivityLabel } from './native-chat-tool-activity-label'
+import { NativeChatToolRunIcon } from './NativeChatToolIcon'
 
 /** Stable empty default: a fresh array literal per render breaks memoization. */
 const NO_SUBAGENT_GROUPS: NativeChatSubagentGroupBlock[] = []
@@ -56,6 +56,7 @@ export function NativeChatToolRun({
   backgroundTasks = NO_BACKGROUND_TASKS,
   expandSignal,
   activeTurnIsWorking,
+  trailing,
   expandOverride,
   structuredActivityUi = true,
   disclosureId,
@@ -76,6 +77,10 @@ export function NativeChatToolRun({
   expandOverride?: boolean
   /** Structured lifecycle state, when available, keeps orphaned running calls from spinning. */
   activeTurnIsWorking?: boolean
+  /** Whether this run is the working turn's last. Only that run is live: a run
+   *  the agent has already moved past reads as settled even mid-call. Left
+   *  unset, a working turn's run is taken to be its last. */
+  trailing?: boolean
   structuredActivityUi?: boolean
   /** Message this run belongs to. Windowing unmounts rows, so a run the reader
    *  opened has to be remembered somewhere that outlives the row. */
@@ -117,14 +122,25 @@ export function NativeChatToolRun({
   const askSubject = hasAskCall ? nativeChatAskRunSubject(asks) : null
   const showsHeader = !hasAskCall || countToolCalls(headerBlocks) > 0
   const callCount = countToolCalls(headerBlocks) || headerBlocks.length
+  const askIsActive = selectActiveToolCall(unansweredAsks, { activeTurnIsWorking }) !== null
+  // Live is the turn's state, not a call's. Deriving it from "some call is
+  // running" flipped the header to settled and back around every call, and a
+  // call that finished inside a frame still bought the whole flip. The turn's
+  // trailing run stays live from its first call until the agent moves on; a
+  // caller with no turn state, or a turn blocked on the reader's answer, falls
+  // back to the calls themselves.
+  const live =
+    structuredActivityUi &&
+    (activeTurnIsWorking === true && !askIsActive
+      ? trailing !== false
+      : selectActiveToolCall(headerBlocks, { activeTurnIsWorking }) !== null)
   // One sentence for the whole run, or the command itself when the run is one
   // call — the reader recognizes `git push` faster than "Ran 1 command".
-  const runSentence = nativeChatToolRunSentence(headerBlocks)
-  const headerActiveCall = structuredActivityUi
-    ? selectActiveToolCall(headerBlocks, { activeTurnIsWorking })
-    : null
-  const isSettled = headerActiveCall == null
-  const askIsActive = selectActiveToolCall(unansweredAsks, { activeTurnIsWorking }) !== null
+  const runSentence = nativeChatToolRunSentence(headerBlocks, { live })
+  // What the run is doing now, beside the sentence: the latest call, running or
+  // not, so a call that finished in a frame still leaves its name until the next.
+  const latestCall = live ? headerBlocks.findLast(isToolCallBlock) : undefined
+  const latestCallLabel = latestCall ? describeLatestToolCall(latestCall) : null
   const { succeeded: runSucceeded, failedCallCount } = nativeChatToolRunOutcome(headerBlocks, {
     activeTurnIsWorking
   })
@@ -186,7 +202,7 @@ export function NativeChatToolRun({
     structuredActivityUi &&
     expandOverride === false &&
     !(revealedDiff && open) &&
-    isSettled &&
+    !live &&
     activeTurnIsWorking === false
   ) {
     // The roster is not tool activity, so it survives this guard exactly as it
@@ -203,37 +219,33 @@ export function NativeChatToolRun({
       {hasAskCall ? (
         <NativeChatAwaitingInputRow subject={askSubject} pending={askIsActive} />
       ) : null}
-      {!showsHeader ? null : headerActiveCall ? (
+      {!showsHeader ? null : (
+        // One element for the run's whole life. Live and settled are states of
+        // this button, not two buttons: a header that remounted as a call started
+        // and again as it ended lost its hover, its mark, and its count each time.
         <button
           type="button"
           onClick={() => setOpen(!open)}
-          className="group/tool-run flex min-h-6 w-full items-center gap-1.5 rounded-md py-0.5 text-left text-sm leading-relaxed text-muted-foreground hover:bg-accent/20 focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-inset focus-visible:ring-ring/70"
+          className="group/tool-run flex min-h-6 w-full items-center gap-1.5 rounded-md py-0.5 text-left focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-inset focus-visible:ring-ring/70"
           aria-expanded={open}
           aria-live="polite"
-        >
-          <NativeChatToolIcon
-            mcpIdentity={headerActiveCall.mcpIdentity}
-            rowWord={headerActiveCall.name}
-            className="text-muted-foreground"
-          />
-          <span className="min-w-0 animate-pulse truncate text-foreground/85 motion-reduce:animate-none">
-            {nativeChatToolActivityLabel(headerActiveCall)}
-          </span>
-          {open ? <ChevronRight className="size-3.5 rotate-90 text-muted-foreground" /> : null}
-        </button>
-      ) : (
-        <button
-          type="button"
-          onClick={() => setOpen(!open)}
-          className="group/tool-run flex min-h-6 w-full items-center gap-1.5 py-0.5 text-left"
-          aria-expanded={open}
+          data-native-chat-tool-run-state={live ? 'live' : 'settled'}
         >
           {structuredActivityUi && settledHeaderIcon ? (
             <NativeChatToolRunIcon iconName={settledHeaderIcon} className="text-muted-foreground" />
           ) : null}
-          {/* The run in words, in the transcript's own type. The calls it counts
-              are one click away, so the header does not have to list them. */}
-          <span className="min-w-0 truncate text-sm leading-relaxed text-muted-foreground transition-colors group-hover/tool-run:text-foreground/80">
+          {/* The run in words, in the transcript's own type. Present tense while
+              live, past once settled; the text changes in place and nothing
+              around it moves. While live it keeps its width and the preview
+              beside it is what gives way. */}
+          <span
+            className={cn(
+              'truncate text-sm leading-relaxed transition-colors',
+              live
+                ? 'max-w-[72%] shrink-0 animate-pulse text-foreground/85 motion-reduce:animate-none'
+                : 'min-w-0 text-muted-foreground group-hover/tool-run:text-foreground/80'
+            )}
+          >
             {runSentence ?? fallbackLabel}
           </span>
           {failedCallCount > 0 ? (
@@ -257,10 +269,17 @@ export function NativeChatToolRun({
               )}
             </span>
           ) : null}
-          {/* Only a stated success is marked done — see nativeChatToolRunOutcome. */}
-          {structuredActivityUi && runSucceeded ? (
+          {/* Only a stated success is marked done — see nativeChatToolRunOutcome —
+              and never while live: between two calls nothing is running, and a
+              mark that appeared then would flash on every call. */}
+          {structuredActivityUi && !live && runSucceeded ? (
             <Check aria-hidden className="size-3 shrink-0 text-muted-foreground" />
           ) : null}
+          {latestCallLabel ? (
+            <span className="min-w-0 truncate font-mono text-[11px] text-muted-foreground">
+              {latestCallLabel}
+            </span>
+          ) : null}
           {/* Revealed on hover of this header alone — see NativeChatToolLine on
               why the group is named — and points down when open. */}
           <ChevronRight
diff --git a/src/renderer/src/components/native-chat/NativeChatTranscriptRow.tsx b/src/renderer/src/components/native-chat/NativeChatTranscriptRow.tsx
index c07e568734f..266f528ebfd 100644
--- a/src/renderer/src/components/native-chat/NativeChatTranscriptRow.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatTranscriptRow.tsx
@@ -56,6 +56,7 @@ export const NativeChatTranscriptRow = memo(function NativeChatTranscriptRow({
           }
           expandSignal={context.expandSignal}
           activeTurnIsWorking={slot.activeTurnIsWorking}
+          trailingRun={slot.trailingRun}
           onScrollMessageToTop={context.onScrollMessageToTop}
           onLinkClick={context.onLinkClick}
           allowFileUriLinks={context.allowFileUriLinks}
diff --git a/src/renderer/src/components/native-chat/native-chat-tool-activity-label.ts b/src/renderer/src/components/native-chat/native-chat-tool-activity-label.ts
deleted file mode 100644
index 2d1f21c22be..00000000000
--- a/src/renderer/src/components/native-chat/native-chat-tool-activity-label.ts
+++ /dev/null
@@ -1,20 +0,0 @@
-import { translate } from '@/i18n/i18n'
-import {
-  describeActiveToolCall,
-  NATIVE_CHAT_TOOL_ACTIVITY_COPY
-} from '../../../../shared/native-chat-tool-activity'
-import type { NativeChatBlock } from '../../../../shared/native-chat-types'
-
-type ToolCall = Extract<NativeChatBlock, { type: 'tool-call' }>
-
-export function nativeChatToolActivityLabel(call: ToolCall): string {
-  const { key, toolName, preview } = describeActiveToolCall(call)
-  const copy = NATIVE_CHAT_TOOL_ACTIVITY_COPY[key]
-  return key === 'runningPreview'
-    ? translate('components.native-chat.tool.runningPreview', copy, { preview })
-    : key === 'runningCommand'
-      ? translate('components.native-chat.tool.runningCommand', copy)
-      : key === 'runningNamedPreview'
-        ? translate('components.native-chat.tool.runningNamedPreview', copy, { toolName, preview })
-        : translate('components.native-chat.tool.runningNamed', copy, { toolName })
-}
diff --git a/src/renderer/src/components/native-chat/native-chat-tool-run-label.ts b/src/renderer/src/components/native-chat/native-chat-tool-run-label.ts
index bedcc7239e0..3c47b2df96b 100644
--- a/src/renderer/src/components/native-chat/native-chat-tool-run-label.ts
+++ b/src/renderer/src/components/native-chat/native-chat-tool-run-label.ts
@@ -15,9 +15,12 @@ import { toolInputCommand } from '../../../../shared/native-chat-tool-summary'
  *  sentence would stay English in every locale while the row above it translated.
  *  `native-chat-shared-copy-matches-catalog` pins these against the record mobile
  *  renders from, which is what keeps the duplication honest. */
-function clause(category: NativeChatToolCategory, count: number): string {
+function clause(category: NativeChatToolCategory, count: number, live: boolean): string {
   const one = count === 1
   const value0 = { value0: count }
+  if (live) {
+    return liveClause(category, one, value0)
+  }
   switch (category) {
     case 'read':
       return one
@@ -86,8 +89,99 @@ function clause(category: NativeChatToolCategory, count: number): string {
   }
 }
 
-/** The one line a settled run reads as, localized. */
-export function nativeChatToolRunSentence(blocks: readonly NativeChatBlock[]): string | null {
+/** The present-tense clause, while the run is still live. Same shape as the
+ *  settled one so the header's text changes in place and nothing else does. */
+function liveClause(
+  category: NativeChatToolCategory,
+  one: boolean,
+  value0: { value0: number }
+): string {
+  switch (category) {
+    case 'read':
+      return one
+        ? translate('components.native-chat.tool.runLiveReadOne', 'Reading 1 file')
+        : translate(
+            'components.native-chat.tool.runLiveReadMany',
+            'Reading {{value0}} files',
+            value0
+          )
+    case 'search':
+      return one
+        ? translate('components.native-chat.tool.runLiveSearchOne', 'Searching 1 time')
+        : translate(
+            'components.native-chat.tool.runLiveSearchMany',
+            'Searching {{value0}} times',
+            value0
+          )
+    case 'listFiles':
+      return one
+        ? translate('components.native-chat.tool.runLiveListFilesOne', 'Listing 1 directory')
+        : translate(
+            'components.native-chat.tool.runLiveListFilesMany',
+            'Listing {{value0}} directories',
+            value0
+          )
+    case 'unknown':
+      return one
+        ? translate('components.native-chat.tool.runLiveCommandOne', 'Running 1 command')
+        : translate(
+            'components.native-chat.tool.runLiveCommandMany',
+            'Running {{value0}} commands',
+            value0
+          )
+    case 'fileChange':
+      return one
+        ? translate('components.native-chat.tool.runLiveFileChangeOne', 'Editing 1 file')
+        : translate(
+            'components.native-chat.tool.runLiveFileChangeMany',
+            'Editing {{value0}} files',
+            value0
+          )
+    case 'webSearch':
+      return one
+        ? translate('components.native-chat.tool.runLiveWebSearchOne', 'Searching the web 1 time')
+        : translate(
+            'components.native-chat.tool.runLiveWebSearchMany',
+            'Searching the web {{value0}} times',
+            value0
+          )
+    case 'mcpToolCall':
+      return one
+        ? translate('components.native-chat.tool.runLiveIntegrationOne', 'Using 1 integration')
+        : translate(
+            'components.native-chat.tool.runLiveIntegrationMany',
+            'Using {{value0}} integrations',
+            value0
+          )
+    case 'subAgentActivity':
+      return one
+        ? translate('components.native-chat.tool.runLiveAgentOne', 'Running 1 agent')
+        : translate(
+            'components.native-chat.tool.runLiveAgentMany',
+            'Running {{value0}} agents',
+            value0
+          )
+    case 'todoList':
+      return one
+        ? translate('components.native-chat.tool.runLivePlanOne', 'Updating the plan')
+        : translate(
+            'components.native-chat.tool.runLivePlanMany',
+            'Updating the plan {{value0}} times',
+            value0
+          )
+    case 'other':
+      return one
+        ? translate('components.native-chat.tool.runLiveToolOne', 'Using 1 tool')
+        : translate('components.native-chat.tool.runLiveToolMany', 'Using {{value0}} tools', value0)
+  }
+}
+
+/** The one line a run reads as, localized: past tense once settled, present
+ *  while live. */
+export function nativeChatToolRunSentence(
+  blocks: readonly NativeChatBlock[],
+  { live = false }: { live?: boolean } = {}
+): string | null {
   const calls = blocks.filter(isToolCallBlock)
   if (calls.length === 0) {
     return null
@@ -95,14 +189,17 @@ export function nativeChatToolRunSentence(blocks: readonly NativeChatBlock[]): s
   // A lone shell call keeps its own command: `git push` identifies the work
   // better than "Ran 1 command" can, and it is the row the reader would open
   // anyway. A call carrying no command has nothing better than its category.
-  if (calls.length === 1) {
+  // Not while live: the command is then the preview beside the sentence, and a
+  // header that swapped shape when the second call arrived is the swap this row
+  // exists to avoid.
+  if (calls.length === 1 && !live) {
     const command = toolInputCommand(calls[0].input)
     if (command !== null && command.length > 0) {
       return command
     }
   }
   return joinNativeChatToolRunClauses(
-    nativeChatToolRunClauses(calls).map(({ category, count }) => clause(category, count)),
+    nativeChatToolRunClauses(calls).map(({ category, count }) => clause(category, count, live)),
     {
       pair: (first, second) =>
         translate('components.native-chat.tool.runPair', '{{value0}} and {{value1}}', {
diff --git a/src/renderer/src/components/native-chat/native-chat-transcript-slots.test.ts b/src/renderer/src/components/native-chat/native-chat-transcript-slots.test.ts
index 1f74079b4e5..7c665ab6804 100644
--- a/src/renderer/src/components/native-chat/native-chat-transcript-slots.test.ts
+++ b/src/renderer/src/components/native-chat/native-chat-transcript-slots.test.ts
@@ -47,7 +47,57 @@ function build(
   })
 }
 
+function toolRun(id: string): NativeChatMessage {
+  return {
+    id,
+    role: 'assistant',
+    blocks: [{ type: 'tool-call', name: 'shell', input: { command: 'ls' }, state: 'completed' }],
+    timestamp: 1,
+    source: 'transcript'
+  }
+}
+
 describe('transcript slots', () => {
+  // The trailing run is the one still live while the turn works. Prose or a
+  // further run after it settles it; a reasoning aside leaves it live.
+  it('marks the last row that speaks or acts as the trailing run', () => {
+    const trailing = (messages: NativeChatMessage[]) =>
+      build(messages)
+        .filter((slot) => slot.trailingRun)
+        .map((slot) => slot.message.id)
+
+    expect(trailing([text('u', 'go', 'user'), toolRun('a'), text('b', 'Done.')])).toEqual(['b'])
+    expect(trailing([text('u', 'go', 'user'), toolRun('a'), toolRun('b')])).toEqual(['b'])
+    expect(
+      trailing([text('u', 'go', 'user'), toolRun('a'), text('r', 'hmm', 'reasoning')])
+    ).toEqual(['a'])
+    expect(trailing([toolRun('a'), text('u', 'again', 'user')])).toEqual(['a'])
+  })
+
+  // Approving a call lets that call run, and it sits in the run above the
+  // receipt. A question's receipt blocks the agent on the reader, so it does not.
+  it('keeps the run above an approval receipt trailing, but not above a question', () => {
+    const resolution = {
+      state: 'resolved' as const,
+      selectedOptionId: 'yes',
+      resolvedBy: 'desktop',
+      resolvedAt: 1
+    }
+    const receipts = new Map<string, NativeChatResolvedPrompt>([
+      ['approval', { kind: 'approval', title: 'Run?', detail: 'ls', options: [], resolution }],
+      ['question', { kind: 'question', question: 'Which?', options: [], resolution }]
+    ])
+    const trailing = (receiptId: string) =>
+      build([text('u', 'go', 'user'), toolRun('a'), text(receiptId, 'Run?', 'system')], {
+        receipts
+      })
+        .filter((slot) => slot.trailingRun)
+        .map((slot) => slot.message.id)
+
+    expect(trailing('approval')).toEqual(['a'])
+    expect(trailing('question')).toEqual(['question'])
+  })
+
   // A counted row that draws nothing is a gap in the transcript: it reserves
   // estimated height for a bubble that never appears.
   it('gives no slot to a message with nothing to draw', () => {
diff --git a/src/renderer/src/components/native-chat/native-chat-transcript-slots.ts b/src/renderer/src/components/native-chat/native-chat-transcript-slots.ts
index 4b485990eb0..2fd8d39ae79 100644
--- a/src/renderer/src/components/native-chat/native-chat-transcript-slots.ts
+++ b/src/renderer/src/components/native-chat/native-chat-transcript-slots.ts
@@ -10,6 +10,7 @@
 import {
   isBackgroundTaskBlock,
   isSubagentGroupBlock,
+  isToolCallBlock,
   type NativeChatMessage
 } from '../../../../shared/native-chat-types'
 import type { NativeChatTurnStatus } from '../../../../shared/native-chat-turn-status'
@@ -30,6 +31,10 @@ export type NativeChatTranscriptSlot = {
   turnKey: string | undefined
   /** The row's own turn is the one still running, so its tools stay live. */
   activeTurnIsWorking: boolean
+  /** Nothing the agent said or did comes after this row, so its tool run is
+   *  the one still live while the turn works. A later run or answer settles it;
+   *  a reasoning aside does not, the agent is still inside the same batch. */
+  trailingRun: boolean
   /** Resolved approval/question stands in for the message it answered. */
   receipt: NativeChatResolvedPrompt | undefined
   /** Turn timing shown under this row, already filtered to "should render". */
@@ -94,6 +99,17 @@ export function buildNativeChatTranscriptSlots(
       )
     }
   })
+  // Liveness is the turn's, not any one call's: the run at the frontier stays
+  // live between its calls, and a run the agent has moved past is settled even
+  // while its last call is still reporting. An approval's receipt decides a call
+  // of the run above it, which then runs, so it does not move past that run.
+  const trailingRunIndex = foldRows.findLastIndex(
+    (row, index) =>
+      row.role !== 'user' &&
+      row.role !== 'reasoning' &&
+      receipts.get(messages[index].id)?.kind !== 'approval' &&
+      (row.rendersProse || messages[index].blocks.some(isToolCallBlock))
+  )
   const settledTurnKeys = new Set(
     showTurnStatus
       ? Object.entries(turnStatuses.completedByTurn)
@@ -134,6 +150,7 @@ export function buildNativeChatTranscriptSlots(
       activeTurnIsWorking:
         (currentTurnKey ? turnKey === currentTurnKey : turnKey === undefined) &&
         (isWorking || lifecycleWorking),
+      trailingRun: index === trailingRunIndex,
       receipt,
       status: status ?? undefined,
       folded,
diff --git a/src/renderer/src/components/native-chat/use-native-chat-transcript-window.options.test.tsx b/src/renderer/src/components/native-chat/use-native-chat-transcript-window.options.test.tsx
index 571187fff51..823f78af6ed 100644
--- a/src/renderer/src/components/native-chat/use-native-chat-transcript-window.options.test.tsx
+++ b/src/renderer/src/components/native-chat/use-native-chat-transcript-window.options.test.tsx
@@ -52,6 +52,7 @@ function slot(id: string): NativeChatTranscriptSlot {
     },
     turnKey: undefined,
     activeTurnIsWorking: false,
+    trailingRun: false,
     receipt: undefined,
     status: undefined,
     folded: false,
diff --git a/src/renderer/src/i18n/locales/en.json b/src/renderer/src/i18n/locales/en.json
index e013a1cfce6..79730cba488 100644
--- a/src/renderer/src/i18n/locales/en.json
+++ b/src/renderer/src/i18n/locales/en.json
@@ -17399,7 +17399,27 @@
         "runToolOne": "Used 1 tool",
         "runToolMany": "Used {{value0}} tools",
         "runPair": "{{value0}} and {{value1}}",
-        "runList": "{{value0}}, and {{value1}}"
+        "runList": "{{value0}}, and {{value1}}",
+        "runLiveReadOne": "Reading 1 file",
+        "runLiveReadMany": "Reading {{value0}} files",
+        "runLiveSearchOne": "Searching 1 time",
+        "runLiveSearchMany": "Searching {{value0}} times",
+        "runLiveListFilesOne": "Listing 1 directory",
+        "runLiveListFilesMany": "Listing {{value0}} directories",
+        "runLiveCommandOne": "Running 1 command",
+        "runLiveCommandMany": "Running {{value0}} commands",
+        "runLiveFileChangeOne": "Editing 1 file",
+        "runLiveFileChangeMany": "Editing {{value0}} files",
+        "runLiveWebSearchOne": "Searching the web 1 time",
+        "runLiveWebSearchMany": "Searching the web {{value0}} times",
+        "runLiveIntegrationOne": "Using 1 integration",
+        "runLiveIntegrationMany": "Using {{value0}} integrations",
+        "runLiveAgentOne": "Running 1 agent",
+        "runLiveAgentMany": "Running {{value0}} agents",
+        "runLivePlanOne": "Updating the plan",
+        "runLivePlanMany": "Updating the plan {{value0}} times",
+        "runLiveToolOne": "Using 1 tool",
+        "runLiveToolMany": "Using {{value0}} tools"
       },
       "providerFrame": {
         "byteLength": "{{value0}} bytes"
diff --git a/src/shared/native-chat-tool-activity.ts b/src/shared/native-chat-tool-activity.ts
index 14887ea28c4..c873084a2d3 100644
--- a/src/shared/native-chat-tool-activity.ts
+++ b/src/shared/native-chat-tool-activity.ts
@@ -1,6 +1,6 @@
-// Live tool-activity derivation and copy for the native-chat "Running …" row,
-// shared by the desktop renderer (as its i18n fallback strings) and the mobile
-// app (used directly — mobile ships English only) so the two surfaces never drift.
+// Live tool-activity derivation and copy for native chat's tool runs. Mobile's
+// "Running …" row renders this copy directly (it ships English only); desktop
+// uses the count and failure strings as i18n fallbacks, so the two never drift.
 
 import { createToolInputDisplay } from './native-chat-tool-summary'
 import { isToolCallBlock, type NativeChatBlock } from './native-chat-types'
@@ -72,6 +72,17 @@ export function formatActiveToolLabel(descriptor: NativeChatActiveToolDescriptor
     .replaceAll('{{toolName}}', descriptor.toolName)
 }
 
+/** What a live run names beside its sentence: the command itself, or the tool's
+ *  word and argument. Tense-free on purpose — the sentence carries the state, so
+ *  this never claims a call that just finished is still running. */
+export function describeLatestToolCall(call: NativeChatToolCallBlock): string {
+  const { toolName, preview, isCommand } = describeActiveToolCall(call)
+  if (isCommand) {
+    return preview || toolName
+  }
+  return preview ? `${toolName} ${preview}` : toolName
+}
+
 /** The most recent still-running call in a run, or null once the run is settled.
  *  A block without lifecycle `state` only counts while the turn is known to be
  *  working, so a restored transcript never spins on an orphaned call. */