diff --git a/apps/web/src/i18n/locales/en.json b/apps/web/src/i18n/locales/en.json
index 2d9554e09..44896f1a4 100644
--- a/apps/web/src/i18n/locales/en.json
+++ b/apps/web/src/i18n/locales/en.json
@@ -666,6 +666,29 @@
       "thought": "Thought",
       "thoughtBriefly": "Thought for a couple of seconds",
       "thoughtSeconds": "Thought for {seconds}s",
+      "phase": {
+        "browse": { "ing": "Exploring", "done": "Explored" },
+        "edit": { "ing": "Editing", "done": "Edited" },
+        "run": { "ing": "Running", "done": "Ran" },
+        "message": { "ing": "Messaging", "done": "Sent" },
+        "schedule": { "ing": "Scheduling", "done": "Scheduled" },
+        "media": { "ing": "Generating", "done": "Generated" },
+        "agent": { "ing": "Delegating", "done": "Delegated" },
+        "gui": { "ing": "Browsing", "done": "Browsed" },
+        "other": { "ing": "Working", "done": "Worked" }
+      },
+      "frag": {
+        "fileOperations": "{count} file operation | {count} file operations",
+        "searches": "{count} searches",
+        "commands": "{count} commands",
+        "messages": "{count} messages",
+        "schedules": "{count} schedules",
+        "media": "{count} media files",
+        "agents": "{count} agents",
+        "steps": "{count} step | {count} steps",
+        "sites": "{count} sites"
+      },
+      "fragmentSeparator": ", ",
       "thinkingHints": [
         "Connecting the dots",
         "Piecing it together",
diff --git a/apps/web/src/i18n/locales/ja.json b/apps/web/src/i18n/locales/ja.json
index f6b437260..cb6245baa 100644
--- a/apps/web/src/i18n/locales/ja.json
+++ b/apps/web/src/i18n/locales/ja.json
@@ -649,7 +649,30 @@
       "steps": "{count} ステップ",
       "thought": "考え",
       "thoughtBriefly": "少し考えた",
-      "thoughtSeconds": "{seconds}秒考えました"
+      "thoughtSeconds": "{seconds}秒考えました",
+      "phase": {
+        "browse": { "ing": "探索中", "done": "探索しました" },
+        "edit": { "ing": "編集中", "done": "編集しました" },
+        "run": { "ing": "実行中", "done": "実行しました" },
+        "message": { "ing": "送信中", "done": "送信しました" },
+        "schedule": { "ing": "変更中", "done": "変更しました" },
+        "media": { "ing": "生成中", "done": "生成しました" },
+        "agent": { "ing": "委譲中", "done": "委譲しました" },
+        "gui": { "ing": "閲覧中", "done": "閲覧しました" },
+        "other": { "ing": "作業中", "done": "作業しました" }
+      },
+      "frag": {
+        "fileOperations": "ファイル操作 {count} 件",
+        "searches": "{count} 件の検索",
+        "commands": "{count} コマンド",
+        "messages": "{count} 件のメッセージ",
+        "schedules": "{count} 件のスケジュール",
+        "media": "{count} 個のメディアファイル",
+        "agents": "{count} のAgent",
+        "steps": "{count} ステップ",
+        "sites": "{count} 件のサイト"
+      },
+      "fragmentSeparator": "、"
     },
     "currentBot": "現在のBot",
     "inputPlaceholder": "質問を入力してください…",
diff --git a/apps/web/src/i18n/locales/zh.json b/apps/web/src/i18n/locales/zh.json
index 73c2fca8e..c36498e5b 100644
--- a/apps/web/src/i18n/locales/zh.json
+++ b/apps/web/src/i18n/locales/zh.json
@@ -666,6 +666,29 @@
       "thought": "已思考",
       "thoughtBriefly": "思考了几秒",
       "thoughtSeconds": "已思考 {seconds} 秒",
