From f4207428317c207834fec228998ba01dec72a4e1 Mon Sep 17 00:00:00 2001
From: Shaojin Wen <shaojin.wensj@alibaba-inc.com>
Date: Mon, 27 Apr 2026 16:54:10 +0800
Subject: [PATCH] feat(cli,core): LLM-generated summary labels for tool-call
 batches (#3538)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* feat(cli,core): generate tool-use summaries for compact mode

After each tool batch completes, fire a parallel fast-model call to
generate a short git-commit-subject-style label summarizing what the
batch accomplished (e.g. "Read txt files", "Searched in auth/"). In
compact mode the label replaces the generic "Tool × N" header so N
parallel tool calls collapse to a single semantic row.

The fast-model call (~1s) runs fire-and-forget, overlapped with the
next turn's API stream, so there is no perceived latency. Missing
fast model, aborted turns, and model failures all degrade silently to
the existing rendering.

The summary is also emitted as a `tool_use_summary` history entry
with `precedingToolUseIds`, keeping the shape compatible with SDK
clients that want to render collapsed tool views on their own.

Gated by `experimental.emitToolUseSummaries` (default on). Can be
overridden per-session with `QWEN_CODE_EMIT_TOOL_USE_SUMMARIES=0|1`.

The system prompt and truncation rules (300 chars per tool field,
200 chars of trailing assistant text as intent prefix) match the
existing behavior seen in other tools that emit the same message
type, so SDK consumers see a consistent shape across clients.

* fix(core): bound cleanSummary quote-strip regex to avoid ReDoS

CodeQL js/polynomial-redos flagged the /^["'`]+|["'`]+$/g pattern in
cleanSummary because its input comes from an LLM (treated as
uncontrolled). The original regex is anchored and linear in practice,
but tightening the quantifier to {1,10} both satisfies the static
check and caps engine work on pathological model output with a long
run of quotes. Ten opening/closing quotes is well past anything a real
label would produce.

* fix(cli): render tool_use_summary inline so full mode also shows the label

The summary was only visible in compact mode because the full-mode
ToolGroupMessage ignored the compactLabel prop. Compact mode got away
with this because mergeCompactToolGroups triggers refreshStatic(),
which re-renders the merged tool_group with its newly-looked-up
label. Full mode has no such refresh path, so when the fast-model
call resolves *after* the tool_group has been committed to the
append-only <Static>, there is no way to retroactively decorate it.

Switch to rendering `tool_use_summary` as its own inline history item
(a single dim `● <label>` line). New items append cleanly to <Static>,
so the summary flows in naturally once the fast-model call resolves.
Compact mode still replaces the merged tool_group header with the
label and hides the standalone summary line via the `compactMode`
guard.

With this, the feature works under the default `ui.compactMode: false`
— not just the opt-in compact view.

* docs: tool-use-summaries feature guide, settings entry, and design doc

Three new docs matching the existing fast-model feature docs layout:

- docs/users/features/tool-use-summaries.md — user-facing guide
  covering full + compact rendering, configuration (settings + env),
  failure modes, cost, and cross-links to followup-suggestions.

- docs/users/configuration/settings.md — register the new
  experimental.emitToolUseSummaries setting next to the other
  fast-model-driven UI settings.

- docs/design/tool-use-summary/tool-use-summary-design.md — deep dive
  matching the compact-mode-design.md competitive-analysis style.
  Documents the Claude Code port (prompt, truncation, timing, gate),
  the deviations (settings layer, default on, cleanSummary, dual
  render paths), and the Ink <Static> append-only rationale that
  drove the inline full-mode render vs header-replacement split.

* docs: add Recommended pairing section to tool-use-summaries

Full-mode rendering of the summary works, but for small same-type
batches (Read × 3 and similar) the label visibly restates what the
tool lines already show. Pairing with ui.compactMode: true folds
the whole batch into a single labeled row, which is the cleanest
transcript shape once the label is available.

Adds a dedicated section showing the paired settings.json snippet
and explicitly calling out when each mode wins (and when to turn
the feature off instead).

* fix: address review feedback on tool-use summary generation

Addresses multiple issues from @chiga0's review:

Blocking — compact-mode label invisible for single-batch turns.
mergeCompactToolGroups's adjacency-only gating left a trailing
tool_use_summary in the merged result whenever there was no second
batch to merge across. That pushed mergedHistory.length lock-step
with history.length and MainContent's refreshStatic heuristic
(currMLen <= prevMLen) never fired, so Ink's append-only <Static>
never repainted the tool_group with its newly-looked-up label.
Drop tool_use_summary items unconditionally now; gemini_thought
still survives to avoid unnecessary repaints. New tests cover
the single-batch case and the summary-before-user-message case.

Blocking — stale summary appears after Ctrl+C on the next turn.
summarySignal captured the CURRENT turn's AbortController, but the
summary resolves during the NEXT turn's streaming window. The next
turn's submitQuery allocates a fresh controller, so the captured
signal was never aborted — Ctrl+C during the new turn used to let
the previous turn's summary land in the transcript seconds later.
Fix: dedicated per-batch AbortController tracked in a ref set,
aborted eagerly from cancelOngoingRequest; resolve-time check reads
the live abort state and turnCancelledRef.

High — summarizer input pollution.
geminiTools contained error/cancelled tools; retry-loop warnings
and "Cancelled by user" strings were feeding the fast model.
cleanSummary can only reject error-shaped output, not prevent the
model from hallucinating a plausible label from bad input (the PR's
own tmux screenshot showed "Read txt files · 5 tools" where 4 of
the 5 were prior-retry failures). Filter to status === 'success'
before building the prompt; skip the call entirely if nothing's
left.

High — unstable label on merged groups.
getCompactLabel iterated all callIds and returned the first hit,
so asynchronous resolution order made the header visibly flip
from SB to SA when batch A resolved after batch B. Lock onto
item.tools[0].callId to keep stable "leading batch governs"
semantics.

High — force-expanded groups in compact mode had no label at all.
Compact mode routes non-force-expand groups through
CompactToolGroupDisplay (consumes compactLabel) and force-expand
groups through the full ToolGroupMessage (ignores compactLabel);
the standalone ● line was gated on !compactMode, creating a dead
zone — exactly the diagnostically valuable case. MainContent now
computes absorbedCallIds (which groups actually consume the
header replacement) and passes summaryAbsorbed to
HistoryItemDisplay; force-expand groups in compact mode get the
standalone line as the label's only path to the screen.

Medium — cleanSummary robustness.
Extend quote-strip to Unicode curly + CJK corner brackets; strip
markdown emphasis (**bold**, _italic_); broaden refusal-prefix
rejection to curly-apostrophe "I can't", Chinese "我无法 / 我不能 /
抱歉 / 无法", and "Failed to / Sorry, / Request failed". 7 new
cleanSummary tests cover the added cases.

Low — concurrent-rendering safety.
Move historyRef.current = history from render phase into
useLayoutEffect so bailed renders can't leave a dropped value.

Low — CompactToolGroupDisplay readability.
Extract renderSummaryHeader / renderDefaultHeader helpers and
document the toolCalls.length > 1 count-suffix guard so a future
"fix" to >= 1 doesn't reintroduce "Read config.json · 1 tools".

Docs — add Scope & Lifecycle section to tool-use-summaries.md
covering (1) one generation per batch shared by both modes,
(2) no backfill on toggle / session resume, (3) main-agent batches
only with the Task-tool clarification.

* fix: address second-round review feedback on tool-use summaries

Critical — force-expand groups lost their summary entirely.
Previous round's "drop tool_use_summary unconditionally" merge fix
also stripped summaries for force-expanded groups, defeating the
exact case (errors, confirmations, focused shell) where the
standalone ● label is the label's only path to the screen. The
merge function now takes an absorbedCallIds set: summaries whose
preceding callIds are all absorbed by a compact tool_group header
are dropped (so refreshStatic still fires), but force-expanded
summaries pass through to be rendered standalone by
HistoryItemDisplay. MainContent computes absorbedCallIds from raw
history and passes it in. New tests cover both the absorbed-drop
and the force-expand-preserve cases plus the empty-set default
for callers that don't compute absorption.

Suggestion — late-arriving summaries could land out of order.
A slow fast-model call could resolve after the next turn's
content was committed, planting the ● label between later items
in full mode. The resolve callback now captures the first batch
callId, locates the corresponding tool_group at resolve time,
and drops the summary if a newer tool_group has already appeared
in history. New test exercises this with a manually-resolved
fast-model promise.

Suggestion — truncateJson allocated full JSON for large strings.
A 10MB ReadFile result was being JSON.stringify'd in full only to
be sliced down to 300 chars. Added preTruncate that walks the
value (depth-bounded to 4) and slices string leaves to maxLength
before serialization. Tests verify the input never reaches its
full pre-cap form.

Suggestion — settings description over-claimed SDK emission.
The description said summaries are emitted to SDK clients as a
tool_use_summary message; the SDK plumbing isn't actually wired
in this PR (the factory is exported for follow-up). Updated
settings.json description and regenerated the vscode schema to
state CLI-only scope explicitly.

Suggestion — fastModel data-boundary not documented.
When fastModel uses a different provider than the main session
model, tool inputs/outputs cross a new auth boundary that users
may not expect. Added "Data flow & privacy" section to the user
feature doc spelling out: same-provider fast model = no scope
change; different-provider = strictly larger sharing scope; two
escape hatches (same-provider fast model OR feature off).
Code-level mitigation (metadata-only mode) deferred.
---
 .../tool-use-summary-design.md                | 177 ++++++++
 docs/users/configuration/settings.md          |   1 +
 docs/users/features/_meta.ts                  |   1 +
 docs/users/features/tool-use-summaries.md     | 178 ++++++++
 packages/cli/src/config/config.ts             |   1 +
 packages/cli/src/config/settingsSchema.ts     |  10 +
 .../ui/components/HistoryItemDisplay.test.tsx |  19 +
 .../src/ui/components/HistoryItemDisplay.tsx  |  42 ++
 .../cli/src/ui/components/MainContent.tsx     | 102 ++++-
 .../messages/CompactToolGroupDisplay.test.tsx |  90 +++-
 .../messages/CompactToolGroupDisplay.tsx      |  79 +++-
 .../components/messages/ToolGroupMessage.tsx  |   8 +
 .../cli/src/ui/hooks/useGeminiStream.test.tsx | 318 ++++++++++++++
 packages/cli/src/ui/hooks/useGeminiStream.ts  | 165 ++++++-
 packages/cli/src/ui/types.ts                  |  14 +
 .../ui/utils/mergeCompactToolGroups.test.ts   | 128 ++++++
 .../src/ui/utils/mergeCompactToolGroups.ts    |  52 ++-
 packages/core/src/config/config.ts            |  19 +
 packages/core/src/index.ts                    |   1 +
 .../core/src/services/toolUseSummary.test.ts  | 409 ++++++++++++++++++
 packages/core/src/services/toolUseSummary.ts  | 309 +++++++++++++
 .../schemas/settings.schema.json              |   5 +
 22 files changed, 2104 insertions(+), 24 deletions(-)
 create mode 100644 docs/design/tool-use-summary/tool-use-summary-design.md
 create mode 100644 docs/users/features/tool-use-summaries.md
 create mode 100644 packages/core/src/services/toolUseSummary.test.ts
 create mode 100644 packages/core/src/services/toolUseSummary.ts

diff --git a/docs/design/tool-use-summary/tool-use-summary-design.md b/docs/design/tool-use-summary/tool-use-summary-design.md
new file mode 100644
index 000000000..8045edd83
--- /dev/null
+++ b/docs/design/tool-use-summary/tool-use-summary-design.md
@@ -0,0 +1,177 @@
+# Tool-Use Summary Design
+
+> Fast-model labels for parallel tool batches — motivation, competitive analysis with Claude Code, architecture, and the append-only-Static rationale that drove the current full-mode render.
+>
+> User documentation: [Tool-Use Summaries](../../users/features/tool-use-summaries.md).
+
+## 1. Executive Summary
+
+After each tool batch completes, Qwen Code fires a short fast-model call that returns a git-commit-subject-style label summarizing the batch. The label shows as an inline dim `● <label>` line in full mode and replaces the generic `Tool × N` header in compact mode. Generation runs fire-and-forget in parallel with the next turn's API stream, so its ~1s latency is hidden behind main-model streaming.
+
+| Dimension             | Claude Code                                                           | Qwen Code                                                                                  |
+| --------------------- | --------------------------------------------------------------------- | ------------------------------------------------------------------------------------------ |
+| Trigger point         | `query.ts` — after a tool batch finalizes                             | `useGeminiStream.ts` → `handleCompletedTools` — same lifecycle point                       |
+| Generation model      | Haiku via `queryHaiku`                                                | Configured `fastModel` via `GeminiClient.generateContent`                                  |
+| Subagent behavior     | `!toolUseContext.agentId` — main session only                         | Implicit — subagents run through `agents/runtime/`, not `useGeminiStream`                  |
+| Scheduling            | Fire-and-forget, awaited right before the next turn's stream emits    | Fire-and-forget, appended to history when resolved                                         |
+| Output shape          | `ToolUseSummaryMessage` yielded into the SDK stream                   | `HistoryItemToolUseSummary` added to UI history + factory exported for future SDK use      |
+| Gate                  | `CLAUDE_CODE_EMIT_TOOL_USE_SUMMARIES` env, default **off**            | `experimental.emitToolUseSummaries` setting (default **on**) + env override                |
+| Primary consumer      | Mobile / SDK clients                                                  | CLI compact mode + full mode, future SDK                                                   |
+| Prompt                | Git-commit-subject, past tense, most distinctive noun (verbatim port) | Identical system prompt                                                                    |
+| Input truncation      | 300 chars per tool field via `truncateJson`                           | Identical                                                                                  |
+| Intent prefix         | First 200 chars of the assistant's last message                       | Identical                                                                                  |
+| Prompt caching        | `enablePromptCaching: true` on the Haiku call                         | Not yet wired (forked-agent route available; flagged as future optimization)               |
+| Label post-processing | Raw model text                                                        | `cleanSummary` (strips markdown, quotes, error-prefixes; caps at 100 chars, ReDoS-bounded) |
+| Session persistence   | Stream-only; each session regenerates                                 | UI history only; `ChatRecordingService` does not persist `tool_use_summary` entries        |
+
+## 2. Claude Code Implementation Analysis
+
+### 2.1 Flow
+
+Claude Code runs the tool loop in `query.ts`. After a tool batch executes and its results are normalized, the generator function forks a Haiku call, keeps the pending promise on `nextPendingToolUseSummary`, and continues with the next turn's API call. The Haiku latency (~1s) overlaps the main model's streaming (5–30s), so the user sees zero added latency. Right before emitting the next turn's content, the generator awaits the pending summary and yields a `tool_use_summary` message into the stream.
+
+```
+tool_batch_complete → fork queryHaiku (fire-and-forget)
+                          ↓
+               next_turn_stream_starts
+                          ↓
+       ← summary Promise resolves during streaming →
+                          ↓
+       await pendingToolUseSummary → yield ToolUseSummaryMessage
+                          ↓
+                continue with next turn
+```
+
+### 2.2 Key source files
+
+| Component       | File                                                       | Key logic                                                                               |
+| --------------- | ---------------------------------------------------------- | --------------------------------------------------------------------------------------- |
+| Generator       | `services/toolUseSummary/toolUseSummaryGenerator.ts:45-97` | `generateToolUseSummary({ tools, signal, isNonInteractiveSession, lastAssistantText })` |
+| Trigger         | `query.ts:1411-1482`                                       | Guard by `emitToolUseSummaries` gate + no-subagent; fork Haiku; carry promise           |
+| Await + emit    | `query.ts:1055-1060`                                       | Await `pendingToolUseSummary` at next-turn boundary, yield message                      |
+| Message factory | `utils/messages.ts:5105-5116`                              | `createToolUseSummaryMessage(summary, precedingToolUseIds)`                             |
+| Feature gate    | `query/config.ts:23,36-38`                                 | `emitToolUseSummaries: isEnvTruthy(CLAUDE_CODE_EMIT_TOOL_USE_SUMMARIES)`                |
+
+### 2.3 Design decisions
+
+1. **Always generate when the gate is on, regardless of compact/detail state.** The summary is a stream-level artifact; the UI decides whether to render it.
+2. **Emit as a first-class message type.** `tool_use_summary` sits alongside `user`, `assistant`, `tool_result` in the SDK stream with a `precedingToolUseIds` field for consumers to correlate against the batch.
+3. **Subagents are excluded.** `!toolUseContext.agentId` — subagent output is aggregated upstream; individual subagent batches would produce noisy labels that never surface in the primary UI.
+4. **Default off.** The env-only gate keeps cost at zero unless a downstream SDK consumer opts in. The CC terminal itself does not render the message.
+5. **Input truncation at 300 chars per field.** Covers the dominant cost risk — a single large tool result blowing up the prompt — while keeping enough signal for the label.
+
+## 3. Qwen Code Implementation
+
+### 3.1 Flow
+
+Qwen Code hooks the same lifecycle point (`useGeminiStream.handleCompletedTools`) but renders on both sides of `ui.compactMode` so the feature is useful to CLI users without any SDK plumbing.
+
+```
+tool_batch_complete (handleCompletedTools)
+           ↓
+  config.getEmitToolUseSummaries()?
+           ↓
+   fork generateToolUseSummary (fire-and-forget)
+           ↓
+  submitQuery() for next turn (streaming starts)
+           ↓
+   ← summary Promise resolves during streaming →
+           ↓
+  addItem({type:'tool_use_summary', summary, precedingToolUseIds})
+           ↓
+  HistoryItemDisplay renders:
+    compactMode=false → ● <label> standalone line
+    compactMode=true  → hidden; MainContent lookup injects into CompactToolGroupDisplay header
+```
+
+### 3.2 Key source files
+
+| Component           | File                                                                  | Key logic                                                                 |
+| ------------------- | --------------------------------------------------------------------- | ------------------------------------------------------------------------- |
+| Service             | `packages/core/src/services/toolUseSummary.ts`                        | `generateToolUseSummary`, `truncateJson`, `cleanSummary`, message factory |
+| Config gate         | `packages/core/src/config/config.ts:getEmitToolUseSummaries`          | Env override → settings → default (true)                                  |
+| Trigger             | `packages/cli/src/ui/hooks/useGeminiStream.ts:handleCompletedTools`   | Fires fast-model call, addItem on resolve                                 |
+| Full-mode render    | `packages/cli/src/ui/components/HistoryItemDisplay.tsx`               | Renders `● <label>` line when `!compactMode`                              |
+| Compact-mode lookup | `packages/cli/src/ui/components/MainContent.tsx`                      | `summaryByCallId` map → `compactLabel` prop to each tool_group            |
+| Compact header      | `packages/cli/src/ui/components/messages/CompactToolGroupDisplay.tsx` | Replaces default `Tool × N` with `<Summary> · N tools` when label present |
+| Merge handling      | `packages/cli/src/ui/utils/mergeCompactToolGroups.ts`                 | Treats `tool_use_summary` as hidden-in-compact for adjacency              |
+| UI type             | `packages/cli/src/ui/types.ts:HistoryItemToolUseSummary`              | `{ type: 'tool_use_summary', summary, precedingToolUseIds }`              |
+
+### 3.3 The `<Static>` append-only constraint
+
+The central architectural decision in this PR is **why the full-mode label is a standalone history item and not a decoration on the tool_group itself**.
+
+Qwen Code renders the transcript via Ink's `<Static>`. Static is append-only: once an item is committed to the terminal buffer, Ink will not repaint that region unless `refreshStatic()` is called to clear and re-render the entire transcript. This is the performance model the CLI depends on — static items don't re-render on every keystroke.
+
+Now consider the fast-model call's timing:
+
+```
+T0   tool batch completes, tool_group is pushed to history
+T0+ε tool_group renders through <Static> and is committed to the buffer
+T0+1s fast-model call resolves with a label
+```
+
+At T0+1s, we cannot retroactively add the label to the already-committed tool_group. Two options exist:
+
+1. **Update the tool_group's props + call `refreshStatic()`.** Works, but causes a full transcript repaint on every batch — one of the most expensive UI operations in the app. Visible flash. Unacceptable for a cosmetic label.
+2. **Render the summary as its own new history item appended _after_ the tool_group.** Static handles this natively — new items append cleanly, no repaint.
+
+This PR takes option 2 in full mode. The `tool_use_summary` entry is a real history item, rendered as a single dim `● <label>` line by `HistoryItemDisplay`. No `refreshStatic` needed.
+
+Compact mode is different because of `mergeCompactToolGroups`. When consecutive tool_groups merge, `MainContent` already calls `refreshStatic()` — that's an existing codepath, and it re-renders the merged group with the label looked up from history. So compact mode _does_ get the label as a header replacement. To avoid rendering the same label twice (once as the compact header, once as a trailing `● <label>` line), `HistoryItemDisplay` hides the standalone line when `compactMode` is true.
+
+```
+Full mode              Compact mode (with merge)
+───────────            ─────────────────────────
+[tool_group]           [merged tool_group — header replaced via lookup]
+● <label>              (● <label> line is hidden)
+```
+
+### 3.4 Gate semantics
+
+Three layers, resolved in order of precedence:
+
+1. `QWEN_CODE_EMIT_TOOL_USE_SUMMARIES=0|1|true|false` — env override, highest priority.
+2. `experimental.emitToolUseSummaries` in `settings.json` — default `true`.
+3. Implicit skip — if `config.getFastModel()` returns `undefined`, generation is skipped regardless of the gate. No error, no user-visible change.
+
+### 3.5 Output cleaning
+
+`cleanSummary` runs on every model response before it is added to history:
+
+1. Take the first line only (drops model reasoning preambles).
+2. Strip bullet prefixes (`-`, `*`, `•`) — models sometimes return the label as a list item.
+3. Strip surrounding quotes/backticks via a bounded `{1,10}` regex (CodeQL-safe; no real label has more than a handful of wrapping quotes).
+4. Strip prefix labels (`Label:`, `Summary:`, `Result:`, `Output:`) that some models prepend.
+5. Reject error-message shapes (`API error: ...`, `Error: ...`, `I cannot ...`, `I can't ...`, `Unable to ...`) — returns empty string so no history item is added.
+6. Hard-cap length at 100 characters (mobile UI truncates around 30; the slack covers CJK phrases).
+
+### 3.6 Telemetry
+
+The summary generation call sets `promptId: 'tool_use_summary_generation'` so its token usage is accounted separately in `/stats`. This lets users see the exact incremental cost of the feature without conflating it with prompt suggestions or the main session's usage.
+
+## 4. Deviations from Claude Code (and why)
+
+| Deviation                                                                | Why                                                                                                                                                                                     |
+| ------------------------------------------------------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Settings layer in addition to env gate                                   | Qwen Code renders the label in the CLI; users need a persistent switch, not a per-shell env export.                                                                                     |
+| Default **on** instead of off                                            | Label is immediately user-visible in both display modes; users configuring `fastModel` are opting into fast-model features already.                                                     |
+| Dedicated `cleanSummary` post-processing                                 | Qwen Code supports more heterogeneous providers than CC; some models prepend `Label:` or wrap in quotes. Normalizing at the boundary keeps the UI consistent.                           |
+| Stores `HistoryItemToolUseSummary` rather than emitting a stream message | CLI-first implementation; the SDK-stream route is a future PR. The `ToolUseSummaryMessage` factory is already exported for that work.                                                   |
+| Prompt caching not yet wired                                             | The fast model is often the same as the main model for users who haven't configured a separate one. Adding cache sharing requires routing via `forkedAgent.ts`; tracked as a follow-up. |
+| Dual render paths (full-mode inline + compact-mode header)               | Qwen Code's default is `ui.compactMode: false`; without the inline full-mode render, the feature would be invisible to most users.                                                      |
+
+## 5. Known limitations
+
+- **No session persistence.** `tool_use_summary` is not written to the chat recording JSONL. Resuming a session loses labels; tool groups render with the generic header as a fallback. Low-priority: labels regenerate naturally as the user continues the session.
+- **No SDK stream emission yet.** The message factory is exported, but the CLI does not yet feed `tool_use_summary` into the SDK bridge. Follow-up PR.
+- **No prompt caching.** Each batch incurs a fresh input-token cost. Negligible in absolute terms (~300 tokens) but measurable if you run dozens of batches per turn.
+- **Summary for merged compact groups picks the first contributing batch's label.** If a user fires ten dissimilar batches back-to-back (tight loop, not typical), the merged compact header will show only the leading batch's intent. Trade-off accepted: fanning out per-batch labels in a merged view is visually noisier than taking the first.
+- **Fast model required.** Without a configured `fastModel`, generation is skipped. Falling back to the main model is deliberately disallowed to keep the cost profile bounded.
+
+## 6. Future work
+
+1. Wire `ToolUseSummaryMessage` into the SDK bridge so the existing factory gets used downstream.
+2. Route generation via `forkedAgent.ts` with `enablePromptCaching` so repeated tool-name prefixes hit provider caches.
+3. Optional: persist `tool_use_summary` entries to `ChatRecordingService` and replay on session resume.
+4. Optional: per-tool-name label shortcuts (e.g., always `Read <filename>` for a single `read_file` call) as a pre-LLM fast path.
diff --git a/docs/users/configuration/settings.md b/docs/users/configuration/settings.md
index 8ea037779..4be4c5077 100644
--- a/docs/users/configuration/settings.md
+++ b/docs/users/configuration/settings.md
@@ -117,6 +117,7 @@ Settings are organized into categories. All settings should be placed within the
 | `ui.enableFollowupSuggestions`          | boolean          | Enable [followup suggestions](../features/followup-suggestions) that predict what you want to type next after the model responds. Suggestions appear as ghost text and can be accepted with Tab, Enter, or Right Arrow.                                                                                                                                                                                                                                                                                                                            | `true`      |
 | `ui.enableCacheSharing`                 | boolean          | Use cache-aware forked queries for suggestion generation. Reduces cost on providers that support prefix caching (experimental).                                                                                                                                                                                                                                                                                                                                                                                                                    | `true`      |
 | `ui.enableSpeculation`                  | boolean          | Speculatively execute accepted suggestions before submission. Results appear instantly when you accept (experimental).                                                                                                                                                                                                                                                                                                                                                                                                                             | `false`     |
+| `experimental.emitToolUseSummaries`     | boolean          | Generate short LLM-based labels summarizing each tool-call batch. See [Tool-Use Summaries](../features/tool-use-summaries). Requires `fastModel` to be configured; silently skipped otherwise. Can be overridden per-session with `QWEN_CODE_EMIT_TOOL_USE_SUMMARIES=0` or `=1`.                                                                                                                                                                                                                                                                   | `true`      |
 
 #### ide
 
diff --git a/docs/users/features/_meta.ts b/docs/users/features/_meta.ts
index bdb2d6145..661a26c03 100644
--- a/docs/users/features/_meta.ts
+++ b/docs/users/features/_meta.ts
@@ -2,6 +2,7 @@ export default {
   commands: 'Commands',
   'code-review': 'Code Review',
   'followup-suggestions': 'Followup Suggestions',
+  'tool-use-summaries': 'Tool-Use Summaries',
   'sub-agents': 'SubAgents',
   arena: 'Agent Arena',
   skills: 'Skills',
diff --git a/docs/users/features/tool-use-summaries.md b/docs/users/features/tool-use-summaries.md
new file mode 100644
index 000000000..8be660ca1
--- /dev/null
+++ b/docs/users/features/tool-use-summaries.md
@@ -0,0 +1,178 @@
+# Tool-Use Summaries
+
+Qwen Code can generate a short, git-commit-subject-style label after each tool batch completes, summarizing what the batch accomplished. The label appears inline in the transcript and replaces the generic `Tool × N` header in compact mode.
+
+This is a UX aid for parallel tool calls: when the model fans out into several `Read` + `Grep` + `Bash` calls at once, the summary tells you the intent at a glance instead of forcing you to scan the tool list.
+
+The feature is enabled by default and runs silently in the background. It requires a configured [fast model](./followup-suggestions#fast-model).
+
+## What You See
+
+### Full mode (default)
+
+The summary appears as a dim badge line directly below the tool group:
+
+```
+╭──────────────────────────────────────────────╮
+│ ✓  ReadFile a.txt                            │
+│ ✓  ReadFile b.txt                            │
+│ ✓  ReadFile c.txt                            │
+│ ✓  ReadFile d.txt                            │
+╰──────────────────────────────────────────────╯
+
+ ● Read 4 text files
+```
+
+### Compact mode (`Ctrl+O` or `ui.compactMode: true`)
+
+The label replaces the generic `Tool × N` header in the compact one-liner:
+
+```
+╭──────────────────────────────────────────────╮
+│✓  Read txt files  · 4 tools                  │
+│Press Ctrl+O to show full tool output         │
+╰──────────────────────────────────────────────╯
+```
+
+The individual tool calls are still a keystroke away (`Ctrl+O` to toggle to full mode).
+
+## How It Works
+
+After a tool batch finalizes, Qwen Code fires a fire-and-forget call to the configured fast model with:
+
+- The tool names, truncated arguments, and truncated results (each capped at 300 characters).
+- The assistant's most recent text output (first 200 characters) as an intent prefix.
+- A system prompt instructing the model to return a past-tense, 30-character label in git-commit-subject style.
+
+The call runs in parallel with the next turn's API streaming, so its ~1s latency is hidden behind the main model's response. When the label resolves, it is appended to the transcript as a `tool_use_summary` entry.
+
+Example labels: `Searched in auth/`, `Fixed NPE in UserService`, `Created signup endpoint`, `Read config.json`, `Ran failing tests`.
+
+## When It Appears
+
+The summary is generated when **all** of the following are true:
+
+- `experimental.emitToolUseSummaries` is `true` (default).
+- A `fastModel` is configured (via settings or `/model --fast`).
+- At least one tool completed in the batch.
+- The turn was not aborted before tool completion.
+- The fast model returned a non-empty, non-error response.
+
+Subagent tool calls do not trigger summary generation — only the main session's tool batches do.
+
+## When It Doesn't Appear
+
+The summary is silently skipped (no error, no UI change) when:
+
+- No fast model is configured.
+- The fast model call fails, times out, or returns empty.
+- The model returned an obvious error-message-like string (e.g., `Error: ...`, `I cannot ...`) — filtered out by the client so the UI does not show misleading labels.
+- The turn was aborted (`Ctrl+C`) before the model finished.
+
+In all these cases, the tool group renders as it always has.
+
+## Fast Model
+
+The label is generated using the [fast model](./followup-suggestions#fast-model) — the same model you configure for prompt suggestions and speculative execution. Configure it via:
+
+### Via command
+
+```
+/model --fast qwen3-coder-flash
+```
+
+### Via `settings.json`
+
+```json
+{
+  "fastModel": "qwen3-coder-flash"
+}
+```
+
+When no fast model is configured, summary generation is skipped entirely — the feature has no effect until you set one up.
+
+## Configuration
+
+These settings can be configured in `settings.json`:
+
+| Setting                             | Type    | Default | Description                                                                                        |
+| ----------------------------------- | ------- | ------- | -------------------------------------------------------------------------------------------------- |
+| `experimental.emitToolUseSummaries` | boolean | `true`  | Master switch for summary generation. Turn off to disable the extra fast-model call.               |
+| `fastModel`                         | string  | `""`    | Fast model used for summary generation (shared with prompt suggestions). Required; no-op if empty. |
+
+### Environment override
+
+`QWEN_CODE_EMIT_TOOL_USE_SUMMARIES` overrides the `experimental.emitToolUseSummaries` setting for the current session:
+
+- `QWEN_CODE_EMIT_TOOL_USE_SUMMARIES=0` or `=false` — force off.
+- `QWEN_CODE_EMIT_TOOL_USE_SUMMARIES=1` or `=true` — force on.
+- Unset — use the `experimental.emitToolUseSummaries` setting.
+
+### Example
+
+```json
+{
+  "fastModel": "qwen3-coder-flash",
+  "experimental": {
+    "emitToolUseSummaries": true
+  }
+}
+```
+
+## Scope & lifecycle
+
+Three points that tend to trip up a first read of this feature:
+
+1. **One generation per batch, shared by both display modes.** The fast-model call happens exactly once in `handleCompletedTools` when a tool batch finalizes. Toggling `Ctrl+O` afterwards does **not** trigger a new call — both modes read from the same `tool_use_summary` history entry that was captured the first time. You can flip compact mode on and off freely without extra cost.
+2. **No backfill on toggle or on session resume.** A `tool_group` that completed before the feature was enabled (or before you flipped the setting on, or in a resumed session — `ChatRecordingService` does not persist summary entries) will never get a label. There is no "sweep existing history" pass. If you turn this setting on mid-session, only _future_ batches will show a label; older groups keep the default rendering with no indicator that a label is missing.
+3. **Main-agent batches only.** The trigger lives in the main session's turn loop (`useGeminiStream`), so:
+   - ✅ Shell, MCP, file operations, and the `Task` / subagent tool _call itself_ (as it appears in the main batch) are summarized.
+   - ❌ A subagent's **internal** tool batches (run through `packages/core/src/agents/runtime/`) are not summarized.
+
+   An outer batch that _contains_ a `Task` tool will still be labeled, but the fast model sees only the subagent tool call and its aggregated output — not the individual tool calls inside the subagent. Expect labels like `Ran research-agent` or `Delegated file search` rather than `Searched 14 files`. This is intentional — summarizing subagent internals would multiply the fast-model cost and surface noise that never shows up in the primary UI.
+
+## Recommended pairing: enable compact mode
+
+For batches of 3+ parallel tool calls, pairing this feature with `ui.compactMode: true` produces the cleanest transcript. The compact view folds the whole batch into a single labeled row (`✓  Read txt files  · 4 tools`) instead of showing every tool line plus the trailing summary. Details remain one keystroke away via `Ctrl+O`.
+
+```json
+{
+  "fastModel": "qwen3-coder-flash",
+  "ui": {
+    "compactMode": true
+  },
+  "experimental": {
+    "emitToolUseSummaries": true
+  }
+}
+```
+
+In full mode (the default), the summary renders as a trailing `● <label>` line below the tool group — useful for large or heterogeneous batches, but for small same-type batches (e.g. `Read × 3`) the label can read as a restatement of the visible tool lines. If that matches your usual workflow, either turn compact mode on as above, or turn the summary off entirely via `experimental.emitToolUseSummaries: false`.
+
+## Monitoring
+
+Summary model usage appears in `/stats` output under the fast-model token totals, with the `prompt_id` `tool_use_summary_generation` so it can be distinguished from prompt suggestions and other background tasks.
+
+## Data flow & privacy
+
+The summary call sends each successful tool's name, truncated `args`, and truncated result (each field capped at 300 characters) to the **fast model**, plus the first 200 characters of the assistant's most recent text as an intent prefix.
+
+If your fast model is configured for the same provider/auth as your main session model, the data flows along the same boundary your main session already uses — no change in trust scope. If you have configured a fast model from a **different provider**, tool inputs and outputs (potentially including file contents read by `read_file`, command output from shell calls, or values surfaced through MCP tools) will be sent to that other provider as part of the summarization prompt. That is a strictly larger data-sharing scope than the main session alone.
+
+If this matters for your workflow, you have two clean options:
+
+- Configure `fastModel` to a model under the same provider as your main session, so the summary call doesn't cross any new auth/data boundary.
+- Disable the feature entirely with `experimental.emitToolUseSummaries: false` (or `QWEN_CODE_EMIT_TOOL_USE_SUMMARIES=0`).
+
+The 300-character per-field cap limits exposure but does not eliminate it — secrets discovered in tool output during the cap window can still be sent. Treat the fast model's data boundary the same way you treat the main model's.
+
+## Cost
+
+One fast-model call per qualifying tool batch. Input is a small fixed system prompt plus the truncated tool inputs/outputs (each capped at 300 characters per field). Output is a single short line (capped at 100 characters, typically 20 tokens or fewer). On a typical fast model this is roughly $0.001 per batch.
+
+If you do not want the extra cost, turn the feature off via `experimental.emitToolUseSummaries: false` or `QWEN_CODE_EMIT_TOOL_USE_SUMMARIES=0`.
+
+## Related
+
+- [Compact Mode](../configuration/settings#ui.compactMode) — toggle with `Ctrl+O`; the summary replaces the generic tool-group header when compact mode is on.
+- [Followup Suggestions](./followup-suggestions) — another fast-model-driven UX enhancement that shares the same `fastModel` setting.
diff --git a/packages/cli/src/config/config.ts b/packages/cli/src/config/config.ts
index 304f878ac..fb3d1318a 100755
--- a/packages/cli/src/config/config.ts
+++ b/packages/cli/src/config/config.ts
@@ -1168,6 +1168,7 @@ export async function loadCliConfig(
       argv.maxSessionTurns ?? settings.model?.maxSessionTurns ?? -1,
     experimentalZedIntegration: argv.acp || argv.experimentalAcp || false,
     cronEnabled: settings.experimental?.cron ?? false,
+    emitToolUseSummaries: settings.experimental?.emitToolUseSummaries ?? true,
     listExtensions: argv.listExtensions || false,
     overrideExtensions: overrideExtensions || argv.extensions,
     noBrowser: !!process.env['NO_BROWSER'],
diff --git a/packages/cli/src/config/settingsSchema.ts b/packages/cli/src/config/settingsSchema.ts
index 9bfa13110..9a2e2e370 100644
--- a/packages/cli/src/config/settingsSchema.ts
+++ b/packages/cli/src/config/settingsSchema.ts
@@ -1862,6 +1862,16 @@ const SETTINGS_SCHEMA = {
           'Enable in-session cron/loop tools (experimental). When enabled, the model can create recurring prompts using cron_create, cron_list, and cron_delete tools. Can also be enabled via QWEN_CODE_ENABLE_CRON=1 environment variable.',
         showInDialog: true,
       },
+      emitToolUseSummaries: {
+        type: 'boolean',
+        label: 'Tool Use Summaries',
+        category: 'Experimental',
+        requiresRestart: false,
+        default: true,
+        description:
+          'Generate a short LLM-based label after each tool batch completes. In compact mode the label replaces the generic `Tool × N` header; in full mode it appears as a dim `● <label>` line below the tool group. Requires a fast model to be configured; runs in parallel with the next API call so latency is hidden. Currently affects interactive CLI rendering only — SDK / non-interactive emission of the `tool_use_summary` message is not yet wired (the message factory is exported for a follow-up PR). Can be overridden with QWEN_CODE_EMIT_TOOL_USE_SUMMARIES=0 or =1.',
+        showInDialog: true,
+      },
     },
   },
 } as const satisfies SettingsSchema;
diff --git a/packages/cli/src/ui/components/HistoryItemDisplay.test.tsx b/packages/cli/src/ui/components/HistoryItemDisplay.test.tsx
index 7b4a22e80..443a28d18 100644
--- a/packages/cli/src/ui/components/HistoryItemDisplay.test.tsx
+++ b/packages/cli/src/ui/components/HistoryItemDisplay.test.tsx
@@ -284,4 +284,23 @@ describe('<HistoryItemDisplay />', () => {
 
     expect(lastFrame()).toMatchSnapshot();
   });
+
+  it('renders tool_use_summary as a dim badge line in full mode', () => {
+    const item: HistoryItem = {
+      id: 1,
+      type: 'tool_use_summary',
+      summary: 'Read txt files',
+      precedingToolUseIds: ['c1', 'c2', 'c3', 'c4'],
+    };
+    const { lastFrame } = renderWithProviders(
+      <HistoryItemDisplay
+        {...baseItem}
+        item={item}
+        isPending={false}
+        terminalWidth={80}
+      />,
+    );
+    expect(lastFrame()).toContain('Read txt files');
+    expect(lastFrame()).toContain('●');
+  });
 });
diff --git a/packages/cli/src/ui/components/HistoryItemDisplay.tsx b/packages/cli/src/ui/components/HistoryItemDisplay.tsx
index a37544db0..5344da6a1 100644
--- a/packages/cli/src/ui/components/HistoryItemDisplay.tsx
+++ b/packages/cli/src/ui/components/HistoryItemDisplay.tsx
@@ -64,6 +64,21 @@ interface HistoryItemDisplayProps {
   activeShellPtyId?: number | null;
   embeddedShellFocused?: boolean;
   availableTerminalHeightGemini?: number;
+  /**
+   * When the item is a `tool_group`, an optional short LLM-generated label
+   * summarizing the batch. Replaces the generic "Tool × N" line in compact
+   * mode. Computed by the parent from `tool_use_summary` history items.
+   */
+  compactLabel?: string;
+  /**
+   * When the item is a `tool_use_summary`, true if a sibling tool_group has
+   * absorbed this label via its compact-mode header. The standalone `● <label>`
+   * line is suppressed in that case. False for force-expanded groups in
+   * compact mode (they render through the full ToolGroupMessage path and
+   * don't consume compactLabel, so the standalone line is the label's only
+   * path to the screen) and for all tool_use_summary items in full mode.
+   */
+  summaryAbsorbed?: boolean;
 }
 
 const HistoryItemDisplayComponent: React.FC<HistoryItemDisplayProps> = ({
@@ -77,6 +92,8 @@ const HistoryItemDisplayComponent: React.FC<HistoryItemDisplayProps> = ({
   activeShellPtyId,
   embeddedShellFocused,
   availableTerminalHeightGemini,
+  compactLabel,
+  summaryAbsorbed = false,
 }) => {
   const marginTop =
     item.type === 'gemini_content' || item.type === 'gemini_thought_content'
@@ -198,8 +215,33 @@ const HistoryItemDisplayComponent: React.FC<HistoryItemDisplayProps> = ({
           memoryWriteCount={itemForDisplay.memoryWriteCount}
           memoryReadCount={itemForDisplay.memoryReadCount}
           isUserInitiated={itemForDisplay.isUserInitiated}
+          compactLabel={compactLabel}
         />
       )}
+      {/*
+        `tool_use_summary` as a standalone inline item.
+
+        In full mode (`compactMode=false`), the label arrives via the fast-model
+        call AFTER the tool_group has been committed to Ink's append-only
+        <Static>, so we cannot update the tool_group's header retroactively.
+        Rendering a standalone `● <label>` line appends cleanly.
+
+        In compact mode, the label is normally absorbed into the merged
+        tool_group's header (via `compactLabel` prop to CompactToolGroupDisplay),
+        and `summaryAbsorbed=true` is set so this block does nothing. But when
+        the sibling tool_group is force-expanded (errors, confirmations,
+        user-initiated, focused shell), the full-expand path ignores
+        `compactLabel`, and `MainContent` leaves `summaryAbsorbed=false` —
+        the standalone line below is then the label's only route to the UI,
+        which is exactly the case where a summary is most diagnostically
+        useful ("Fixed NPE in UserService" on an errored batch).
+      */}
+      {itemForDisplay.type === 'tool_use_summary' &&
+        (!compactMode || !summaryAbsorbed) && (
+          <Box paddingLeft={1}>
+            <Text dimColor>● {itemForDisplay.summary}</Text>
+          </Box>
+        )}
       {itemForDisplay.type === 'compression' && (
         <CompressionMessage compression={itemForDisplay.compression} />
       )}
diff --git a/packages/cli/src/ui/components/MainContent.tsx b/packages/cli/src/ui/components/MainContent.tsx
index 89c799097..172419ee9 100644
--- a/packages/cli/src/ui/components/MainContent.tsx
+++ b/packages/cli/src/ui/components/MainContent.tsx
@@ -5,7 +5,8 @@
  */
 
 import { Box, Static } from 'ink';
-import { useEffect, useMemo, useRef } from 'react';
+import { useCallback, useEffect, useMemo, useRef } from 'react';
+import type { HistoryItem, HistoryItemWithoutId } from '../types.js';
 import { HistoryItemDisplay } from './HistoryItemDisplay.js';
 import { ShowMoreLines } from './ShowMoreLines.js';
 import { Notifications } from './Notifications.js';
@@ -16,7 +17,10 @@ import { useAppContext } from '../contexts/AppContext.js';
 import { AppHeader } from './AppHeader.js';
 import { DebugModeNotification } from './DebugModeNotification.js';
 import { useCompactMode } from '../contexts/CompactModeContext.js';
-import { mergeCompactToolGroups } from '../utils/mergeCompactToolGroups.js';
+import {
+  isForceExpandGroup,
+  mergeCompactToolGroups,
+} from '../utils/mergeCompactToolGroups.js';
 
 // Limit Gemini messages to a very high number of lines to mitigate performance
 // issues in the worst case if we somehow get an enormous response from Gemini.
@@ -37,7 +41,47 @@ export const MainContent = () => {
     availableTerminalHeight,
   } = uiState;
 
-  // Merge consecutive tool_groups for compact mode display
+  // Set of callIds whose label is absorbed by a compact-mode tool_group header.
+  // Computed from RAW history (not merged) — force-expand status depends only
+  // on the tool_group's own state, and mergeable groups don't change force-
+  // expand status when merged. Iterating raw history avoids a circular
+  // dependency with mergedHistory (which receives absorbedCallIds).
+  //
+  // In compact mode, non-force-expanded tool_groups render via
+  // CompactToolGroupDisplay and consume the label as their header replacement.
+  // Force-expanded groups (errors, confirmations, user-initiated, focused
+  // shell) render through the full ToolGroupMessage path and ignore
+  // compactLabel — their callIds are intentionally NOT in this set so the
+  // standalone `● <label>` line in HistoryItemDisplay is the label's only
+  // path to the screen.
+  const absorbedCallIds = useMemo(() => {
+    const absorbed = new Set<string>();
+    if (!compactMode) return absorbed;
+    for (const item of uiState.history) {
+      if (item.type !== 'tool_group') continue;
+      if (
+        isForceExpandGroup(
+          item,
+          uiState.embeddedShellFocused ?? false,
+          uiState.activePtyId,
+        )
+      ) {
+        continue;
+      }
+      for (const tool of item.tools) absorbed.add(tool.callId);
+    }
+    return absorbed;
+  }, [
+    compactMode,
+    uiState.history,
+    uiState.embeddedShellFocused,
+    uiState.activePtyId,
+  ]);
+
+  // Merge consecutive tool_groups for compact mode display. Summaries for
+  // absorbed call IDs are dropped during merge so refreshStatic fires;
+  // summaries for force-expanded (non-absorbed) groups pass through so
+  // HistoryItemDisplay can render them as standalone `● <label>` lines.
   const mergedHistory = useMemo(
     () =>
       compactMode
@@ -45,6 +89,7 @@ export const MainContent = () => {
             uiState.history,
             uiState.embeddedShellFocused,
             uiState.activePtyId,
+            absorbedCallIds,
           )
         : uiState.history,
     [
@@ -52,9 +97,56 @@ export const MainContent = () => {
       uiState.history,
       uiState.embeddedShellFocused,
       uiState.activePtyId,
+      absorbedCallIds,
     ],
   );
 
+  // Build a callId → summary lookup from `tool_use_summary` history items so
+  // compact-mode tool groups can render a semantic label instead of a generic
+  // "Tool × N" line. A summary is indexed under every callId it covers; when
+  // multiple groups are merged, the first group's summary wins (see below).
+  const summaryByCallId = useMemo(() => {
+    const map = new Map<string, string>();
+    for (const item of uiState.history) {
+      if (item.type === 'tool_use_summary') {
+        for (const callId of item.precedingToolUseIds) {
+          // First summary wins — earlier summaries represent the opening
+          // intent of a batch streak, later ones would override it otherwise.
+          if (!map.has(callId)) {
+            map.set(callId, item.summary);
+          }
+        }
+      }
+    }
+    return map;
+  }, [uiState.history]);
+
+  const isSummaryAbsorbed = useCallback(
+    (item: HistoryItem | HistoryItemWithoutId): boolean => {
+      if (item.type !== 'tool_use_summary') return false;
+      return item.precedingToolUseIds.some((id) => absorbedCallIds.has(id));
+    },
+    [absorbedCallIds],
+  );
+
+  const getCompactLabel = useCallback(
+    (item: HistoryItem | HistoryItemWithoutId): string | undefined => {
+      if (item.type !== 'tool_group' || item.tools.length === 0)
+        return undefined;
+      // Look up ONLY the first tool's callId. A merged group concatenates
+      // batch A (earliest calls) then batch B; earlier iterations scanned
+      // all callIds and returned "first hit", but async resolution order
+      // breaks that — if B's summary resolves first, the header renders
+      // SB; when A later resolves, the next render flips to SA. Anchoring
+      // on item.tools[0].callId gives stable "leading batch governs"
+      // semantics; if A's call failed and only B resolved, the header
+      // stays blank for that group (acceptable — the fallback is the
+      // default "Tool × N" rendering once the lookup misses).
+      return summaryByCallId.get(item.tools[0].callId);
+    },
+    [summaryByCallId],
+  );
+
   // Ink's <Static> is append-only: once an item is rendered to the terminal
   // buffer, it cannot be replaced. In compact mode, when a new tool_group is
   // merged into a previous one, the merged result has FEWER items than the
@@ -102,6 +194,8 @@ export const MainContent = () => {
               item={h}
               isPending={false}
               commands={uiState.slashCommands}
+              compactLabel={getCompactLabel(h)}
+              summaryAbsorbed={isSummaryAbsorbed(h)}
             />
           )),
         ]}
@@ -123,6 +217,8 @@ export const MainContent = () => {
               isFocused={!uiState.isEditorDialogOpen}
               activeShellPtyId={uiState.activePtyId}
               embeddedShellFocused={uiState.embeddedShellFocused}
+              compactLabel={getCompactLabel(item)}
+              summaryAbsorbed={isSummaryAbsorbed(item)}
             />
           ))}
           <ShowMoreLines constrainHeight={uiState.constrainHeight} />
diff --git a/packages/cli/src/ui/components/messages/CompactToolGroupDisplay.test.tsx b/packages/cli/src/ui/components/messages/CompactToolGroupDisplay.test.tsx
index e0180c3d1..88d0a9e24 100644
--- a/packages/cli/src/ui/components/messages/CompactToolGroupDisplay.test.tsx
+++ b/packages/cli/src/ui/components/messages/CompactToolGroupDisplay.test.tsx
@@ -36,7 +36,22 @@ function shellTool(
   };
 }
 
