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. */