+      "phase": {
+        "browse": { "ing": "探索中", "done": "已探索" },
+        "edit": { "ing": "修改中", "done": "已修改" },
+        "run": { "ing": "运行中", "done": "已运行" },
+        "message": { "ing": "发送中", "done": "已发送" },
+        "schedule": { "ing": "调整中", "done": "已调整" },
+        "media": { "ing": "生成中", "done": "已生成" },
+        "agent": { "ing": "委派中", "done": "已委派" },
+        "gui": { "ing": "浏览中", "done": "已浏览" },
+        "other": { "ing": "处理中", "done": "已处理" }
+      },
+      "frag": {
+        "fileOperations": "{count} 次文件操作",
+        "searches": "{count} 次搜索",
+        "commands": "{count} 条命令",
+        "messages": "{count} 条消息",
+        "schedules": "{count} 个定时任务",
+        "media": "{count} 个媒体文件",
+        "agents": "{count} 个 Agent",
+        "steps": "{count} 步",
+        "sites": "{count} 个网站"
+      },
+      "fragmentSeparator": "、",
       "thinkingHints": [
         "正在连接线索",
         "正在拼合信息",
diff --git a/apps/web/src/pages/home/components/tool-call-group.test.ts b/apps/web/src/pages/home/components/tool-call-group.test.ts
index 27ae39afd..a9f925614 100644
--- a/apps/web/src/pages/home/components/tool-call-group.test.ts
+++ b/apps/web/src/pages/home/components/tool-call-group.test.ts
@@ -1,6 +1,6 @@
 // @vitest-environment jsdom
 
-import { createApp, defineComponent, h } from 'vue'
+import { createApp, defineComponent, h, nextTick } from 'vue'
 import { createI18n } from 'vue-i18n'
 import { afterEach, describe, expect, it, vi } from 'vitest'
 import type { ContentBlock, ThinkingBlock as ThinkingBlockType, ToolCallBlock as ToolCallBlockType } from '@/store/chat-list'
@@ -14,10 +14,20 @@ vi.mock('@/i18n', () => ({
 }))
 import ToolCallGroup from './tool-call-group.vue'
 
-// Pins the ghost-"Thinking…" fix: the collapsed header is a live ticker only
-// while the turn streams (`active`). A background task that outlives the turn
-// must not pin the ticker — its `running` block used to keep the header saying
-// "Thinking…" indefinitely on a finished turn (issue #1106).
+// Two contracts pinned here:
+//
+// 1. Ghost-"Thinking…" fix (issue #1106): the collapsed header is a live
+//    two-layer summary only while the turn streams (`active`). A background
+//    task that outlives the turn must not pin the live header — its `running`
+//    block used to keep the header saying "Thinking…" indefinitely on a
+//    finished turn.
+//
+// 2. The two-layer adaptive header: while a segment streams, a muted phase
+//    verb ("Exploring") leads the header with live bare-count details
+//    ("2 file operations, 1 command"), and a "now" line below rolls the current
+//    call; once the segment settles, the verb turns past tense ("Explored")
+//    and diff totals appear. This guards against regressing to a bare ticker
+//    of the latest call (which hid the aggregate view until settle).
 
 interface MountedGroup {
   app: ReturnType<typeof createApp>
@@ -33,6 +43,7 @@ afterEach(() => {
   }
 })
 
+let nextBlockId = 0
 let nextMessageId = 0
 
 function mountGroup(items: ContentBlock[], active: boolean | undefined): HTMLDivElement {
@@ -50,8 +61,41 @@ function mountGroup(items: ContentBlock[], active: boolean | undefined): HTMLDiv
       en: {
         chat: {
           thinkingInProgress: 'Thinking',
-          process: { thought: 'Thought', steps: '{count} steps', run: 'Ran {count} commands' },
-          tools: { run: 'Run' },
+          process: {
+            thought: 'Thought',
+            steps: '{count} steps',
+            fragmentSeparator: ', ',
+            phase: {
+              browse: { ing: 'Exploring', done: 'Explored' },
+              edit: { ing: 'Editing', done: 'Edited' },
+              run: { ing: 'Running', done: 'Ran' },
+              message: { ing: 'Messaging', done: 'Sent' },
+              schedule: { ing: 'Scheduling', done: 'Scheduled' },
+              media: { ing: 'Generating', done: 'Generated' },
+              agent: { ing: 'Delegating', done: 'Delegated' },
+              gui: { ing: 'Browsing', done: 'Browsed' },
+              other: { ing: 'Working', done: 'Worked' },
+            },
+            frag: {
+              fileOperations: '{count} file operation | {count} file operations',
+              searches: '{count} searches',
+              commands: '{count} commands',
+              messages: '{count} messages',
+              schedules: '{count} schedules',
+              media: '{count} media files',
+              agents: '{count} agents',
+              steps: '{count} step | {count} steps',
+              sites: '{count} sites',
+            },
+          },
+          tools: {
+            run: 'Run',
+            read: 'Read',
+            exec: 'Run',
+            edit: 'Edit',
+            ask_user: 'Ask user',
+            pending: { generic: 'Working…' },
+          },
         },
       },
     },
@@ -61,13 +105,15 @@ function mountGroup(items: ContentBlock[], active: boolean | undefined): HTMLDiv
   return root
 }
 