-describe('<CompactToolGroupDisplay />', () => {
+function toolCall(
+  overrides: Partial<IndividualToolCallDisplay> = {},
+): IndividualToolCallDisplay {
+  return {
+    callId: 'call-1',
+    name: 'read_file',
+    description: 'Read a.ts',
+    resultDisplay: 'file contents',
+    status: ToolCallStatus.Success,
+    confirmationDetails: undefined,
+    renderOutputAsMarkdown: false,
+    ...overrides,
+  };
+}
+
+describe('<CompactToolGroupDisplay /> — shell timeout plumbing', () => {
   beforeEach(() => {
     vi.useFakeTimers();
     vi.setSystemTime(NOW);
@@ -91,3 +106,76 @@ describe('<CompactToolGroupDisplay />', () => {
     expect(lastFrame()).not.toContain('timeout');
   });
 });
+
+describe('<CompactToolGroupDisplay /> — summary label', () => {
+  it('renders default header (active tool name + count) when no compactLabel is provided', () => {
+    const tools = [
+      toolCall({ callId: 'c1', name: 'read_file' }),
+      toolCall({ callId: 'c2', name: 'read_file' }),
+      toolCall({ callId: 'c3', name: 'grep' }),
+    ];
+    const { lastFrame } = render(
+      <CompactToolGroupDisplay toolCalls={tools} contentWidth={80} />,
+    );
+    const frame = lastFrame()!;
+    // Active tool = last in array when none are executing/confirming.
+    expect(frame).toContain('grep');
+    expect(frame).toContain('× 3');
+  });
+
+  it('replaces header with compactLabel when provided', () => {
+    const tools = [
+      toolCall({ callId: 'c1', name: 'read_file' }),
+      toolCall({ callId: 'c2', name: 'grep' }),
+    ];
+    const { lastFrame } = render(
+      <CompactToolGroupDisplay
+        toolCalls={tools}
+        contentWidth={80}
+        compactLabel="Searched in auth/"
+      />,
+    );
+    const frame = lastFrame()!;
+    expect(frame).toContain('Searched in auth/');
+    expect(frame).toContain('2 tools');
+    // The raw tool name should not appear as the primary header when a
+    // summary is shown.
+    expect(frame).not.toContain('read_file × 2');
+  });
+
+  it('shows tool count suffix only when multiple tools are present', () => {
+    const tools = [toolCall({ callId: 'c1', name: 'read_file' })];
+    const { lastFrame } = render(
+      <CompactToolGroupDisplay
+        toolCalls={tools}
+        contentWidth={80}
+        compactLabel="Read config.json"
+      />,
+    );
+    const frame = lastFrame()!;
+    expect(frame).toContain('Read config.json');
+    expect(frame).not.toContain('tools');
+  });
+
+  it('renders nothing for empty tool calls', () => {
+    const { lastFrame } = render(
+      <CompactToolGroupDisplay toolCalls={[]} contentWidth={80} />,
+    );
+    expect(lastFrame()).toBe('');
+  });
+
+  it('preserves default rendering for shell commands without label', () => {
+    const tools = [
+      toolCall({
+        callId: 'c1',
+        name: 'Bash',
+        description: 'ls -la',
+      }),
+    ];
+    const { lastFrame } = render(
+      <CompactToolGroupDisplay toolCalls={tools} contentWidth={80} />,
+    );
+    expect(lastFrame()).toContain('Bash');
+    expect(lastFrame()).toContain('ls -la');
+  });
+});
diff --git a/packages/cli/src/ui/components/messages/CompactToolGroupDisplay.tsx b/packages/cli/src/ui/components/messages/CompactToolGroupDisplay.tsx
index 063a0c283..ea08396ac 100644
--- a/packages/cli/src/ui/components/messages/CompactToolGroupDisplay.tsx
+++ b/packages/cli/src/ui/components/messages/CompactToolGroupDisplay.tsx
@@ -18,6 +18,13 @@ import { ToolElapsedTime } from '../shared/ToolElapsedTime.js';
 interface CompactToolGroupDisplayProps {
   toolCalls: IndividualToolCallDisplay[];
   contentWidth: number;
+  /**
+   * Optional LLM-generated label (~30 chars, git-commit-subject style) that
+   * replaces the "active tool name + count + description" header when
+   * present. Falls back to the default rendering while the label is still
+   * being generated or if generation was skipped/failed.
+   */
+  compactLabel?: string;
 }
 
 // Priority: Confirming > Executing > Error > Canceled > Pending > Success
@@ -66,9 +73,57 @@ function getShellTimeoutMs(
   return undefined;
 }
 
+/**
+ * Summary-label header: bold label + " · N tools" count when there are 2+
+ * tools in the batch. The count is intentionally suppressed for N=1 so
+ * single-tool batches don't read as `Read config.json · 1 tools`. Future
+ * edits: keep the `length > 1` guard, not `>= 1`.
+ */
+function renderSummaryHeader(label: string, count: number) {
+  return (
+    <>
+      <Text bold>{label}</Text>
+      {count > 1 ? (
+        <Text color={theme.text.secondary}>
+          {'  · '}
+          {count} tools
+        </Text>
+      ) : null}
+    </>
+  );
+}
+
+/**
+ * Default header: active tool name + " × N" count + first-line description.
+ * Same N=1 suffix suppression as `renderSummaryHeader`.
+ */
+function renderDefaultHeader(
+  activeToolName: string,
+  activeToolDescription: string,
+  count: number,
+) {
+  return (
+    <>
+      <Text bold>{activeToolName}</Text>
+      {count > 1 ? (
+        <Text color={theme.text.secondary}>
+          {' × '}
+          {count}
+        </Text>
+      ) : null}
+      {activeToolDescription ? (
+        <Text color={theme.text.secondary}>
+          {'  '}
+          {activeToolDescription}
+        </Text>
+      ) : null}
+    </>
+  );
+}
+
 export const CompactToolGroupDisplay: React.FC<
   CompactToolGroupDisplayProps
-> = ({ toolCalls, contentWidth }) => {
+> = ({ toolCalls, contentWidth, compactLabel }) => {
   if (toolCalls.length === 0) return null;
 
   const overallStatus = getOverallStatus(toolCalls);
@@ -103,24 +158,18 @@ export const CompactToolGroupDisplay: React.FC<
       borderColor={borderColor}
       gap={0}
     >
-      {/* Status line: icon + tool name + count + description + elapsed */}
+      {/* Status line: icon + (summary | tool name + description) + count + elapsed */}
       <Box flexDirection="row">
         <ToolStatusIndicator status={overallStatus} name={activeTool.name} />
         <Box flexGrow={1}>
           <Text wrap="truncate-end">
-            <Text bold>{activeTool.name}</Text>
-            {toolCalls.length > 1 ? (
-              <Text color={theme.text.secondary}>
-                {' × '}
-                {toolCalls.length}
-              </Text>
-            ) : null}
-            {activeToolDescription ? (
-              <Text color={theme.text.secondary}>
-                {'  '}
-                {activeToolDescription}
-              </Text>
-            ) : null}
+            {compactLabel
+              ? renderSummaryHeader(compactLabel, toolCalls.length)
+              : renderDefaultHeader(
+                  activeTool.name,
+                  activeToolDescription,
+                  toolCalls.length,
+                )}
           </Text>
         </Box>
         <ToolElapsedTime
diff --git a/packages/cli/src/ui/components/messages/ToolGroupMessage.tsx b/packages/cli/src/ui/components/messages/ToolGroupMessage.tsx
index 2812c8baa..71385c533 100644
--- a/packages/cli/src/ui/components/messages/ToolGroupMessage.tsx
+++ b/packages/cli/src/ui/components/messages/ToolGroupMessage.tsx
@@ -44,6 +44,12 @@ interface ToolGroupMessageProps {
   /** Pre-computed count of read ops from managed-auto-memory files. */
   memoryReadCount?: number;
   isUserInitiated?: boolean;
+  /**
+   * Short LLM-generated label for this batch. Used in compact mode in place
+   * of the "active tool name × count" line. Undefined when summary
+   * generation is disabled, still in-flight, or failed.
+   */
+  compactLabel?: string;
 }
 
 // Main component renders the border and maps the tools using ToolMessage
@@ -57,6 +63,7 @@ export const ToolGroupMessage: React.FC<ToolGroupMessageProps> = ({
   memoryWriteCount,
   memoryReadCount,
   isUserInitiated,
+  compactLabel,
 }) => {
   const config = useConfig();
   const { compactMode } = useCompactMode();
@@ -139,6 +146,7 @@ export const ToolGroupMessage: React.FC<ToolGroupMessageProps> = ({
       <CompactToolGroupDisplay
         toolCalls={toolCalls}
         contentWidth={contentWidth}
+        compactLabel={compactLabel}
       />
     );
   }
diff --git a/packages/cli/src/ui/hooks/useGeminiStream.test.tsx b/packages/cli/src/ui/hooks/useGeminiStream.test.tsx
index b9ad835f3..0616b97ed 100644
--- a/packages/cli/src/ui/hooks/useGeminiStream.test.tsx
+++ b/packages/cli/src/ui/hooks/useGeminiStream.test.tsx
@@ -207,6 +207,8 @@ describe('useGeminiStream', () => {
       getArenaAgentClient: vi.fn(() => null),
       isCronEnabled: vi.fn(() => false),
       getCronScheduler: vi.fn(() => null),
+      getEmitToolUseSummaries: vi.fn(() => false),
+      getFastModel: vi.fn(() => undefined),
       getBackgroundTaskRegistry: vi.fn(() => ({
         setNotificationCallback: vi.fn(),
       })),
@@ -826,6 +828,322 @@ describe('useGeminiStream', () => {
     expect(result.current.streamingState).toBe(StreamingState.Responding);
   });
 
+  describe('Tool-use summary generation', () => {
+    const makeCompletedToolCall = (
+      callId: string,
+      name: string,
+      args: Record<string, unknown>,
+    ): TrackedCompletedToolCall =>
+      ({
+        request: {
+          callId,
+          name,
+          args,
+          isClientInitiated: false,
+          prompt_id: 'prompt-1',
+        },
+        status: 'success',
+        responseSubmittedToGemini: false,
+        tool: {
+          name,
+          displayName: name,
+          description: 'desc',
+          build: vi.fn(),
+        } as any,
+        invocation: {
+          getDescription: () => 'Mock description',
+        } as unknown as AnyToolInvocation,
+        startTime: Date.now(),
+        endTime: Date.now(),
+        response: {
+          callId,
+          responseParts: [{ text: `result for ${name}` }],
+          error: undefined,
+          errorType: undefined,
+          resultDisplay: '',
+        },
+      }) as TrackedCompletedToolCall;
+
+    const runCompletion = async (
+      config: Config,
+      completedTools: TrackedCompletedToolCall[],
+    ) => {
+      let capturedOnComplete:
+        | ((completedTools: TrackedToolCall[]) => Promise<void>)
+        | null = null;
+
+      mockUseReactToolScheduler.mockImplementation((onComplete) => {
+        capturedOnComplete = onComplete;
+        return [
+          completedTools,
+          mockScheduleToolCalls,
+          mockMarkToolsAsSubmitted,
+        ];
+      });
+
+      // Seed history with a tool_group whose callIds match the completed
+      // tools, so the staleness check (which verifies the tool_group is
+      // still the latest in history) passes. Without this seed the summary
+      // would be dropped as stale before addItem is called.
+      const historyWithToolGroup = [
+        {
+          type: 'tool_group',
+          id: 1,
+          tools: completedTools.map((tc) => ({
+            callId: tc.request.callId,
+            name: tc.request.name,
+            description: '',
+            status: 0,
+            resultDisplay: undefined,
+            confirmationDetails: undefined,
+          })),
+        } as unknown as HistoryItem,
+      ];
+
+      renderHook(() =>
+        useGeminiStream(
+          new MockedGeminiClientClass(config),
+          historyWithToolGroup,
+          mockAddItem,
+          config,
+          mockLoadedSettings,
+          mockOnDebugMessage,
+          mockHandleSlashCommand,
+          false,
+          () => 'vscode' as EditorType,
+          () => {},
+          () => Promise.resolve(),
+          false,
+          () => {},
+          () => {},
+          () => {},
+          () => {},
+          80,
+          24,
+        ),
+      );
+
+      await act(async () => {
+        if (capturedOnComplete) {
+          await capturedOnComplete(completedTools);
+        }
+      });
+    };
+
+    it('skips summary generation when the feature is disabled', async () => {
+      const config = {
+        ...mockConfig,
+        getEmitToolUseSummaries: vi.fn(() => false),
+        getFastModel: vi.fn(() => 'qwen-fast'),
+        getGeminiClient: vi.fn(() => ({
+          generateContent: vi.fn(),
+        })),
+      } as unknown as Config;
+
+      await runCompletion(config, [
+        makeCompletedToolCall('c1', 'Read', { file: 'a.ts' }),
+        makeCompletedToolCall('c2', 'Grep', { pattern: 'foo' }),
+      ]);
+
+      // The flag is off — even though a fast model is configured, no summary
+      // history item should be added.
+      const summaryItems = (mockAddItem.mock.calls as any[][]).filter(
+        (call) => call[0]?.type === 'tool_use_summary',
+      );
+      expect(summaryItems).toHaveLength(0);
+    });
+
+    it('skips summary generation when no fast model is configured', async () => {
+      const generateContent = vi.fn();
+      const config = {
+        ...mockConfig,
+        getEmitToolUseSummaries: vi.fn(() => true),
+        getFastModel: vi.fn(() => undefined),
+        getGeminiClient: vi.fn(() => ({ generateContent })),
+      } as unknown as Config;
+
+      await runCompletion(config, [
+        makeCompletedToolCall('c1', 'Read', { file: 'a.ts' }),
+      ]);
+
+      expect(generateContent).not.toHaveBeenCalled();
+    });
+
+    it('fires generation with tool input/output when enabled', async () => {
+      const generateContent = vi.fn().mockResolvedValue({
+        candidates: [{ content: { parts: [{ text: 'Searched auth/' }] } }],
+      });
+      const config = {
+        ...mockConfig,
+        getEmitToolUseSummaries: vi.fn(() => true),
+        getFastModel: vi.fn(() => 'qwen-fast'),
+        getGeminiClient: vi.fn(() => ({ generateContent })),
+      } as unknown as Config;
+
+      await runCompletion(config, [
+        makeCompletedToolCall('c1', 'Grep', { pattern: 'login' }),
+        makeCompletedToolCall('c2', 'Read', { file: 'auth.ts' }),
+      ]);
+
+      // Wait for the fire-and-forget promise chain to settle (addItem happens in .then()).
+      await waitFor(() => {
+        const summaryItems = (mockAddItem.mock.calls as any[][]).filter(
+          (call) => call[0]?.type === 'tool_use_summary',
+        );
+        expect(summaryItems).toHaveLength(1);
+        expect(summaryItems[0][0]).toMatchObject({
+          type: 'tool_use_summary',
+          summary: 'Searched auth/',
+          precedingToolUseIds: ['c1', 'c2'],
+        });
+      });
+
+      // Model was called with the fast model and includes tool names in the prompt.
+      expect(generateContent).toHaveBeenCalledTimes(1);
+      const callArgs = generateContent.mock.calls[0];
+      expect(callArgs[3]).toBe('qwen-fast');
+      const userText = callArgs[0][0].parts[0].text as string;
+      expect(userText).toContain('Tool: Grep');
+      expect(userText).toContain('Tool: Read');
+      expect(userText).toContain('"pattern":"login"');
+    });
+
+    it('drops a late summary when a newer tool_group has been added', async () => {
+      // Resolve the fast-model call but ensure history shows a NEWER
+      // tool_group AFTER ours — simulates a slow summary landing during
+      // the next turn. The summary must not be appended; otherwise the
+      // ● label line would land in the wrong transcript position.
+      let resolveSummary: (val: { candidates: unknown[] }) => void;
+      const generateContent = vi.fn().mockImplementation(
+        () =>
+          new Promise((resolve) => {
+            resolveSummary = resolve;
+          }),
+      );
+      const config = {
+        ...mockConfig,
+        getEmitToolUseSummaries: vi.fn(() => true),
+        getFastModel: vi.fn(() => 'qwen-fast'),
+        getGeminiClient: vi.fn(() => ({ generateContent })),
+      } as unknown as Config;
+
+      let capturedOnComplete:
+        | ((completedTools: TrackedToolCall[]) => Promise<void>)
+        | null = null;
+      const completedTools = [
+        makeCompletedToolCall('c1', 'Read', { file: 'a.ts' }),
+      ];
+      mockUseReactToolScheduler.mockImplementation((onComplete) => {
+        capturedOnComplete = onComplete;
+        return [
+          completedTools,
+          mockScheduleToolCalls,
+          mockMarkToolsAsSubmitted,
+        ];
+      });
+
+      // History initially has our tool_group, but a newer tool_group is
+      // added before the summary resolves.
+      const history: HistoryItem[] = [
+        {
+          type: 'tool_group',
+          id: 1,
+          tools: [
+            {
+              callId: 'c1',
+              name: 'Read',
+              description: '',
+              status: 0,
+              resultDisplay: undefined,
+              confirmationDetails: undefined,
+            },
+          ],
+        } as unknown as HistoryItem,
+        {
+          type: 'tool_group',
+          id: 2,
+          tools: [
+            {
+              callId: 'c2',
+              name: 'Edit',
+              description: '',
+              status: 0,
+              resultDisplay: undefined,
+              confirmationDetails: undefined,
+            },
+          ],
+        } as unknown as HistoryItem,
+      ];
+
+      renderHook(() =>
+        useGeminiStream(
+          new MockedGeminiClientClass(config),
+          history,
+          mockAddItem,
+          config,
+          mockLoadedSettings,
+          mockOnDebugMessage,
+          mockHandleSlashCommand,
+          false,
+          () => 'vscode' as EditorType,
+          () => {},
+          () => Promise.resolve(),
+          false,
+          () => {},
+          () => {},
+          () => {},
+          () => {},
+          80,
+          24,
+        ),
+      );
+
+      await act(async () => {
+        if (capturedOnComplete) {
+          await capturedOnComplete(completedTools);
+        }
+      });
+
+      // Resolve the summary — it should be dropped because tool_group id=2
+      // is newer than our anchor tool_group id=1.
+      await act(async () => {
+        resolveSummary!({
+          candidates: [{ content: { parts: [{ text: 'Read file' }] } }],
+        });
+      });
+
+      const summaryItems = (mockAddItem.mock.calls as any[][]).filter(
+        (call) => call[0]?.type === 'tool_use_summary',
+      );
+      expect(summaryItems).toHaveLength(0);
+    });
+
+    it('does not add a history item when the model returns empty', async () => {
+      const generateContent = vi.fn().mockResolvedValue({
+        candidates: [{ content: { parts: [{ text: '' }] } }],
+      });
+      const config = {
+        ...mockConfig,
+        getEmitToolUseSummaries: vi.fn(() => true),
+        getFastModel: vi.fn(() => 'qwen-fast'),
+        getGeminiClient: vi.fn(() => ({ generateContent })),
+      } as unknown as Config;
+
+      await runCompletion(config, [
+        makeCompletedToolCall('c1', 'Read', { file: 'a.ts' }),
+      ]);
+
+      // The fast-model call happened but produced no label, so no history item.
+      await waitFor(() => {
+        expect(generateContent).toHaveBeenCalled();
+      });
+      const summaryItems = (mockAddItem.mock.calls as any[][]).filter(
+        (call) => call[0]?.type === 'tool_use_summary',
+      );
+      expect(summaryItems).toHaveLength(0);
+    });
+  });
+
   describe('Cancellation', () => {
     it('buffers streamed content until the throttle interval elapses', async () => {
       vi.useFakeTimers();
diff --git a/packages/cli/src/ui/hooks/useGeminiStream.ts b/packages/cli/src/ui/hooks/useGeminiStream.ts
index fd80a6ec4..e59112f3d 100644
--- a/packages/cli/src/ui/hooks/useGeminiStream.ts
+++ b/packages/cli/src/ui/hooks/useGeminiStream.ts
@@ -4,7 +4,14 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import { useState, useRef, useCallback, useEffect, useMemo } from 'react';
+import {
+  useState,
+  useRef,
+  useCallback,
+  useEffect,
+  useMemo,
+  useLayoutEffect,
+} from 'react';
 import type {
   Config,
   EditorType,
@@ -42,6 +49,7 @@ import {
   ApiCancelEvent,
   isSupportedImageMimeType,
   getUnsupportedImageFormatWarning,
+  generateToolUseSummary,
 } from '@qwen-code/qwen-code-core';
 import { type Part, type PartListUnion, FinishReason } from '@google/genai';
 import type {
@@ -80,6 +88,48 @@ import { useDualOutput } from '../../dualOutput/DualOutputContext.js';
 
 const debugLogger = createDebugLogger('GEMINI_STREAM');
 
+/**
+ * Pull the assistant's most recent visible text from the UI history. Used as
+ * an intent prefix for tool-use summary generation so the summarizer knows
+ * what the user was trying to accomplish.
+ */
+function extractLastAssistantText(history: HistoryItem[]): string | undefined {
+  for (let i = history.length - 1; i >= 0; i--) {
+    const item = history[i];
+    if (
+      (item.type === 'gemini' || item.type === 'gemini_content') &&
+      typeof item.text === 'string' &&
+      item.text.trim().length > 0
+    ) {
+      return item.text;
+    }
+  }
+  return undefined;
+}
+
+/**
+ * Flatten `functionResponse` parts into a compact string for the summarizer.
+ * The summarizer itself truncates to 300 chars per field, so we just join
+ * whatever is available without re-serializing.
+ */
+function extractToolResultText(parts: Part[] | Part | undefined): unknown {
+  if (!parts) return '';
+  const list = Array.isArray(parts) ? parts : [parts];
+  const chunks: unknown[] = [];
+  for (const part of list) {
+    if ('functionResponse' in part && part.functionResponse) {
+      const response = (part.functionResponse as { response?: unknown })
+        .response;
+      if (response !== undefined) chunks.push(response);
+    } else if ('text' in part && typeof part.text === 'string') {
+      chunks.push(part.text);
+    }
+  }
+  if (chunks.length === 0) return '';
+  if (chunks.length === 1) return chunks[0];
+  return chunks;
+}
+
 /**
  * Classify API error to StopFailureErrorType
  * @internal Exported for testing purposes
@@ -229,6 +279,22 @@ export const useGeminiStream = (
   const dualOutput = useDualOutput();
   const [isResponding, setIsResponding] = useState<boolean>(false);
   const [thought, setThought] = useState<ThoughtSummary | null>(null);
+  // Hold the latest history in a ref so handleCompletedTools can read it
+  // without depending on `history` (which would recreate the tool scheduler
+  // every render). Use useLayoutEffect instead of writing during render —
+  // writing refs in the render phase is unsafe under React's concurrent
+  // rendering (a bailed-out render could leave the ref with a dropped value).
+  const historyRef = useRef<HistoryItem[]>(history);
+  useLayoutEffect(() => {
+    historyRef.current = history;
+  }, [history]);
+  // In-flight tool-use-summary aborters. Each batch gets its own AbortController
+  // because the captured turn controller is replaced when submitQuery starts
+  // the next turn, and the summary call outlives the current turn (that's the
+  // whole point — it overlaps with the next turn's streaming). cancelOngoingRequest
+  // aborts all in-flight summaries so Ctrl+C during the next turn also kills
+  // this turn's stale summary work.
+  const summaryAbortRefsRef = useRef<Set<AbortController>>(new Set());
   const [pendingHistoryItem, pendingHistoryItemRef, setPendingHistoryItem] =
     useStateAndRef<HistoryItemWithoutId | null>(null);
   const [
@@ -495,6 +561,12 @@ export const useGeminiStream = (
     turnCancelledRef.current = true;
     isSubmittingQueryRef.current = false;
     abortControllerRef.current?.abort();
+    // Cancel any in-flight tool-use-summary generations so their Promise.then
+    // doesn't addItem a stale label after the user cancelled.
+    for (const ac of summaryAbortRefsRef.current) {
+      ac.abort();
+    }
+    summaryAbortRefsRef.current.clear();
 
     // Report cancellation to arena status reporter (if in arena mode).
     // This is needed because cancellation during tool execution won't
@@ -1868,6 +1940,97 @@ export const useGeminiStream = (
 
       markToolsAsSubmitted(callIdsToMarkAsSubmitted);
 
+      // Fire tool-use summary generation in parallel with the next API call.
+      // The fast-model Haiku-equivalent latency (~1s) is hidden behind the
+      // main-model streaming (5-30s). Mirrors Claude Code's query.ts:1411-1482
+      // behavior. Fire-and-forget: failures are silent and never block the turn.
+      // Subagent exclusion is implicit — useGeminiStream only drives the
+      // main session; subagents run through agents/runtime/ with their own loop.
+      if (config.getEmitToolUseSummaries()) {
+        // Only summarize successful tools. Error/cancelled entries push
+        // "Cancelled by user" / retry-loop warnings into the summarizer
+        // prompt and produce plausibly-worded but misleading labels (the
+        // fast model happily synthesizes "Attempted to read files" from a
+        // batch that was mostly failures). cleanSummary can reject output
+        // prefixes but not prevent this kind of polluted-input hallucination.
+        const successfulTools = geminiTools.filter(
+          (tc) => tc.status === 'success',
+        );
+        if (successfulTools.length > 0) {
+          const toolInfoForSummary = successfulTools.map((tc) => ({
+            name: tc.request.name,
+            input: tc.request.args,
+            output: extractToolResultText(tc.response.responseParts),
+          }));
+          const toolUseIds = successfulTools.map((tc) => tc.request.callId);
+          const lastAssistantText = extractLastAssistantText(
+            historyRef.current,
+          );
+          // Dedicated AbortController for this batch. Scoping it to the
+          // current turn via abortControllerRef.current would be wrong —
+          // submitQuery() below allocates a new controller for the next
+          // turn, so the captured signal becomes stale the moment the
+          // next turn starts. Instead, check the live abort state at
+          // resolve time (which covers both Ctrl+C on the next turn and
+          // mid-flight cancellation of this batch via turnCancelledRef).
+          const summaryAbort = new AbortController();
+          summaryAbortRefsRef.current.add(summaryAbort);
+
+          // Capture the first callId so we can locate "our" tool_group at
+          // resolve time. If a newer tool_group has been added since we
+          // fired (i.e., the conversation moved on), we drop the summary
+          // rather than wedging the `● <label>` line between later items.
+          const anchorCallId = toolUseIds[0];
+
+          void generateToolUseSummary({
+            config,
+            tools: toolInfoForSummary,
+            signal: summaryAbort.signal,
+            lastAssistantText,
+          })
+            .then((summary) => {
+              summaryAbortRefsRef.current.delete(summaryAbort);
+              const cancelled =
+                turnCancelledRef.current ||
+                abortControllerRef.current?.signal.aborted ||
+                summaryAbort.signal.aborted;
+              if (!summary || cancelled) return;
+
+              // Stale-summary check: only append if our tool_group is still
+              // the latest one in history. If a newer batch landed while
+              // the fast-model call was in flight, the conversation has
+              // moved past this batch and dropping in a `● <label>` line
+              // now would land it after later content (full mode) or
+              // attribute it to the wrong group (compact mode).
+              const currentHistory = historyRef.current;
+              const ourIdx = currentHistory.findIndex(
+                (h) =>
+                  h.type === 'tool_group' &&
+                  h.tools.some((t) => t.callId === anchorCallId),
+              );
+              if (ourIdx < 0) return;
+              const laterToolGroupExists = currentHistory
+                .slice(ourIdx + 1)
+                .some((h) => h.type === 'tool_group');
+              if (laterToolGroupExists) return;
+
+              if (summary && !cancelled) {
+                addItem(
+                  {
+                    type: 'tool_use_summary',
+                    summary,
+                    precedingToolUseIds: toolUseIds,
+                  } as HistoryItemWithoutId,
+                  Date.now(),
+                );
+              }
+            })
+            .catch(() => {
+              summaryAbortRefsRef.current.delete(summaryAbort);
+            });
+        }
+      }
+
       // Don't continue if model was switched due to quota error
       if (modelSwitchedFromQuotaError) {
         return;
diff --git a/packages/cli/src/ui/types.ts b/packages/cli/src/ui/types.ts
index 775537da9..b29e31588 100644
--- a/packages/cli/src/ui/types.ts
+++ b/packages/cli/src/ui/types.ts
@@ -210,6 +210,19 @@ export type HistoryItemToolGroup = HistoryItemBase & {
   isUserInitiated?: boolean;
 };
 
+/**
+ * Short LLM-generated label summarizing a preceding tool batch. Emitted after
+ * the batch completes and consumed by compact-mode rendering to replace the
+ * generic "Tool × N" line with something like "Searched in auth/". Also
+ * surfaces to SDK clients as a `tool_use_summary` stream message.
+ */
+export type HistoryItemToolUseSummary = HistoryItemBase & {
+  type: 'tool_use_summary';
+  summary: string;
+  /** Tool callIds this summary describes. Used to locate the target tool_group. */
+  precedingToolUseIds: string[];
+};
+
 export type HistoryItemNotification = HistoryItemBase & {
   type: 'notification';
   text: string;
@@ -471,6 +484,7 @@ export type HistoryItemWithoutId =
   | HistoryItemAbout
   | HistoryItemHelp
   | HistoryItemToolGroup
+  | HistoryItemToolUseSummary
   | HistoryItemStats
   | HistoryItemModelStats
   | HistoryItemToolStats
diff --git a/packages/cli/src/ui/utils/mergeCompactToolGroups.test.ts b/packages/cli/src/ui/utils/mergeCompactToolGroups.test.ts
index 2a8f69afe..405516234 100644
--- a/packages/cli/src/ui/utils/mergeCompactToolGroups.test.ts
+++ b/packages/cli/src/ui/utils/mergeCompactToolGroups.test.ts
@@ -343,6 +343,134 @@ describe('mergeCompactToolGroups', () => {
     expect(merged[3].type).toBe('tool_group');
   });
 
+  it('drops trailing tool_use_summary after a single absorbed tool_group', () => {
+    // Single-batch turn: one tool_group, then its summary arrives. The group
+    // is non-force-expanded (compact-mode candidate), so its callId is in
+    // absorbedCallIds — the summary is consumed by the compact header and
+    // dropped from merged output. Without this drop, mergedHistory.length
+    // would grow lock-step with history.length and MainContent's
+    // refreshStatic heuristic would never fire.
+    const items: HistoryItem[] = [
+      createToolGroup(1, [createTool('c1', 'Shell', ToolCallStatus.Success)]),
+      {
+        type: 'tool_use_summary',
+        id: 2,
+        summary: 'Ran shell batch',
+        precedingToolUseIds: ['c1'],
+      },
+    ];
+
+    const merged = mergeCompactToolGroups(
+      items,
+      false,
+      undefined,
+      new Set(['c1']),
+    );
+
+    expect(merged.length).toBe(1);
+    expect(merged[0].id).toBe(1);
+    expect(merged[0].type).toBe('tool_group');
+  });
+
+  it('drops absorbed trailing tool_use_summary even when followed by visible non-mergeable items', () => {
+    const items: HistoryItem[] = [
+      createToolGroup(1, [createTool('c1', 'Shell', ToolCallStatus.Success)]),
+      {
+        type: 'tool_use_summary',
+        id: 2,
+        summary: 'Ran shell batch',
+        precedingToolUseIds: ['c1'],
+      },
+      { type: 'user', id: 3, text: 'next prompt' },
+    ];
+
+    const merged = mergeCompactToolGroups(
+      items,
+      false,
+      undefined,
+      new Set(['c1']),
+    );
+
+    expect(merged.length).toBe(2);
+    expect(merged[0].type).toBe('tool_group');
+    expect(merged[1].type).toBe('user');
+  });
+
+  it('preserves tool_use_summary for force-expanded (non-absorbed) tool_group', () => {
+    // The errored tool_group is force-expanded: it renders through the full
+    // ToolGroupMessage path, ignoring `compactLabel`. Its callId is NOT in
+    // absorbedCallIds, so the summary must survive in merged output —
+    // HistoryItemDisplay then renders it as a standalone `● <label>` line,
+    // which is the only way the label reaches the screen for this group.
+    const items: HistoryItem[] = [
+      createToolGroup(1, [
+        createTool('c1', 'Shell', ToolCallStatus.Error, 'boom'),
+      ]),
+      {
+        type: 'tool_use_summary',
+        id: 2,
+        summary: 'Tried shell batch',
+        precedingToolUseIds: ['c1'],
+      },
+    ];
+
+    // Empty absorbedCallIds — the errored group's callId is not absorbed.
+    const merged = mergeCompactToolGroups(items, false, undefined, new Set());
+
+    expect(merged.length).toBe(2);
+    expect(merged[0].type).toBe('tool_group');
+    expect(merged[1].type).toBe('tool_use_summary');
+  });
+
+  it('preserves tool_use_summary when no absorbedCallIds set is provided (default)', () => {
+    // Default empty set — preserves all summaries. This is the safe default
+    // for callers that don't compute absorption (e.g., older test fixtures
+    // and any future callers outside MainContent).
+    const items: HistoryItem[] = [
+      createToolGroup(1, [createTool('c1', 'Shell', ToolCallStatus.Success)]),
+      {
+        type: 'tool_use_summary',
+        id: 2,
+        summary: 'Ran shell batch',
+        precedingToolUseIds: ['c1'],
+      },
+    ];
+
+    const merged = mergeCompactToolGroups(items);
+
+    expect(merged.length).toBe(2);
+    expect(merged[0].type).toBe('tool_group');
+    expect(merged[1].type).toBe('tool_use_summary');
+  });
+
+  it('merges tool_groups separated by tool_use_summary (hidden in compact)', () => {
+    // Two mergeable batches separated by an absorbed summary — the summary
+    // is dropped during merge, the two groups concatenate.
+    const items: HistoryItem[] = [
+      createToolGroup(1, [createTool('c1', 'Shell', ToolCallStatus.Success)]),
+      {
+        type: 'tool_use_summary',
+        id: 2,
+        summary: 'Ran first shell batch',
+        precedingToolUseIds: ['c1'],
+      },
+      createToolGroup(3, [createTool('c2', 'Shell', ToolCallStatus.Success)]),
+    ];
+
+    const merged = mergeCompactToolGroups(
+      items,
+      false,
+      undefined,
+      new Set(['c1', 'c2']),
+    );
+
+    expect(merged.length).toBe(1);
+    expect(merged[0].id).toBe(1);
+    if (isToolGroup(merged[0])) {
+      expect(merged[0].tools.map((t) => t.callId)).toEqual(['c1', 'c2']);
+    }
+  });
+
   it('preserves trailing gemini_thought after merged group', () => {
     const items: HistoryItem[] = [
       createToolGroup(1, [createTool('c1', 'Shell', ToolCallStatus.Success)]),
diff --git a/packages/cli/src/ui/utils/mergeCompactToolGroups.ts b/packages/cli/src/ui/utils/mergeCompactToolGroups.ts
index 087cdb82f..a5540e178 100644
--- a/packages/cli/src/ui/utils/mergeCompactToolGroups.ts
+++ b/packages/cli/src/ui/utils/mergeCompactToolGroups.ts
@@ -34,8 +34,12 @@ function isAgentWithPendingConfirmation(
 /**
  * Check if a tool_group history item should be excluded from merging due to force-expand conditions.
  * These conditions match ToolGroupMessage.tsx:105-112 showCompact logic.
+ * Exported so MainContent can determine which callIds get their label
+ * "absorbed" by the compact tool_group header vs which need the standalone
+ * `● <label>` line rendered (force-expanded groups never go through the
+ * compact path, so their label would otherwise be invisible).
  */
-function isForceExpandGroup(
+export function isForceExpandGroup(
   item: HistoryItem,
   embeddedShellFocused: boolean,
   activeShellPtyId: number | undefined,
@@ -83,12 +87,16 @@ function isForceExpandGroup(
 
 /**
  * Check if an item is hidden in compact mode (so it shouldn't break tool_group adjacency).
- * This mirrors HistoryItemDisplay.tsx:123-142 which hides gemini_thought / gemini_thought_content
- * when compactMode is true.
+ * This mirrors HistoryItemDisplay.tsx which hides:
+ *  - `gemini_thought` / `gemini_thought_content` (thinking — hidden when compactMode is true),
+ *  - `tool_use_summary` (consumed upstream to decorate the adjacent tool_group's label;
+ *    never rendered standalone so it must not break adjacency between two batches).
  */
 function isHiddenInCompactMode(item: HistoryItem): boolean {
   return (
-    item.type === 'gemini_thought' || item.type === 'gemini_thought_content'
+    item.type === 'gemini_thought' ||
+    item.type === 'gemini_thought_content' ||
+    item.type === 'tool_use_summary'
   );
 }
 
@@ -104,12 +112,20 @@ function isHiddenInCompactMode(item: HistoryItem): boolean {
  * @param items - History items array
  * @param embeddedShellFocused - Whether embedded shell is focused
  * @param activeShellPtyId - PTY ID of the active shell (if any)
+ * @param absorbedCallIds - Set of tool callIds whose summary label is consumed
+ *   by a compact-mode tool_group header (i.e., the corresponding tool_group is
+ *   NOT force-expanded). Summaries for these callIds are dropped from the
+ *   merged result so MainContent's refreshStatic heuristic fires and the
+ *   tool_group re-renders with its label. Summaries for force-expanded groups
+ *   pass through unchanged so HistoryItemDisplay can render them as standalone
+ *   `● <label>` lines (the compact path doesn't consume their label).
  * @returns New array with merged tool_groups (does not mutate input)
  */
 export function mergeCompactToolGroups(
   items: HistoryItem[],
   embeddedShellFocused: boolean = false,
   activeShellPtyId: number | undefined = undefined,
+  absorbedCallIds: ReadonlySet<string> = new Set(),
 ): HistoryItem[] {
   const result: HistoryItem[] = [];
   let i = 0;
@@ -117,6 +133,34 @@ export function mergeCompactToolGroups(
   while (i < items.length) {
     const item = items[i];
 
+    // Drop `tool_use_summary` items whose preceding callIds are *all* absorbed
+    // by a compact tool_group header. Those headers will display the label
+    // directly (via the `compactLabel` lookup in MainContent), so keeping the
+    // standalone summary in the merged result would either double-display the
+    // label (if HistoryItemDisplay rendered both) or, more importantly, would
+    // bump mergedHistory.length lock-step with history.length and prevent
+    // refreshStatic from firing — Ink's <Static> would never repaint the
+    // committed tool_group with the new label.
+    //
+    // Summaries with at least one non-absorbed preceding callId — e.g., when
+    // the corresponding tool_group is force-expanded (errors / confirming /
+    // user-initiated / focused shell) and renders through the full
+    // ToolGroupMessage path that does not consume `compactLabel` — must
+    // survive in the merged result so HistoryItemDisplay can render them as
+    // standalone `● <label>` lines.
+    if (item.type === 'tool_use_summary') {
+      const allAbsorbed =
+        item.precedingToolUseIds.length > 0 &&
+        item.precedingToolUseIds.every((id) => absorbedCallIds.has(id));
+      if (allAbsorbed) {
+        i++;
+        continue;
+      }
+      result.push(item);
+      i++;
+      continue;
+    }
+
     // Pass through non-mergeable items unchanged
     if (
       item.type !== 'tool_group' ||
diff --git a/packages/core/src/config/config.ts b/packages/core/src/config/config.ts
index de4d151b1..c8753ab58 100644
--- a/packages/core/src/config/config.ts
+++ b/packages/core/src/config/config.ts
@@ -383,6 +383,7 @@ export interface ConfigParameters {
   sessionTokenLimit?: number;
   experimentalZedIntegration?: boolean;
   cronEnabled?: boolean;
+  emitToolUseSummaries?: boolean;
   listExtensions?: boolean;
   overrideExtensions?: string[];
   allowedMcpServers?: string[];
@@ -631,6 +632,7 @@ export class Config {
   private readonly cliVersion?: string;
   private readonly experimentalZedIntegration: boolean = false;
   private readonly cronEnabled: boolean = false;
+  private readonly emitToolUseSummaries: boolean = true;
   private readonly chatRecordingEnabled: boolean;
   private readonly loadMemoryFromIncludeDirectories: boolean = false;
   private readonly importFormat: 'tree' | 'flat';
@@ -773,6 +775,7 @@ export class Config {
     this.experimentalZedIntegration =
       params.experimentalZedIntegration ?? false;
     this.cronEnabled = params.cronEnabled ?? false;
+    this.emitToolUseSummaries = params.emitToolUseSummaries ?? true;
     this.listExtensions = params.listExtensions ?? false;
     this.overrideExtensions = params.overrideExtensions;
     this.noBrowser = params.noBrowser ?? false;
@@ -1990,6 +1993,22 @@ export class Config {
     return this.cronEnabled;
   }
 
+  /**
+   * Whether the turn loop should fire a fast-model call after each tool batch
+   * to emit a `tool_use_summary` message. Mirrors Claude Code's
+   * `CLAUDE_CODE_EMIT_TOOL_USE_SUMMARIES` gate, but defaults to on so the
+   * compact-mode UI benefits without configuration.
+   *
+   * Env overrides (either direction): `QWEN_CODE_EMIT_TOOL_USE_SUMMARIES=0`
+   * to force off, `=1` to force on.
+   */
+  getEmitToolUseSummaries(): boolean {
+    const env = process.env['QWEN_CODE_EMIT_TOOL_USE_SUMMARIES'];
+    if (env === '0' || env === 'false') return false;
+    if (env === '1' || env === 'true') return true;
+    return this.emitToolUseSummaries;
+  }
+
   getEnableRecursiveFileSearch(): boolean {
     return this.fileFiltering.enableRecursiveFileSearch;
   }
diff --git a/packages/core/src/index.ts b/packages/core/src/index.ts
index 985dda01c..98e43709c 100644
--- a/packages/core/src/index.ts
+++ b/packages/core/src/index.ts
@@ -147,6 +147,7 @@ export * from './services/sessionService.js';
 export * from './services/sessionTitle.js';
 export { stripTerminalControlSequences } from './utils/terminalSafe.js';
 export * from './services/shellExecutionService.js';
+export * from './services/toolUseSummary.js';
 export * from './utils/bareMode.js';
 
 // ============================================================================
diff --git a/packages/core/src/services/toolUseSummary.test.ts b/packages/core/src/services/toolUseSummary.test.ts
new file mode 100644
index 000000000..bc6649bbc
--- /dev/null
+++ b/packages/core/src/services/toolUseSummary.test.ts
@@ -0,0 +1,409 @@
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import type { Config } from '../config/config.js';
+import {
+  cleanSummary,
+  createToolUseSummaryMessage,
+  generateToolUseSummary,
+  TOOL_USE_SUMMARY_SYSTEM_PROMPT,
+  truncateJson,
+} from './toolUseSummary.js';
+
+// Sanity helper for the pre-truncation tests: `y` count in the output must
+// be less than maxLength (since JSON quoting and the field name eat some of
+// the budget) — confirming the input never reached its full 10MB form.
+function maxLengthGuard(maxLength: number) {
+  return maxLength;
+}
+
+describe('truncateJson', () => {
+  it('returns JSON for short values', () => {
+    expect(truncateJson({ foo: 'bar' }, 100)).toBe('{"foo":"bar"}');
+    expect(truncateJson('hello', 100)).toBe('"hello"');
+    expect(truncateJson(42, 100)).toBe('42');
+  });
+
+  it('truncates long values with ellipsis', () => {
+    const long = 'x'.repeat(500);
+    const result = truncateJson(long, 50);
+    expect(result.length).toBe(50);
+    expect(result.endsWith('...')).toBe(true);
+  });
+
+  it('handles undefined', () => {
+    expect(truncateJson(undefined, 100)).toBe('[undefined]');
+  });
+
+  it('pre-truncates large string leaves before JSON serialization', () => {
+    // Ensures we don't allocate the full JSON for a 10MB string just to
+    // slice it to maxLength. The result must still be ≤ maxLength.
+    const huge = 'x'.repeat(10_000_000);
+    const result = truncateJson(huge, 300);
+    expect(result.length).toBeLessThanOrEqual(300);
+    expect(result.endsWith('...')).toBe(true);
+  });
+
+  it('pre-truncates large string fields inside objects', () => {
+    // The point: a 10MB string field must not be fully serialized before the
+    // outer cap is applied (would allocate 10MB+ of JSON only to slice it).
+    // Pre-truncation slices each string leaf to maxLength first, so the
+    // serializer never sees the full payload.
+    const obj = { content: 'y'.repeat(10_000_000) };
+    const result = truncateJson(obj, 300);
+    expect(result.length).toBeLessThanOrEqual(300);
+    // The huge field is truncated to <= maxLength characters — far below
+    // its original 10M length.
+    const yCount = (result.match(/y/g) ?? []).length;
+    expect(yCount).toBeLessThan(maxLengthGuard(300));
+  });
+
+  it('handles circular references gracefully', () => {
+    const circular: Record<string, unknown> = {};
+    circular['self'] = circular;
+    expect(truncateJson(circular, 100)).toBe('[unable to serialize]');
+  });
+});
+
+describe('cleanSummary', () => {
+  it('preserves well-formed labels', () => {
+    expect(cleanSummary('Searched in auth/')).toBe('Searched in auth/');
+    expect(cleanSummary('Fixed NPE in UserService')).toBe(
+      'Fixed NPE in UserService',
+    );
+  });
+
+  it('takes first line only', () => {
+    expect(cleanSummary('Created signup endpoint\nSome reasoning')).toBe(
+      'Created signup endpoint',
+    );
+  });
+
+  it('strips surrounding quotes', () => {
+    expect(cleanSummary('"Read config.json"')).toBe('Read config.json');
+    expect(cleanSummary("'Ran failing tests'")).toBe('Ran failing tests');
+    expect(cleanSummary('`Fixed bug`')).toBe('Fixed bug');
+  });
+
+  it('strips leading bullet/dash', () => {
+    expect(cleanSummary('- Searched auth')).toBe('Searched auth');
+    expect(cleanSummary('* Read files')).toBe('Read files');
+    expect(cleanSummary('• Fixed NPE')).toBe('Fixed NPE');
+  });
+
+  it('strips Label:/Summary: prefixes', () => {
+    expect(cleanSummary('Label: Fixed bug')).toBe('Fixed bug');
+    expect(cleanSummary('Summary: Ran tests')).toBe('Ran tests');
+    expect(cleanSummary('Label:Searched files')).toBe('Searched files');
+  });
+
+  it('rejects error messages', () => {
+    expect(cleanSummary('API error: 500')).toBe('');
+    expect(cleanSummary('Error: something went wrong')).toBe('');
+    expect(cleanSummary('I cannot generate a summary')).toBe('');
+    expect(cleanSummary("I can't help with that")).toBe('');
+    expect(cleanSummary('Unable to determine')).toBe('');
+  });
+
+  it('caps length at 100 chars', () => {
+    const long = 'x'.repeat(200);
+    expect(cleanSummary(long).length).toBe(100);
+  });
+
+  it('returns empty for empty/whitespace input', () => {
+    expect(cleanSummary('')).toBe('');
+    expect(cleanSummary('   ')).toBe('');
+    expect(cleanSummary('\n\n')).toBe('');
+  });
+
+  it('preserves CJK labels', () => {
+    expect(cleanSummary('搜索了 auth 模块')).toBe('搜索了 auth 模块');
+  });
+
+  it('strips Unicode curly quotes', () => {
+    expect(cleanSummary('“Read config.json”')).toBe('Read config.json');
+    expect(cleanSummary('‘Ran tests’')).toBe('Ran tests');
+  });
+
+  it('strips CJK corner brackets', () => {
+    expect(cleanSummary('「搜索了 auth 模块」')).toBe('搜索了 auth 模块');
+    expect(cleanSummary('『Fixed bug』')).toBe('Fixed bug');
+  });
+
+  it('strips markdown emphasis markers', () => {
+    expect(cleanSummary('**Read 4 files**')).toBe('Read 4 files');
+    expect(cleanSummary('_Searched auth_')).toBe('Searched auth');
+    expect(cleanSummary('__Fixed NPE__')).toBe('Fixed NPE');
+  });
+
+  it('rejects Chinese refusal responses', () => {
+    expect(cleanSummary('我无法生成摘要')).toBe('');
+    expect(cleanSummary('我不能回答这个')).toBe('');
+    expect(cleanSummary('抱歉，我不能帮助')).toBe('');
+    expect(cleanSummary('无法确定')).toBe('');
+    expect(cleanSummary('无法完成')).toBe('');
+  });
+
+  it('rejects curly-apostrophe English refusals', () => {
+    // U+2019 right single quotation mark — models often emit this for
+    // typographic apostrophes and the ASCII-only check missed it.
+    expect(cleanSummary('I can’t generate that')).toBe('');
+  });
+
+  it('rejects additional English refusal patterns', () => {
+    expect(cleanSummary('Failed to read files')).toBe('');
+    expect(cleanSummary('Sorry, I cannot')).toBe('');
+    expect(cleanSummary('Request failed')).toBe('');
+  });
+});
+
+describe('createToolUseSummaryMessage', () => {
+  it('creates a message with generated uuid and timestamp', () => {
+    const msg = createToolUseSummaryMessage('Fixed bug', ['call-1', 'call-2']);
+    expect(msg.type).toBe('tool_use_summary');
+    expect(msg.summary).toBe('Fixed bug');
+    expect(msg.precedingToolUseIds).toEqual(['call-1', 'call-2']);
+    expect(msg.uuid).toMatch(/^[0-9a-f-]{36}$/);
+    expect(msg.timestamp).toMatch(/^\d{4}-\d{2}-\d{2}T/);
+  });
+
+  it('generates distinct uuids', () => {
+    const a = createToolUseSummaryMessage('a', []);
+    const b = createToolUseSummaryMessage('b', []);
+    expect(a.uuid).not.toBe(b.uuid);
+  });
+});
+
+describe('generateToolUseSummary', () => {
+  const makeMockConfig = (
+    fastModel: string | undefined,
+    generateContentFn?: ReturnType<typeof vi.fn>,
+  ): Config => {
+    const mockClient = generateContentFn
+      ? { generateContent: generateContentFn }
+      : undefined;
+    return {
+      getFastModel: () => fastModel,
+      getGeminiClient: () => mockClient,
+    } as unknown as Config;
+  };
+
+  const abortController = (): AbortController => new AbortController();
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('returns null when tools array is empty', async () => {
+    const config = makeMockConfig('qwen-fast');
+    const result = await generateToolUseSummary({
+      config,
+      tools: [],
+      signal: abortController().signal,
+    });
+    expect(result).toBeNull();
+  });
+
+  it('returns null when no fast model is configured', async () => {
+    const config = makeMockConfig(undefined);
+    const result = await generateToolUseSummary({
+      config,
+      tools: [{ name: 'Read', input: { file: 'a.ts' }, output: '...' }],
+      signal: abortController().signal,
+    });
+    expect(result).toBeNull();
+  });
+
+  it('returns null when signal is already aborted', async () => {
+    const config = makeMockConfig('qwen-fast');
+    const ac = abortController();
+    ac.abort();
+    const result = await generateToolUseSummary({
+      config,
+      tools: [{ name: 'Read', input: {}, output: '' }],
+      signal: ac.signal,
+    });
+    expect(result).toBeNull();
+  });
+
+  it('calls model with fast model id and system prompt', async () => {
+    const generateContentFn = vi.fn().mockResolvedValue({
+      candidates: [
+        {
+          content: { parts: [{ text: 'Searched in auth/' }] },
+        },
+      ],
+    });
+    const config = makeMockConfig('qwen-fast', generateContentFn);
+
+    const result = await generateToolUseSummary({
+      config,
+      tools: [
+        { name: 'Grep', input: { pattern: 'login' }, output: '3 matches' },
+      ],
+      signal: abortController().signal,
+    });
+
+    expect(result).toBe('Searched in auth/');
+    expect(generateContentFn).toHaveBeenCalledTimes(1);
+
+    const args = generateContentFn.mock.calls[0];
+    const [contents, generationConfig, , model, promptId] = args;
+
+    expect(model).toBe('qwen-fast');
+    expect(promptId).toBe('tool_use_summary_generation');
+    expect(generationConfig.systemInstruction).toBe(
+      TOOL_USE_SUMMARY_SYSTEM_PROMPT,
+    );
+    expect(generationConfig.tools).toEqual([]);
+
+    const userText = contents[0].parts[0].text as string;
+    expect(userText).toContain('Tool: Grep');
+    expect(userText).toContain('"pattern":"login"');
+    expect(userText).toContain('3 matches');
+    expect(userText).toContain('Label:');
+  });
+
+  it('includes lastAssistantText as intent prefix', async () => {
+    const generateContentFn = vi.fn().mockResolvedValue({
+      candidates: [{ content: { parts: [{ text: 'Fixed auth bug' }] } }],
+    });
+    const config = makeMockConfig('qwen-fast', generateContentFn);
+
+    await generateToolUseSummary({
+      config,
+      tools: [{ name: 'Edit', input: {}, output: '' }],
+      signal: abortController().signal,
+      lastAssistantText:
+        'I will now fix the authentication bug in the login flow.',
+    });
+
+    const userText = generateContentFn.mock.calls[0][0][0].parts[0]
+      .text as string;
+    expect(userText).toContain(
+      "User's intent (from assistant's last message):",
+    );
+    expect(userText).toContain('fix the authentication bug');
+  });
+
+  it('truncates lastAssistantText to 200 chars', async () => {
+    const generateContentFn = vi.fn().mockResolvedValue({
+      candidates: [{ content: { parts: [{ text: 'Done' }] } }],
+    });
+    const config = makeMockConfig('qwen-fast', generateContentFn);
+
+    const longText = 'A'.repeat(500);
+    await generateToolUseSummary({
+      config,
+      tools: [{ name: 'Edit', input: {}, output: '' }],
+      signal: abortController().signal,
+      lastAssistantText: longText,
+    });
+
+    const userText = generateContentFn.mock.calls[0][0][0].parts[0]
+      .text as string;
+    // 200 As + some wrapper text, but no 500 As
+    expect(userText).toContain('A'.repeat(200));
+    expect(userText).not.toContain('A'.repeat(201));
+  });
+
+  it('uses explicit model parameter over config fast model', async () => {
+    const generateContentFn = vi.fn().mockResolvedValue({
+      candidates: [{ content: { parts: [{ text: 'Done' }] } }],
+    });
+    const config = makeMockConfig('qwen-fast', generateContentFn);
+
+    await generateToolUseSummary({
+      config,
+      tools: [{ name: 'Edit', input: {}, output: '' }],
+      signal: abortController().signal,
+      model: 'qwen-turbo-explicit',
+    });
+
+    expect(generateContentFn.mock.calls[0][3]).toBe('qwen-turbo-explicit');
+  });
+
+  it('returns null when model returns empty text', async () => {
+    const generateContentFn = vi.fn().mockResolvedValue({
+      candidates: [{ content: { parts: [{ text: '' }] } }],
+    });
+    const config = makeMockConfig('qwen-fast', generateContentFn);
+
+    const result = await generateToolUseSummary({
+      config,
+      tools: [{ name: 'Read', input: {}, output: '' }],
+      signal: abortController().signal,
+    });
+    expect(result).toBeNull();
+  });
+
+  it('returns null when model call throws', async () => {
+    const generateContentFn = vi.fn().mockRejectedValue(new Error('API error'));
+    const config = makeMockConfig('qwen-fast', generateContentFn);
+
+    const result = await generateToolUseSummary({
+      config,
+      tools: [{ name: 'Read', input: {}, output: '' }],
+      signal: abortController().signal,
+    });
+    expect(result).toBeNull();
+  });
+
+  it('returns null when the signal aborts during the call', async () => {
+    const ac = abortController();
+    const generateContentFn = vi.fn().mockImplementation(async () => {
+      ac.abort();
+      throw new Error('aborted');
+    });
+    const config = makeMockConfig('qwen-fast', generateContentFn);
+
+    const result = await generateToolUseSummary({
+      config,
+      tools: [{ name: 'Read', input: {}, output: '' }],
+      signal: ac.signal,
+    });
+    expect(result).toBeNull();
+  });
+
+  it('truncates tool input/output to 300 chars', async () => {
+    const generateContentFn = vi.fn().mockResolvedValue({
+      candidates: [{ content: { parts: [{ text: 'Read file' }] } }],
+    });
+    const config = makeMockConfig('qwen-fast', generateContentFn);
+
+    const hugeInput = { content: 'x'.repeat(10000) };
+    const hugeOutput = 'y'.repeat(10000);
+
+    await generateToolUseSummary({
+      config,
+      tools: [{ name: 'Read', input: hugeInput, output: hugeOutput }],
+      signal: abortController().signal,
+    });
+
+    const userText = generateContentFn.mock.calls[0][0][0].parts[0]
+      .text as string;
+    // Each field capped at 300, so overall prompt shouldn't contain the
+    // full 10K repetition.
+    expect(userText).not.toContain('x'.repeat(500));
+    expect(userText).not.toContain('y'.repeat(500));
+    expect(userText).toContain('...');
+  });
+
+  it('cleans markdown bullets / quotes from model output', async () => {
+    const generateContentFn = vi.fn().mockResolvedValue({
+      candidates: [{ content: { parts: [{ text: '- "Searched auth/"' }] } }],
+    });
+    const config = makeMockConfig('qwen-fast', generateContentFn);
+
+    const result = await generateToolUseSummary({
+      config,
+      tools: [{ name: 'Grep', input: {}, output: '' }],
+      signal: abortController().signal,
+    });
+    expect(result).toBe('Searched auth/');
+  });
+});
diff --git a/packages/core/src/services/toolUseSummary.ts b/packages/core/src/services/toolUseSummary.ts
new file mode 100644
index 000000000..aa2007155
--- /dev/null
+++ b/packages/core/src/services/toolUseSummary.ts
@@ -0,0 +1,309 @@
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Tool Use Summary Generator
+ *
+ * Generates a short human-readable label (git-commit-subject style, ~30 chars)
+ * describing what a batch of tool calls accomplished. Uses the configured fast
+ * model so the call is cheap; runs in parallel with the next turn's API call so
+ * its ~1s latency is hidden behind the 5-30s main-model streaming.
+ *
+ * Ported from Claude Code (`services/toolUseSummary/toolUseSummaryGenerator.ts`).
+ * The system prompt is verbatim; the input/output shape and truncation rules
+ * are preserved for behavioral parity with the SDK `tool_use_summary` message.
+ */
+
+import { randomUUID } from 'node:crypto';
+import type { Config } from '../config/config.js';
+import { getResponseText } from '../utils/partUtils.js';
+import { createDebugLogger } from '../utils/debugLogger.js';
+
+const debugLogger = createDebugLogger('TOOL_USE_SUMMARY');
+
+/**
+ * Message emitted into the stream after a tool batch completes with a
+ * successful summary. Mirrors Claude Code's `ToolUseSummaryMessage` so SDK
+ * clients consuming either stream see a compatible shape.
+ */
+export interface ToolUseSummaryMessage {
+  type: 'tool_use_summary';
+  summary: string;
+  /** Tool-use call IDs this summary describes. */
+  precedingToolUseIds: string[];
+  uuid: string;
+  timestamp: string;
+}
+
+/**
+ * Creates a `tool_use_summary` message. The UUID and timestamp are generated
+ * here so the message is immediately serializable for recording/SDK emission.
+ */
+export function createToolUseSummaryMessage(
+  summary: string,
+  precedingToolUseIds: string[],
+): ToolUseSummaryMessage {
+  return {
+    type: 'tool_use_summary',
+    summary,
+    precedingToolUseIds,
+    uuid: randomUUID(),
+    timestamp: new Date().toISOString(),
+  };
+}
+
+export const TOOL_USE_SUMMARY_SYSTEM_PROMPT = `Write a short summary label describing what these tool calls accomplished. It appears as a single-line row in a mobile app and truncates around 30 characters, so think git-commit-subject, not sentence.
+
+Keep the verb in past tense and the most distinctive noun. Drop articles, connectors, and long location context first.
+
+Examples:
+- Searched in auth/
+- Fixed NPE in UserService
+- Created signup endpoint
+- Read config.json
+- Ran failing tests`;
+
+/** Max characters per input/output field fed to the summarizer. */
+const INPUT_TRUNCATE_LENGTH = 300;
+/** Max characters of the last assistant text included as user-intent prefix. */
+const LAST_ASSISTANT_TEXT_LENGTH = 200;
+/** Output length cap. Matches mobile UI truncation behavior. */
+const MAX_SUMMARY_LENGTH = 100;
+
+export interface ToolInfo {
+  name: string;
+  input: unknown;
+  output: unknown;
+}
+
+export interface GenerateToolUseSummaryParams {
+  config: Config;
+  tools: ToolInfo[];
+  signal: AbortSignal;
+  /**
+   * Trailing text from the assistant's last message, used as intent prefix
+   * so the summarizer knows what the user was trying to accomplish.
+   */
+  lastAssistantText?: string;
+  /**
+   * Fast model to use. If omitted, falls back to `config.getFastModel()`;
+   * if that also returns undefined, the call is skipped (returns null).
+   * Unlike `sessionRecap`, this does not fall back to the main model —
+   * summary generation is a nice-to-have and must not incur main-model cost.
+   */
+  model?: string;
+}
+
+/**
+ * Generates a short label for a completed tool batch.
+ *
+ * @returns The summary string, or null when skipped (no tools, no fast model,
+ * aborted, or model failure). Non-critical: callers should not surface errors.
+ */
+export async function generateToolUseSummary(
+  params: GenerateToolUseSummaryParams,
+): Promise<string | null> {
+  const { config, tools, signal, lastAssistantText } = params;
+
+  if (tools.length === 0) {
+    return null;
+  }
+
+  const model = params.model ?? config.getFastModel();
+  if (!model) {
+    debugLogger.debug('No fast model configured — skipping summary generation');
+    return null;
+  }
+
+  if (signal.aborted) {
+    return null;
+  }
+
+  try {
+    const toolSummaries = tools
+      .map((tool) => {
+        const inputStr = truncateJson(tool.input, INPUT_TRUNCATE_LENGTH);
+        const outputStr = truncateJson(tool.output, INPUT_TRUNCATE_LENGTH);
+        return `Tool: ${tool.name}\nInput: ${inputStr}\nOutput: ${outputStr}`;
+      })
+      .join('\n\n');
+
+    const contextPrefix = lastAssistantText
+      ? `User's intent (from assistant's last message): ${lastAssistantText.slice(0, LAST_ASSISTANT_TEXT_LENGTH)}\n\n`
+      : '';
+
+    const userPrompt = `${contextPrefix}Tools completed:\n\n${toolSummaries}\n\nLabel:`;
+
+    const geminiClient = config.getGeminiClient();
+    if (!geminiClient) {
+      debugLogger.debug('No gemini client available — skipping');
+      return null;
+    }
+
+    const response = await geminiClient.generateContent(
+      [{ role: 'user', parts: [{ text: userPrompt }] }],
+      {
+        systemInstruction: TOOL_USE_SUMMARY_SYSTEM_PROMPT,
+        tools: [],
+        maxOutputTokens: 60,
+        temperature: 0.3,
+      },
+      signal,
+      model,
+      'tool_use_summary_generation',
+    );
+
+    if (signal.aborted) return null;
+
+    const raw = getResponseText(response)?.trim();
+    if (!raw) {
+      debugLogger.debug('Summary generation returned empty result');
+      return null;
+    }
+
+    const cleaned = cleanSummary(raw);
+    if (!cleaned) {
+      debugLogger.debug(`Summary cleaned to empty: raw="${raw}"`);
+      return null;
+    }
+
+    debugLogger.debug(`Summary generated: "${cleaned}"`);
+    return cleaned;
+  } catch (err) {
+    if (signal.aborted) return null;
+    debugLogger.warn(
+      `Summary generation failed: ${err instanceof Error ? err.message : String(err)}`,
+    );
+    return null;
+  }
+}
+
+/**
+ * Truncates a JSON value to a maximum length for the prompt. Mirrors
+ * Claude Code's `truncateJson` behavior (including the `...` suffix).
+ *
+ * For large string inputs, pre-truncates BEFORE serialization to avoid
+ * allocating the full JSON representation on the interactive turn path —
+ * a 10MB ReadFile result would otherwise be fully stringified just to be
+ * sliced down to 300 chars and discarded.
+ *
+ * For object/array inputs, recursively pre-truncates string fields one
+ * level deep before serialization. Tool inputs (`args`) and outputs
+ * (functionResponse content) are typically shallow objects with the
+ * dominant cost in a small number of long string fields.
+ */
+export function truncateJson(value: unknown, maxLength: number): string {
+  try {
+    const pre = preTruncate(value, maxLength);
+    const str = JSON.stringify(pre);
+    if (str == null) return '[undefined]';
+    return str.length <= maxLength ? str : str.slice(0, maxLength - 3) + '...';
+  } catch {
+    return '[unable to serialize]';
+  }
+}
+
+/**
+ * Walks an arbitrary value and pre-truncates string leaves that exceed
+ * `maxLength`. Bounded to depth 4 to keep the cost predictable on deeply
+ * nested objects (rare in tool args/outputs but possible).
+ */
+function preTruncate(value: unknown, maxLength: number, depth = 0): unknown {
+  if (value === null || value === undefined) return value;
+  if (typeof value === 'string') {
+    return value.length > maxLength ? value.slice(0, maxLength) : value;
+  }
+  if (depth >= 4) return value;
+  if (Array.isArray(value)) {
+    return value.map((v) => preTruncate(v, maxLength, depth + 1));
+  }
+  if (typeof value === 'object') {
+    const out: Record<string, unknown> = {};
+    for (const [k, v] of Object.entries(value as Record<string, unknown>)) {
+      out[k] = preTruncate(v, maxLength, depth + 1);
+    }
+    return out;
+  }
+  return value;
+}
+
+/**
+ * Strips markdown, quotes, and common prefix noise from the model's raw
+ * response. Enforces `MAX_SUMMARY_LENGTH` as a hard cap — the mobile UI
+ * truncates around 30 chars, but we allow some slack so unusual-but-useful
+ * labels (e.g. CJK phrases) survive. Returns empty string if the result is
+ * unusable (error message, prefixed label, etc.).
+ */
+/**
+ * Character class covering ASCII and common Unicode quote / bracket-quote
+ * pairs. Chinese-instruct models frequently emit U+2018/U+2019 (curly single),
+ * U+201C/U+201D (curly double), U+300C-F (CJK corner brackets). Bounded
+ * quantifier keeps the regex linear (js/polynomial-redos).
+ */
+const QUOTE_CHARS = '"\'`‘’“”「」『』';
+const LEADING_QUOTES_RE = new RegExp(`^[${QUOTE_CHARS}]{1,10}`);
+const TRAILING_QUOTES_RE = new RegExp(`[${QUOTE_CHARS}]{1,10}$`);
+
+/**
+ * Error/refusal-like response markers, matched case-insensitively anywhere
+ * the label should not produce. Covers English and Chinese refusals common
+ * in mixed-provider deployments.
+ */
+const REFUSAL_PREFIXES = [
+  /^api error\b/i,
+  /^error[:：]/i,
+  // Match "I can't" (ASCII U+0027 apostrophe), "I can’t" (curly U+2019),
+  // and "I cannot" as a single pattern.
+  /^i can(?:['’]t|not)\b/i,
+  /^unable to\b/i,
+  /^failed to\b/i,
+  /^sorry[,，]/i,
+  /^request failed\b/i,
+  /^我无法/,
+  /^我不能/,
+  /^抱歉[,，]?/,
+  /^无法/,
+];
+
+export function cleanSummary(raw: string): string {
+  // Take first line only
+  let text = raw.split('\n')[0]?.trim() ?? '';
+
+  // Strip leading bullet/dash first — otherwise a bulleted quoted label like
+  // `- "Searched auth/"` would keep its leading quote after the trailing one
+  // is stripped.
+  text = text.replace(/^[-*•]\s+/, '').trim();
+
+  // Strip markdown emphasis (`**bold**`, `__bold__`, `_italic_`). Bounded
+  // quantifiers keep the regex linear.
+  text = text
+    .replace(/^[*_]{1,3}/, '')
+    .replace(/[*_]{1,3}$/, '')
+    .trim();
+
+  // Strip surrounding ASCII + Unicode quotes/backticks.
+  text = text
+    .replace(LEADING_QUOTES_RE, '')
+    .replace(TRAILING_QUOTES_RE, '')
+    .trim();
+
+  // Strip common prefix labels like "Label:" "Summary:"
+  text = text.replace(/^(label|summary|result|output)\s*[:：]\s*/i, '').trim();
+
+  if (!text) return '';
+
+  // Reject error/refusal-like responses (English + Chinese variants).
+  for (const re of REFUSAL_PREFIXES) {
+    if (re.test(text)) return '';
+  }
+
+  // Hard cap length
+  if (text.length > MAX_SUMMARY_LENGTH) {
+    text = text.slice(0, MAX_SUMMARY_LENGTH).trim();
+  }
+
+  return text;
+}
diff --git a/packages/vscode-ide-companion/schemas/settings.schema.json b/packages/vscode-ide-companion/schemas/settings.schema.json
index ba5d3be73..09d5b73b9 100644
--- a/packages/vscode-ide-companion/schemas/settings.schema.json
+++ b/packages/vscode-ide-companion/schemas/settings.schema.json
@@ -2010,6 +2010,11 @@
           "description": "Enable in-session cron/loop tools (experimental). When enabled, the model can create recurring prompts using cron_create, cron_list, and cron_delete tools. Can also be enabled via QWEN_CODE_ENABLE_CRON=1 environment variable.",
           "type": "boolean",
           "default": false
+        },
+        "emitToolUseSummaries": {
+          "description": "Generate a short LLM-based label after each tool batch completes. In compact mode the label replaces the generic `Tool × N` header; in full mode it appears as a dim `● <label>` line below the tool group. Requires a fast model to be configured; runs in parallel with the next API call so latency is hidden. Currently affects interactive CLI rendering only — SDK / non-interactive emission of the `tool_use_summary` message is not yet wired (the message factory is exported for a follow-up PR). Can be overridden with QWEN_CODE_EMIT_TOOL_USE_SUMMARIES=0 or =1.",
+          "type": "boolean",
+          "default": true
         }
       }
     },