+// The header row is the toggleable button; its whole text covers verb +
+// details + diffs.
 function headerText(root: HTMLElement): string {
-  // The header label is the span inside the toggleable header row; the capsule
-  // body holds the per-item rows, so restricting to the first button-bound
-  // region would be brittle — take the first span with the tracking class.
-  const spans = [...root.querySelectorAll('span')]
-  const header = spans.find(span => (span.textContent ?? '').length > 0)
-  return header?.textContent ?? ''
+  const button = root.querySelector('button')
+  return button?.textContent ?? ''
+}
+
+function nowLine(root: HTMLElement): HTMLElement | null {
+  return root.querySelector('.now-line')
 }
 
 function bgExecTool(id: number, running: boolean): ToolCallBlockType {
@@ -83,25 +129,161 @@ function bgExecTool(id: number, running: boolean): ToolCallBlockType {
   } as unknown as ToolCallBlockType
 }
 
+function toolBlock(toolName: string, input: unknown, running = false): ToolCallBlockType {
+  const id = ++nextBlockId
+  return {
+    id,
+    type: 'tool',
+    name: toolName,
+    toolName,
+    input,
+    running,
+    done: !running,
+    tool_call_id: `tc-${id}`,
+    toolCallId: `tc-${id}`,
+    result: null,
+  }
+}
+
 function reasoning(id: number): ThinkingBlockType {
   return { id, type: 'reasoning', content: 'planning the tunnel' } as ThinkingBlockType
 }
 
-describe('ToolCallGroup header ticker', () => {
-  it('shows the ticker label while the turn is streaming', () => {
+describe('ToolCallGroup live header gating (#1106)', () => {
+  it('keeps the live two-layer header while the turn is streaming', () => {
     const root = mountGroup([bgExecTool(1, true), reasoning(2)], true)
-    expect(headerText(root)).toBe('Thinking')
+    // Single-tool segment: header keeps the tool's own specific label; the now
+    // line carries the model's current step. No phase verb stutter ("Running
+    // Run xray run") and no bare ticker of the latest item.
+    expect(headerText(root)).toContain('xray run')
+    expect(nowLine(root)?.textContent).toContain('Thinking')
   })
 
-  it('drops the ticker when the turn finished even if a background tool is still running', () => {
+  it('drops the live header when the turn finished even if a background tool is still running', () => {
     const root = mountGroup([bgExecTool(1, true), reasoning(2)], false)
-    // Aggregate summary, not "Thinking" — the model is done; only the spawned
-    // command is alive, and its own row reports that.
+    // Settled single-tool label, not "Thinking" — the model is done; only the
+    // spawned command is alive, and its own row reports that.
     expect(headerText(root)).not.toBe('Thinking')
+    expect(nowLine(root)).toBeNull()
   })
 
-  it('shows the aggregate summary once the turn finished and tools settled', () => {
+  it('shows the settled label once the turn finished and tools settled', () => {
     const root = mountGroup([bgExecTool(1, false), reasoning(2)], false)
     expect(headerText(root)).not.toBe('Thinking')
+    expect(nowLine(root)).toBeNull()
+  })
+})
+
+describe('ToolCallGroup adaptive header layers', () => {
+  it('names the phase and live bare counts in the header, and rolls the current call below', () => {
+    const root = mountGroup([
+      toolBlock('read', { path: 'src/auth/session.ts' }),
+      toolBlock('read', { path: 'src/auth/cookie.ts' }),
+      toolBlock('exec', { command: 'pnpm test' }, true),
+    ], true)
+
+    const header = headerText(root)
+    expect(header).toContain('Exploring')
+    expect(header).toContain('2 file operations')
+    expect(header).toContain('1 command')
+    expect(nowLine(root)?.textContent).toContain('pnpm test')
+  })
+
+  it('settles to a past-tense verb with final counts and diff totals', () => {
+    const root = mountGroup([
+      toolBlock('edit', { path: 'a.ts', old_text: 'l1\nl2\nl3', new_text: 'n1\nn2\nn3\nn4\nn5' }),
+      toolBlock('edit', { path: 'b.ts', old_text: 'l1\nl2', new_text: 'n1\nn2\nn3\nn4' }),
+    ], false)
+
+    const header = headerText(root)
+    expect(header).toContain('Edited')
+    expect(header).toContain('2 file operations')
+    expect(header).toContain('+9')
+    expect(header).toContain('-5')
+    expect(header).not.toContain('Editing')
+    expect(nowLine(root)).toBeNull()
+  })
+
+  it('keeps diff totals hidden while the segment is still streaming', () => {
+    const root = mountGroup([
+      toolBlock('edit', { path: 'a.ts', old_text: 'l1', new_text: 'n1\nn2' }),
+      toolBlock('edit', { path: 'b.ts', old_text: 'l1', new_text: 'n1\nn2' }),
+    ], true)
+
+    const header = headerText(root)
+    expect(header).toContain('Editing')
+    expect(header).not.toContain('+4')
+  })
+
+  it('describes file tool calls as operations rather than unique files', () => {
+    const root = mountGroup([
+      toolBlock('edit', { path: 'same.ts', old_text: 'a', new_text: 'b' }),
+      toolBlock('edit', { path: 'same.ts', old_text: 'b', new_text: 'c' }),
+    ], false)
+
+    const header = headerText(root)
+    expect(header).toContain('2 file operations')
+    expect(header).not.toContain('2 files')
+  })
+
+  it('localizes the fallback count for unclassified tools', () => {
+    const root = mountGroup([
+      toolBlock('write', { path: 'a.ts', content: 'a' }),
+      toolBlock('ask_user', { question: 'Continue?' }, true),
+    ], true)
+
+    const header = headerText(root)
+    expect(header).toContain('1 file operation')
+    expect(header).not.toContain('1 file operations')
+    expect(header).toContain('1 step')
+    expect(header).not.toContain('1 steps')
+    expect(header).not.toContain('chat.process.frag.steps')
+  })
+
+  it('keeps a lone live tool on its own specific label, no phase verb', () => {
+    const root = mountGroup([
+      toolBlock('read', { path: 'src/main.ts' }),
+      reasoning(2),
+    ], true)
+
+    const header = headerText(root)
+    expect(header).toContain('main.ts')
+    expect(header).not.toContain('Exploring')
+    expect(nowLine(root)?.textContent).toContain('Thinking')
+  })
+
+  it('keeps a lone settled tool on its own specific label, no verb', () => {
+    const root = mountGroup([
+      toolBlock('exec', { command: 'pnpm build' }),
+      reasoning(2),
+    ], false)
+
+    const header = headerText(root)
+    expect(header).toContain('pnpm build')
+    expect(header).not.toContain('Ran')
+  })
+
+  it('shows the pending label in the now line while a tool input is still streaming in', () => {
+    const root = mountGroup([
+      toolBlock('read', { path: 'a.ts' }),
+      toolBlock('read', { path: 'b.ts' }),
+      toolBlock('exec', {}, true),
+    ], true)
+
+    expect(nowLine(root)?.textContent).toContain('Working…')
+  })
+
+  it('hides the now line once the user opens the body', async () => {
+    const root = mountGroup([
+      toolBlock('read', { path: 'a.ts' }),
+      toolBlock('read', { path: 'b.ts' }),
+      toolBlock('exec', { command: 'ls' }, true),
+    ], true)
+    expect(nowLine(root)).not.toBeNull()
+
+    root.querySelector('button')?.click()
+    await nextTick()
+
+    expect(nowLine(root)).toBeNull()
   })
 })
diff --git a/apps/web/src/pages/home/components/tool-call-group.vue b/apps/web/src/pages/home/components/tool-call-group.vue
index ee0e6b89a..af90b7a84 100644
--- a/apps/web/src/pages/home/components/tool-call-group.vue
+++ b/apps/web/src/pages/home/components/tool-call-group.vue
@@ -34,16 +34,57 @@
           :connector="item"
         />
       </div>
+      <!-- Two-tone adaptive title: a muted verb names the phase ("Exploring"
+           while streaming, "Explored" once settled) followed by the darker
+           bare-count details. ONLY the verb carries the shimmer — shimmering
+           the counts too turns the whole line into uniform noise and kills the
+           contrast between "phase" and "progress". -->
+      <template v-if="verbLabel">
+        <span
+          class="shrink-0 tracking-[0.01em]"
+          :class="(active || anyToolRunning) ? 'tool-shimmer-text' : 'text-muted-foreground'"
+        >{{ verbLabel }}</span>
+        <span class="min-w-0 truncate tabular-nums">{{ detailsLabel }}</span>
+      </template>
       <span
+        v-else
         class="min-w-0 truncate tracking-[0.01em]"
         :class="anyToolRunning || active ? 'tool-shimmer-text' : ''"
       >{{ headerLabel }}</span>
+      <!-- Segment-level diff totals, revealed only once the segment settles.
+           Mid-stream the per-row diffs inside the capsule already carry that
+           signal and a second growing total here would double-render it. -->
+      <span
+        v-if="!active && diffTotals.add"
+        class="font-mono shrink-0 text-success-foreground"
+      >+{{ diffTotals.add }}</span>
+      <span
+        v-if="!active && diffTotals.remove"
+        class="font-mono shrink-0 text-destructive"
+      >-{{ diffTotals.remove }}</span>
       <ExpandChevron
         :open="open"
         class="ml-0.5"
       />
     </HeaderRow>
 
+    <!-- Second layer of the running header: the header names the phase and the
+         live tally, this line rolls the one call happening right now. Only
+         while collapsed — an open capsule's own last row already carries that
+         signal, so the line steps aside instead of double-rendering it. -->
+    <div
+      v-if="active && !open"
+      class="now-line relative h-[1lh] overflow-hidden mt-0.5 text-cop-title"
+    >
+      <Transition name="now-roll">
+        <div
+          :key="tickerLabel"
+          class="absolute inset-0 truncate"
+          v-text="tickerLabel"
+        />
+      </Transition>
+    </div>
+
     <CollapseSection :open="open">
       <!-- Card body sets the in-card type scale (one notch below the root-level
            cop rows) + tighter leading so nested steps read as a distinct, denser
@@ -84,7 +125,16 @@
 import { computed, ref, watch } from 'vue'
 import { useI18n } from 'vue-i18n'
 import type { ContentBlock, ThinkingBlock as ThinkingBlockType, ToolCallBlock as ToolCallBlockType } from '@/store/chat-list'
-import { SUMMARY_BUCKET_ORDER, getToolDisplay, isGuiTool, toolBucket } from './tool-call-registry'
+import {
+  SUMMARY_BUCKET_ORDER,
+  SUMMARY_FRAGMENT_ORDER,
+  getToolDisplay,
+  isGuiTool,
+  toolBucket,
+  toolFragmentKind,
+  type SummaryFragment,
+  type ToolBucket,
+} from './tool-call-registry'
 import ToolCallInline from './tool-call-inline.vue'
 import ThinkingBlock from './thinking-block.vue'
 import CollapseSection from './collapse-section.vue'
@@ -137,8 +187,8 @@ function toggle() {
 }
 
 // Any tool still executing (a live foreground tool during streaming, or a
-// background task outliving the turn). Drives the shimmer only; the label
-// choice is `active`-gated (see headerLabel).
+// background task outliving the turn). Drives the shimmer only; the header's
+// text content is `active`-gated (see verbLabel/detailsLabel).
 const anyToolRunning = computed(() => toolItems.value.some(tool => tool.running))
 
 function basename(path: string): string {
@@ -168,10 +218,6 @@ function labelFor(tool: ToolCallBlockType): string {
   return subject ? `${verb} ${subject}` : verb
 }
 
-// Collapsed summary: a single tool keeps its subject; multiple tools fall back
-// to category counts ("Read 3 files · Edited 2 files"). The buckets live in the
-// registry so this header and the per-row display share one tool catalog.
-
 // Where a browser navigation went, by host — the one piece of a browsing run
 // worth surfacing in the collapsed header ("Browsed example.com").
 function navigateHost(tool: ToolCallBlockType): string {
@@ -187,42 +233,131 @@ function navigateHost(tool: ToolCallBlockType): string {
   }
 }
 
-const aggregateLabel = computed(() => {
+// Phase of the segment, by its dominant bucket. Ties break by
+// SUMMARY_BUCKET_ORDER; 'other' never wins a tie because a generic "Working"
+// adds nothing over the details alone. A GUI run is always "Browsing"
+// regardless of mix (its observe+action steps are one browsing activity).
+const phaseKey = computed<ToolBucket | 'gui' | null>(() => {
   const tools = toolItems.value
-  if (tools.length === 0) return t('chat.process.thought')
-  if (tools.length === 1) return labelFor(tools[0]!)
-  // A browsing/desktop run is summarized by where it went, not by the screenshot
-  // reads it folded in — name the destination, fall back to a step count.
-  if (tools.some(tool => isGuiTool(tool.toolName))) {
+  if (tools.length === 0) return null
+  if (tools.some(tool => isGuiTool(tool.toolName))) return 'gui'
+  const counts = new Map<ToolBucket, number>()
+  for (const tool of tools) {
+    const bucket = toolBucket(tool.toolName)
+    counts.set(bucket, (counts.get(bucket) ?? 0) + 1)
+  }
+  let best: ToolBucket = 'other'
+  let bestCount = 0
+  for (const bucket of SUMMARY_BUCKET_ORDER) {
+    const count = counts.get(bucket) ?? 0
+    if (count > bestCount) {
+      best = bucket
+      bestCount = count
+    }
+  }
+  if ((counts.get('other') ?? 0) > bestCount) return 'other'
+  return best
+})
+
+// The verb names the phase; its tense is the segment's own lifecycle — present
+// while THIS segment is the streaming tail, past once anything supersedes it.
+// Only genuine multi-tool segments get the verb+details split: a lone tool's
+// own label ("Run ls /tmp") already IS the specific, and prefixing its bucket
+// verb would stutter ("Running Run ls /tmp") while duplicating the now line.
+const verbLabel = computed(() => {
+  const tools = toolItems.value
+  if (tools.length <= 1) return ''
+  const key = phaseKey.value
+  if (!key) return ''
+  return t(`chat.process.phase.${key}.${props.active ? 'ing' : 'done'}`)
+})
+
+// The details half: bare counts ("12 files, 4 searches, ran 3 commands") that
+// grow live while streaming and settle with the segment. GUI runs name the
+// destination instead.
+const detailsLabel = computed(() => {
+  const tools = toolItems.value
+  if (tools.length === 0) return props.active ? t('chat.thinkingInProgress') : t('chat.process.thought')
+  if (phaseKey.value === 'gui') {
     const hosts = [...new Set(tools.map(navigateHost).filter(Boolean))]
-    if (hosts.length === 1) return t('chat.process.browsed', { target: hosts[0] })
-    if (hosts.length > 1) return t('chat.process.browsedSites', { count: hosts.length })
+    if (hosts.length === 1) return hosts[0]!
+    if (hosts.length > 1) return t('chat.process.frag.sites', { count: hosts.length })
     return t('chat.process.steps', { count: tools.length })
   }
-  const acc = new Map<string, number>()
+  const counts = new Map<SummaryFragment, number>()
   for (const tool of tools) {
-    const b = toolBucket(tool.toolName)
-    if (b !== 'other') acc.set(b, (acc.get(b) ?? 0) + 1)
+    const kind = toolFragmentKind(tool.toolName)
+    counts.set(kind, (counts.get(kind) ?? 0) + 1)
   }
-  const segments = SUMMARY_BUCKET_ORDER
-    .filter(b => acc.has(b))
-    .map(b => t(`chat.process.${b}`, { count: acc.get(b)! }))
-  return segments.length ? segments.join(' · ') : t('chat.process.steps', { count: tools.length })
+  const parts = SUMMARY_FRAGMENT_ORDER
+    .filter(kind => counts.has(kind))
+    .map(kind => t(`chat.process.frag.${kind}`, { count: counts.get(kind)! }))
+  return parts.length ? parts.join(t('chat.process.fragmentSeparator')) : t('chat.process.steps', { count: tools.length })
 })
 
-// Streaming header acts as a ticker for the current (last) item.
+// Single-span fallback for the two cases without a verb: a thought-only
+// segment ("Thinking…" / "Thought") and a lone settled tool (its own label).
+const headerLabel = computed(() => {
+  const tools = toolItems.value
+  if (tools.length === 0) return props.active ? t('chat.thinkingInProgress') : t('chat.process.thought')
+  return labelFor(tools[0]!)
+})
+
+// Segment-level diff totals for the settled header (+284 −96), summed from
+// each row's own display math so the header can never disagree with the body.
+const diffTotals = computed(() => {
+  let add = 0
+  let remove = 0
+  for (const tool of toolItems.value) {
+    const display = getToolDisplay(tool)
+    add += display.diffAdd ?? 0
+    remove += display.diffRemove ?? 0
+  }
+  return { add, remove }
+})
+
+// The now line rolls the current (last) item. A reasoning tail reads as
+// "Thinking…"; a tool whose input hasn't streamed yet gets the pending label
+// (same wording as its in-capsule row) instead of a target-less bare verb.
 const tickerLabel = computed(() => {
   const current = props.items[props.items.length - 1]
   if (!current) return ''
   if (current.type === 'reasoning') return t('chat.thinkingInProgress')
-  if (current.type === 'tool') return labelFor(current as ToolCallBlockType)
-  return aggregateLabel.value
+  if (current.type === 'tool') {
+    const tool = current as ToolCallBlockType
+    const input = tool.input
+    const inputReady = input && typeof input === 'object' && Object.keys(input as Record<string, unknown>).length > 0
+    if (tool.running && !inputReady) {
+      const display = getToolDisplay(tool)
+      return t(`chat.tools.pending.${display.actionKey}`, t('chat.tools.pending.generic'))
+    }
+    return labelFor(tool)
+  }
+  return headerLabel.value
 })
-
-// The header is a live ticker ONLY while the turn itself is streaming (`active`).
-// A still-running background task inside a finished turn must not keep the
-// ticker alive: "Thinking…" is a claim about the model, and a background
-// command the model started before finishing says nothing about the model.
-// The background tool's own row already shows its running state.
-const headerLabel = computed(() => (props.active ? tickerLabel.value : aggregateLabel.value))
 </script>
+
+<style scoped>
+/* Roll animation for the now line: incoming row rises from below, outgoing
+   exits upward, both absolutely positioned so they overlap mid-swap. 300ms
+   matches the house motion palette's gentle end. */
+.now-roll-enter-active,
+.now-roll-leave-active {
+  transition: transform 300ms cubic-bezier(0.215, 0.61, 0.355, 1);
+}
+
+.now-roll-enter-from {
+  transform: translateY(calc(100% + 1px));
+}
+
+.now-roll-leave-to {
+  transform: translateY(calc(-100% - 1px));
+}
+
+@media (prefers-reduced-motion: reduce) {
+  .now-roll-enter-active,
+  .now-roll-leave-active {
+    transition: none;
+  }
+}
+</style>
diff --git a/apps/web/src/pages/home/components/tool-call-registry.ts b/apps/web/src/pages/home/components/tool-call-registry.ts
index 31a338025..929834274 100644
--- a/apps/web/src/pages/home/components/tool-call-registry.ts
+++ b/apps/web/src/pages/home/components/tool-call-registry.ts
@@ -179,6 +179,39 @@ export function toolBucket(toolName: string): ToolBucket {
   return 'other'
 }
 
+// Fragment kinds for the group header's details half — the bare counts that
+// follow the phase verb ("Explored 12 file operations, 4 searches, ran 3 commands").
+// Finer-grained than ToolBucket on purpose: 'browse' lumps reads and searches
+// together, but a research run reporting "8 file operations" when 6 calls
+// were web searches is the header lying. File tools deliberately count calls,
+// not unique files: one patch may touch several files and repeated reads may
+// target the same path. Anything not listed falls to 'steps' so the header
+// degrades to a plain step count instead of inventing a noun.
+export type SummaryFragment = 'fileOperations' | 'searches' | 'commands' | 'messages' | 'schedules' | 'media' | 'agents' | 'steps'
+
+const FRAGMENT_TOOLS: Array<[SummaryFragment, Set<string>]> = [
+  ['fileOperations', new Set(['read', 'list', 'write', 'edit', 'apply_patch'])],
+  ['commands', new Set(['exec'])],
+  ['messages', new Set(['send', 'react', 'send_email', 'speak'])],
+  ['schedules', new Set(['create_schedule', 'update_schedule', 'delete_schedule'])],
+  ['media', new Set(['generate_image', 'generate_video', 'transcribe_audio'])],
+  ['agents', new Set(['spawn_agent', 'send_message', 'list_agents'])],
+]
+
+export const SUMMARY_FRAGMENT_ORDER: SummaryFragment[] = [
+  'fileOperations', 'searches', 'commands', 'messages', 'schedules', 'media', 'agents', 'steps',
+]
+
+export function toolFragmentKind(toolName: string): SummaryFragment {
+  for (const [kind, names] of FRAGMENT_TOOLS) {
+    if (names.has(toolName)) return kind
+  }
+  // Read-only lookups (web/memory/message search, list_*/get_*, email reads,
+  // bg status, waits) all read to the user as "it looked something up" — one
+  // 'searches' counter keeps the header to one clause instead of a taxonomy.
+  return isReadOnlyTool(toolName) ? 'searches' : 'steps'
+}
+
 // GUI tools (browser + computer) interleave read-only "observe" and
 // side-effecting "action" calls as one continuous browsing activity. Splitting
 // them on every observe↔action flip would strand each step in its own segment,