diff --git a/docs/design/tool-use-summary/unified-tool-output.md b/docs/design/tool-use-summary/unified-tool-output.md
new file mode 100644
index 00000000000..41f3ee2dc26
--- /dev/null
+++ b/docs/design/tool-use-summary/unified-tool-output.md
@@ -0,0 +1,68 @@
+# Unified Tool Output Rendering
+
+## Background
+
+The TUI previously had two rendering modes for tool results:
+
+- **Compact mode** (Ctrl+O): collapsed completed tool results into a one-line summary
+- **Normal mode**: showed full tool results inline, causing excessive vertical noise
+
+Users had to manually toggle between modes. Most of the time, completed tool results (file contents, search results, etc.) added no value to the conversation flow.
+
+## Design
+
+### Core Principle
+
+**One unified mode**: tool rendering is determined by tool category, not by a user-toggled mode. Information-gathering tools (read/search/list) are collapsed into a summary; mutation tools (edit/write/command/agent) always render individually with full results.
+
+### Semantic Summary (`buildToolSummary`)
+
+Instead of showing raw tool names and counts (`ReadFile x 3`), generate human-readable summaries using a count-based format:
+
+| Scenario           | Output                                        |
+| ------------------ | --------------------------------------------- |
+| Single tool        | `Read 1 file` / `Ran 1 command`               |
+| Multiple same-type | `Read 3 files`                                |
+| Mixed types        | `Ran 1 command, read 3 files, edited 2 files` |
+| Active (executing) | `Reading 1 file` (present progressive)        |
+| Completed          | `Read 1 file` (past tense)                    |
+
+### Tool Categories
+
+| Category | Display Names                | Past Verb | Active Verb | Collapsible |
+| -------- | ---------------------------- | --------- | ----------- | ----------- |
+| read     | ReadFile, Read File(s)       | Read      | Reading     | Yes         |
+| edit     | Edit, NotebookEdit           | Edited    | Editing     | No          |
+| write    | WriteFile                    | Wrote     | Writing     | No          |
+| search   | Grep, Glob                   | Searched  | Searching   | Yes         |
+| list     | ListFiles, Read Directory    | Listed    | Listing     | Yes         |
+| command  | Shell                        | Ran       | Running     | No          |
+| agent    | Agent, Workflow, SendMessage | Ran       | Running     | No          |
+| other    | (everything else)            | Used      | Using       | No          |
+
+### Rendering Rules
+
+1. **Type-based partition**: tools are split by `isCollapsibleTool()` — collapsible tools (read/search/list) render as a `CompactToolGroupDisplay` summary line; non-collapsible tools (edit/write/command/agent/other) render individually via `ToolMessage`
+2. **Memory-only groups** have a dedicated rendering path (read/write counts badge) that takes priority, but only when all ops succeed (`!hasErrorTool && every status === Success`)
+3. **Result collapse**: only collapsible tools with `Success` status have their text/ANSI output collapsed. Non-collapsible tools (including MCP tools, WebFetch, etc.) always show results. Canceled tools keep partial output visible
+4. **Tool names** render bold regardless of status, providing consistent styling across both `CompactToolGroupDisplay` and individual `ToolMessage` paths
+5. **Force-expand conditions**: when any tool in a group is confirming, errored, user-initiated, in a focused shell, or a terminal subagent, ALL tools render individually (no partition) with results forced visible only for the triggering tools (errored, confirming, terminal subagent) — successful siblings keep normal collapse behavior
+6. **`tool_use_summary`** items (LLM-generated semantic summaries) render unconditionally alongside `CompactToolGroupDisplay`'s mechanical count — they serve different purposes (semantic context vs tool count)
+7. **Memory badge**: rendered in both the all-collapsible path and the mixed path when memory ops are present in a non-memory-only group
+
+### Key Changes
+
+| File                          | Change                                                                                                                                            |
+| ----------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `CompactToolGroupDisplay.tsx` | Added `buildToolSummary()` with count format, `isCollapsibleTool()`, removed border styles                                                        |
+| `ToolMessage.tsx`             | `shouldCollapseResult` gated on `isCollapsibleTool()` and `Success` only; `isDim` removed                                                         |
+| `ToolGroupMessage.tsx`        | Type-based partition replaces `showCompact`; `forceShowResult` simplified to `forceExpandAll`; height budget accounts for collapsible summary row |
+| `MainContent.tsx`             | Removed `mergedHistory` alias, `absorbedCallIds`, `summaryByCallId`, cross-group merging                                                          |
+| `HistoryItemDisplay.tsx`      | `tool_use_summary` renders unconditionally (removed `summaryAbsorbed` gate)                                                                       |
+| `mergeCompactToolGroups.ts`   | `compactToggleHasVisualEffect` no longer triggers on `tool_group` (compact mode has no effect on tool rendering)                                  |
+
+## Alternatives Considered
+
+1. **Keep two modes with improved summaries**: Rejected — unnecessary cognitive overhead for users
+2. **Per-tool summary (Gemini CLI style)**: Each tool gets its own summary arrow. Rejected — still too verbose for large tool batches
+3. **Phased rollout**: Rejected — user preference for single implementation pass
diff --git a/packages/cli/src/ui/AppContainer.test.tsx b/packages/cli/src/ui/AppContainer.test.tsx
index 821bc39a0a3..4d0efe6e646 100644
--- a/packages/cli/src/ui/AppContainer.test.tsx
+++ b/packages/cli/src/ui/AppContainer.test.tsx
@@ -3443,7 +3443,7 @@ describe('AppContainer State Management', () => {
         );
       });
 
-      it('calls refreshStatic on Ctrl+O when history contains a tool_group', () => {
+      it('skips refreshStatic on Ctrl+O when history contains only tool_group (no visual effect)', () => {
         mockedUseHistory.mockReturnValue({
           history: [
             { type: 'user', id: 1, text: 'run ls' },
@@ -3483,7 +3483,7 @@ describe('AppContainer State Management', () => {
         expect(handler).toBeDefined();
         handler!(ctrlOKey);
 
-        expect(mockStdout.write).toHaveBeenCalledWith(
+        expect(mockStdout.write).not.toHaveBeenCalledWith(
           ansiEscapes.clearTerminal,
         );
       });
diff --git a/packages/cli/src/ui/components/HistoryItemDisplay.tsx b/packages/cli/src/ui/components/HistoryItemDisplay.tsx
index 3d6871c1057..69a1fcecbd6 100644
--- a/packages/cli/src/ui/components/HistoryItemDisplay.tsx
+++ b/packages/cli/src/ui/components/HistoryItemDisplay.tsx
@@ -57,7 +57,6 @@ import { BtwMessage } from './messages/BtwMessage.js';
 import { MemorySavedMessage } from './messages/MemorySavedMessage.js';
 import { DiffStatsDisplay } from './messages/DiffStatsDisplay.js';
 import { GoalStatusMessage } from './messages/GoalStatusMessage.js';
-import { useCompactMode } from '../contexts/CompactModeContext.js';
 import { useSettings } from '../contexts/SettingsContext.js';
 import { useThoughtExpanded } from '../contexts/ThoughtExpandedContext.js';
 import { useThinkingViewer } from '../contexts/ThinkingViewerContext.js';
@@ -76,21 +75,6 @@ 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;
   sourceCopyIndexOffsets?: MarkdownSourceCopyIndexOffsets;
   /** Force thinking blocks expanded (e.g. in SessionPreview). */
   thoughtExpanded?: boolean;
@@ -206,15 +190,12 @@ const HistoryItemDisplayComponent: React.FC<HistoryItemDisplayProps> = ({
   activeShellPtyId,
   embeddedShellFocused,
   availableTerminalHeightGemini,
-  compactLabel,
-  summaryAbsorbed = false,
   sourceCopyIndexOffsets,
   thoughtExpanded,
   thinkingFullText,
 }) => {
   const marginTop = getHistoryItemMarginTop(item);
 
-  const { compactMode } = useCompactMode();
   const contextThoughtExpanded = useThoughtExpanded();
   const resolvedThoughtExpanded = thoughtExpanded ?? contextThoughtExpanded;
   const settings = useSettings();
@@ -355,33 +336,13 @@ 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 === 'tool_use_summary' && (
+        <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 23752fd5975..81c41002866 100644
--- a/packages/cli/src/ui/components/MainContent.tsx
+++ b/packages/cli/src/ui/components/MainContent.tsx
@@ -12,19 +12,13 @@ import { ShowMoreLines } from './ShowMoreLines.js';
 import { Notifications } from './Notifications.js';
 import { OverflowProvider } from '../contexts/OverflowContext.js';
 import { useUIState } from '../contexts/UIStateContext.js';
-import { useUIActions } from '../contexts/UIActionsContext.js';
 import { useAppContext } from '../contexts/AppContext.js';
 import { AppHeader } from './AppHeader.js';
 import { DebugModeNotification } from './DebugModeNotification.js';
-import { useCompactMode } from '../contexts/CompactModeContext.js';
 import {
   countMarkdownSourceBlocks,
   type MarkdownSourceCopyIndexOffsets,
 } from '../utils/MarkdownDisplay.js';
-import {
-  isForceExpandGroup,
-  mergeCompactToolGroups,
-} from '../utils/mergeCompactToolGroups.js';
 import { buildThinkingFullTextMap } from '../utils/historyUtils.js';
 import { ScrollableList, SCROLL_TO_ITEM_END } from './shared/ScrollableList.js';
 
@@ -88,14 +82,6 @@ function initialReplayCount(length: number): number {
 // stable completed items when unrelated UIState fields change during streaming.
 const VirtualHistoryItem = memo(HistoryItemDisplay);
 
-// Stable empty Set used by `absorbedCallIds` when compact mode is off so the
-// memo returns a referentially-stable value across renders. Without this, every
-// re-render where compactMode is false produced a brand-new empty Set, which
-// invalidated `isSummaryAbsorbed`, then `renderVirtualItem`, then forced
-// `VirtualizedList.renderedItems` to recompute and call renderItem for every
-// item — defeating the static-item memo.
-const EMPTY_ABSORBED_CALL_IDS = new Set<string>();
-
 // Pure functions with no closure deps — defined outside the component so they
 // are stable references and never trigger useMemo/useCallback invalidation.
 const virtualEstimatedItemHeight = () => 3;
@@ -106,8 +92,6 @@ const virtualIsStaticItem = (item: HistoryItem) => item.id > 0;
 export const MainContent = () => {
   const { version } = useAppContext();
   const uiState = useUIState();
-  const uiActions = useUIActions();
-  const { compactMode, compactInline } = useCompactMode();
   const {
     pendingHistoryItems,
     terminalWidth,
@@ -123,206 +107,7 @@ export const MainContent = () => {
     [uiState.history],
   );
 
-  // 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.
-  // Content-stable absorbedCallIds: when the recomputed Set has identical
-  // membership to the previous render, return the previous reference. Avoids
-  // the cascade where activePtyId/embeddedShellFocused flips while a shell
-  // tool runs produce a fresh empty-or-same Set per tick, invalidating
-  // `isSummaryAbsorbed` → `renderVirtualItem` → every static item re-renders.
-  const prevAbsorbedCallIdsRef = useRef<Set<string>>(EMPTY_ABSORBED_CALL_IDS);
-  const absorbedCallIds = useMemo(() => {
-    // When no cross-group merge will happen (Static mode or compactInline),
-    // don't mark summaries as absorbed so the standalone `● <label>` line
-    // in HistoryItemDisplay can render — <Static> can't repaint committed
-    // items, so the label's only path to the screen is the standalone line.
-    if (!compactMode || !uiState.useTerminalBuffer || compactInline)
-      return EMPTY_ABSORBED_CALL_IDS;
-    const absorbed = new Set<string>();
-    for (const item of visibleHistory) {
-      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);
-    }
-    const prev = prevAbsorbedCallIdsRef.current;
-    if (prev.size === absorbed.size) {
-      let allMatch = true;
-      for (const id of absorbed) {
-        if (!prev.has(id)) {
-          allMatch = false;
-          break;
-        }
-      }
-      if (allMatch) return prev;
-    }
-    prevAbsorbedCallIdsRef.current = absorbed;
-    return absorbed;
-  }, [
-    compactMode,
-    compactInline,
-    visibleHistory,
-    uiState.embeddedShellFocused,
-    uiState.activePtyId,
-    uiState.useTerminalBuffer,
-  ]);
-
-  // Merge consecutive tool_groups for compact mode display. Summaries for
-  // absorbed call IDs are dropped during merging so the compact header can
-  // display the label directly; summaries for force-expanded (non-absorbed)
-  // groups pass through so HistoryItemDisplay can render them as standalone
-  // `● <label>` lines.
-  //
-  // Compact-mode content-stable: `mergeCompactToolGroups` always allocates a
-  // fresh array. With `activePtyId` / `embeddedShellFocused` in the deps,
-  // every streaming tick mid-shell-tool produced a new array even when
-  // membership was identical, defeating the Round-2 renderItem stability
-  // fix for compact-mode users. Pair-wise compare the new merged array to
-  // the previous one and return the previous reference when items align.
-  const prevMergedHistoryRef = useRef<HistoryItem[] | null>(null);
-  const mergedHistory = useMemo(() => {
-    if (!compactMode) {
-      prevMergedHistoryRef.current = visibleHistory;
-      return visibleHistory;
-    }
-    // <Static> is append-only: merging reduces item count, which <Static>
-    // can't handle without clearTerminal + remount (the flash we're fixing).
-    if (!uiState.useTerminalBuffer) {
-      prevMergedHistoryRef.current = visibleHistory;
-      return visibleHistory;
-    }
-    // compactInline: user opted into per-group display without cross-group merging.
-    if (compactInline) {
-      prevMergedHistoryRef.current = visibleHistory;
-      return visibleHistory;
-    }
-    const next = mergeCompactToolGroups(
-      visibleHistory,
-      uiState.embeddedShellFocused,
-      uiState.activePtyId,
-      absorbedCallIds,
-    );
-    const prev = prevMergedHistoryRef.current;
-    if (prev && prev.length === next.length) {
-      let same = true;
-      for (let i = 0; i < next.length; i++) {
-        if (prev[i] !== next[i]) {
-          same = false;
-          break;
-        }
-      }
-      if (same) return prev;
-    }
-    prevMergedHistoryRef.current = next;
-    return next;
-  }, [
-    compactMode,
-    compactInline,
-    visibleHistory,
-    uiState.useTerminalBuffer,
-    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 visibleHistory) {
-      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;
-  }, [visibleHistory]);
-
-  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;
-      // When merge is skipped (Static mode or compactInline), tool_groups
-      // render via the full ToolGroupMessage path which ignores compactLabel.
-      // The standalone `● <label>` line in HistoryItemDisplay is the label's
-      // only path to the screen. Suppress the header label to avoid
-      // double-display.
-      if (!uiState.useTerminalBuffer || compactInline) 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, uiState.useTerminalBuffer, compactInline],
-  );
-
-  // 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
-  // raw history. Static would not re-render the older items even though their
-  // content changed, so we explicitly call refreshStatic() to clear the
-  // terminal and re-render the merged view.
-  //
-  // Detection: if history length grew but mergedHistory length did NOT grow
-  // proportionally (i.e., a merge consolidated items), trigger a refresh.
-  const prevHistoryLengthRef = useRef(visibleHistory.length);
-  const prevMergedLengthRef = useRef(mergedHistory.length);
-  useEffect(() => {
-    if (!compactMode) {
-      prevHistoryLengthRef.current = visibleHistory.length;
-      prevMergedLengthRef.current = mergedHistory.length;
-      return;
-    }
-    const prevHLen = prevHistoryLengthRef.current;
-    const currHLen = visibleHistory.length;
-    const prevMLen = prevMergedLengthRef.current;
-    const currMLen = mergedHistory.length;
-    // History grew, but merged length stayed same or shrank → a merge happened.
-    if (currHLen > prevHLen && currMLen <= prevMLen) {
-      uiActions.refreshStatic();
-    }
-    prevHistoryLengthRef.current = currHLen;
-    prevMergedLengthRef.current = currMLen;
-  }, [compactMode, visibleHistory, mergedHistory, uiActions]);
+  // History is rendered as-is (no cross-group merging).
 
   // Virtual viewport path short-circuits below before any of the
   // <Static>-only machinery is needed. The offsets / progressive-replay
@@ -334,7 +119,7 @@ export const MainContent = () => {
     useMemo(() => {
       let runningOffsets = createEmptySourceCopyOffsets();
 
-      const items = mergedHistory.map((item) => {
+      const items = visibleHistory.map((item) => {
         if (item.type === 'gemini') {
           runningOffsets = createEmptySourceCopyOffsets();
           const offsets = cloneSourceCopyOffsets(runningOffsets);
@@ -359,7 +144,7 @@ export const MainContent = () => {
         historyItemsWithSourceCopyOffsets: items,
         pendingStartSourceCopyOffsets: cloneSourceCopyOffsets(runningOffsets),
       };
-    }, [mergedHistory]);
+    }, [visibleHistory]);
 
   const pendingHistoryItemsWithSourceCopyOffsets = useMemo(() => {
     let runningOffsets = cloneSourceCopyOffsets(pendingStartSourceCopyOffsets);
@@ -388,18 +173,18 @@ export const MainContent = () => {
 
   // Progressive Static replay (issue #3899). `replayCount` is the number of
   // history items currently passed to <Static>. It catches up to
-  // mergedHistory.length either in one shot (small lag) or chunk-by-chunk
+  // visibleHistory.length either in one shot (small lag) or chunk-by-chunk
   // through setImmediate (large lag, e.g., post-Ctrl+O remount of a 500-item
   // session).
   //
-  // Note: source-copy offsets are computed across the FULL mergedHistory
+  // Note: source-copy offsets are computed across the FULL visibleHistory
   // above so each code block keeps its stable copy index even when only a
   // prefix is visible; we slice the post-offset array here.
   const [replayCount, setReplayCount] = useState(() =>
-    initialReplayCount(mergedHistory.length),
+    initialReplayCount(visibleHistory.length),
   );
-  const mergedLengthRef = useRef(mergedHistory.length);
-  mergedLengthRef.current = mergedHistory.length;
+  const visibleHistoryLengthRef = useRef(visibleHistory.length);
+  visibleHistoryLengthRef.current = visibleHistory.length;
 
   // The reset MUST happen during render (not in an effect): historyRemountKey
   // also drives the <Static> key below, and Ink remounts Static synchronously
@@ -417,27 +202,30 @@ export const MainContent = () => {
     // `replayCount` / `visibleHistoryItemsWithSourceCopyOffsets`. Skip the
     // chunked-replay reset for VP users so a Ctrl+O / model-change bump
     // doesn't trigger ~M/CHUNK_SIZE extra setImmediate-scheduled
-    // re-renders (M = mergedHistory.length) that the VP path discards.
+    // re-renders (M = visibleHistory.length) that the VP path discards.
     if (!useVirtualScroll) {
-      setReplayCount(initialReplayCount(mergedLengthRef.current));
+      setReplayCount(initialReplayCount(visibleHistoryLengthRef.current));
     }
   }
 
   useEffect(() => {
     if (useVirtualScroll) return;
-    if (replayCount >= mergedHistory.length) return;
-    const remaining = mergedHistory.length - replayCount;
+    if (replayCount >= visibleHistory.length) return;
+    const remaining = visibleHistory.length - replayCount;
     if (remaining <= PROGRESSIVE_REPLAY_CHUNK_SIZE) {
-      setReplayCount(mergedHistory.length);
+      setReplayCount(visibleHistory.length);
       return;
     }
     const handle = setImmediate(() => {
       setReplayCount((c) =>
-        Math.min(c + PROGRESSIVE_REPLAY_CHUNK_SIZE, mergedLengthRef.current),
+        Math.min(
+          c + PROGRESSIVE_REPLAY_CHUNK_SIZE,
+          visibleHistoryLengthRef.current,
+        ),
       );
     });
     return () => clearImmediate(handle);
-  }, [useVirtualScroll, replayCount, mergedHistory.length]);
+  }, [useVirtualScroll, replayCount, visibleHistory.length]);
 
   // Render the full list when the tail gap is small (≤ CHUNK_SIZE). This
   // covers the normal append path: a pending item finalizes, replayCount is
@@ -456,10 +244,10 @@ export const MainContent = () => {
   // Pending items get negative IDs (-(i+1)) so renderItem can tell them apart.
   const allVirtualItems = useMemo(
     (): HistoryItem[] => [
-      ...mergedHistory,
+      ...visibleHistory,
       ...pendingHistoryItems.map((item, i) => ({ ...item, id: -(i + 1) })),
     ],
-    [mergedHistory, pendingHistoryItems],
+    [visibleHistory, pendingHistoryItems],
   );
 
   // Source-copy index offsets propagation. The legacy <Static> path threads
@@ -467,7 +255,7 @@ export const MainContent = () => {
   // diagram stay stable across continuation messages. Build lookup tables so
   // the VP renderItem can attach the same offsets without changing the
   // VirtualizedList API.
-  //   - Static items: look up by HistoryItem reference (mergedHistory items
+  //   - Static items: look up by HistoryItem reference (visibleHistory items
   //     are passed by ref, so identity-keyed lookup is stable).
   //   - Pending items: look up by pending-array index (the spread
   //     `{...item, id: -(i+1)}` creates a new object every render, so the
@@ -489,8 +277,8 @@ export const MainContent = () => {
   }, [historyItemsWithSourceCopyOffsets]);
 
   const thinkingFullTextByItem = useMemo(
-    () => buildThinkingFullTextMap(mergedHistory),
-    [mergedHistory],
+    () => buildThinkingFullTextMap(visibleHistory),
+    [visibleHistory],
   );
   const thinkingFullTextByItemRef = useRef(thinkingFullTextByItem);
   thinkingFullTextByItemRef.current = thinkingFullTextByItem;
@@ -533,7 +321,7 @@ export const MainContent = () => {
 
   // Stable renderItem: deps shrink to inputs that legitimately change the
   // render output for a given item identity (terminalWidth, slashCommands,
-  // compactLabel, summary absorption, static-history source-copy offsets).
+  // static-history source-copy offsets).
   // Streaming-only state — including pending source-copy offsets — is read
   // from refs so callback identity is stable.
   const renderVirtualItem = useCallback(
@@ -557,8 +345,6 @@ export const MainContent = () => {
             activeShellPtyId={ps.activePtyId}
             embeddedShellFocused={ps.embeddedShellFocused}
             commands={uiState.slashCommands}
-            compactLabel={getCompactLabel(item)}
-            summaryAbsorbed={isSummaryAbsorbed(item)}
             sourceCopyIndexOffsets={sourceCopyIndexOffsets}
           />
         );
@@ -572,8 +358,6 @@ export const MainContent = () => {
           item={item}
           isPending={false}
           commands={uiState.slashCommands}
-          compactLabel={getCompactLabel(item)}
-          summaryAbsorbed={isSummaryAbsorbed(item)}
           sourceCopyIndexOffsets={sourceCopyIndexOffsets}
           thinkingFullText={thinkingFullTextByItemRef.current.get(item)}
         />
@@ -584,8 +368,6 @@ export const MainContent = () => {
       mainAreaWidth,
       staticAreaMaxItemHeight,
       uiState.slashCommands,
-      getCompactLabel,
-      isSummaryAbsorbed,
       sourceCopyOffsetsByHistoryItem,
     ],
   );
@@ -647,8 +429,6 @@ export const MainContent = () => {
                 item={h}
                 isPending={false}
                 commands={uiState.slashCommands}
-                compactLabel={getCompactLabel(h)}
-                summaryAbsorbed={isSummaryAbsorbed(h)}
                 sourceCopyIndexOffsets={sourceCopyIndexOffsets}
                 thinkingFullText={thinkingFullTextByItem.get(h)}
               />
@@ -674,8 +454,6 @@ export const MainContent = () => {
                 isFocused={!uiState.isEditorDialogOpen}
                 activeShellPtyId={uiState.activePtyId}
                 embeddedShellFocused={uiState.embeddedShellFocused}
-                compactLabel={getCompactLabel(item)}
-                summaryAbsorbed={isSummaryAbsorbed(item)}
                 sourceCopyIndexOffsets={sourceCopyIndexOffsets}
               />
             ),
diff --git a/packages/cli/src/ui/components/StandaloneSessionPicker.test.tsx b/packages/cli/src/ui/components/StandaloneSessionPicker.test.tsx
index 3d712345ee5..1671e261c76 100644
--- a/packages/cli/src/ui/components/StandaloneSessionPicker.test.tsx
+++ b/packages/cli/src/ui/components/StandaloneSessionPicker.test.tsx
@@ -852,7 +852,7 @@ describe('SessionPicker', () => {
       await act(async () => {
         await loadSessionPromise;
       });
-      // Tool group renders with raw function name fallback (no registry).
+      // 'BashTool' maps to 'other' (non-collapsible) → renders individually.
       expect(lastFrame() ?? '').toContain('BashTool');
     });
 
diff --git a/packages/cli/src/ui/components/messages/CompactToolGroupDisplay.test.tsx b/packages/cli/src/ui/components/messages/CompactToolGroupDisplay.test.tsx
index 88d0a9e2478..5a037f45cd6 100644
--- a/packages/cli/src/ui/components/messages/CompactToolGroupDisplay.test.tsx
+++ b/packages/cli/src/ui/components/messages/CompactToolGroupDisplay.test.tsx
@@ -7,7 +7,11 @@
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
 import { render } from 'ink-testing-library';
 import { Text } from 'ink';
-import { CompactToolGroupDisplay } from './CompactToolGroupDisplay.js';
+import {
+  CompactToolGroupDisplay,
+  buildToolSummary,
+  isCollapsibleTool,
+} from './CompactToolGroupDisplay.js';
 import { ToolCallStatus } from '../../types.js';
 import type { IndividualToolCallDisplay } from '../../types.js';
 
@@ -108,53 +112,19 @@ describe('<CompactToolGroupDisplay /> — shell timeout plumbing', () => {
 });
 
 describe('<CompactToolGroupDisplay /> — summary label', () => {
-  it('renders default header (active tool name + count) when no compactLabel is provided', () => {
+  it('renders semantic summary for collapsible tools', () => {
     const tools = [
-      toolCall({ callId: 'c1', name: 'read_file' }),
-      toolCall({ callId: 'c2', name: 'read_file' }),
-      toolCall({ callId: 'c3', name: 'grep' }),
+      toolCall({ callId: 'c1', name: 'ReadFile', description: 'a.ts' }),
+      toolCall({ callId: 'c2', name: 'ReadFile', description: 'b.ts' }),
+      toolCall({ callId: 'c3', name: 'Grep', description: 'search pattern' }),
     ];
     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');
+    // CATEGORY_ORDER: search → read → list → ...
+    expect(frame).toContain('Searched 1 pattern');
+    expect(frame).toContain('read 2 files');
   });
 
   it('renders nothing for empty tool calls', () => {
@@ -164,18 +134,137 @@ describe('<CompactToolGroupDisplay /> — summary label', () => {
     expect(lastFrame()).toBe('');
   });
 
-  it('preserves default rendering for shell commands without label', () => {
+  it('renders semantic summary for shell commands without label', () => {
     const tools = [
       toolCall({
         callId: 'c1',
-        name: 'Bash',
+        name: 'Shell',
         description: 'ls -la',
       }),
     ];
     const { lastFrame } = render(
       <CompactToolGroupDisplay toolCalls={tools} contentWidth={80} />,
     );
-    expect(lastFrame()).toContain('Bash');
-    expect(lastFrame()).toContain('ls -la');
+    expect(lastFrame()).toContain('Ran 1 command');
+  });
+});
+
+describe('buildToolSummary', () => {
+  const make = (
+    overrides: Partial<IndividualToolCallDisplay>,
+  ): IndividualToolCallDisplay => ({
+    callId: 'c1',
+    name: 'ReadFile',
+    description: 'a.ts',
+    status: ToolCallStatus.Success,
+    resultDisplay: '',
+    confirmationDetails: undefined,
+    ...overrides,
+  });
+
+  it('returns empty string for empty array', () => {
+    expect(buildToolSummary([], false)).toBe('');
+  });
+
+  it('single tool uses count format', () => {
+    expect(buildToolSummary([make({})], false)).toBe('Read 1 file');
+  });
+
+  it('single tool uses progressive verb when active', () => {
+    expect(buildToolSummary([make({})], true)).toBe('Reading 1 file');
+  });
+
+  it('multiple same-type tools use count', () => {
+    const tools = [
+      make({ callId: 'c1', description: 'a.ts' }),
+      make({ callId: 'c2', description: 'b.ts' }),
+      make({ callId: 'c3', description: 'c.ts' }),
+    ];
+    expect(buildToolSummary(tools, false)).toBe('Read 3 files');
+  });
+
+  it('mixed types joined with comma and lowercase verbs', () => {
+    const tools = [
+      make({ callId: 'c1', name: 'ReadFile', description: 'a.ts' }),
+      make({ callId: 'c2', name: 'Edit', description: 'b.ts' }),
+      make({ callId: 'c3', name: 'Shell', description: 'npm test' }),
+    ];
+    // CATEGORY_ORDER: search → read → list → command → edit
+    expect(buildToolSummary(tools, false)).toBe(
+      'Read 1 file, ran 1 command, edited 1 file',
+    );
+  });
+
+  it('respects CATEGORY_ORDER (read before command)', () => {
+    const tools = [
+      make({ callId: 'c1', name: 'ReadFile', description: 'a.ts' }),
+      make({ callId: 'c2', name: 'Shell', description: 'ls' }),
+    ];
+    const result = buildToolSummary(tools, false);
+    expect(result).toBe('Read 1 file, ran 1 command');
+  });
+
+  it('unknown tool names fall to other category', () => {
+    const tools = [
+      make({ callId: 'c1', name: 'UnknownTool', description: 'something' }),
+    ];
+    expect(buildToolSummary(tools, false)).toBe('Used 1 tool');
+  });
+
+  it('mixed group with count per category', () => {
+    const tools = [
+      make({ callId: 'c1', name: 'ReadFile', description: 'a.ts' }),
+      make({ callId: 'c2', name: 'ReadFile', description: 'b.ts' }),
+      make({ callId: 'c3', name: 'Shell', description: 'npm test' }),
+    ];
+    expect(buildToolSummary(tools, false)).toBe('Read 2 files, ran 1 command');
+  });
+
+  it('legacy display names map to correct categories', () => {
+    const tools = [
+      make({ callId: 'c1', name: 'SearchFiles', description: 'pattern' }),
+      make({ callId: 'c2', name: 'ReadFolder', description: '/src' }),
+    ];
+    expect(buildToolSummary(tools, false)).toBe(
+      'Searched 1 pattern, listed 1 directory',
+    );
+  });
+});
+
+describe('isCollapsibleTool', () => {
+  it('returns true for read/search/list tools', () => {
+    expect(isCollapsibleTool('ReadFile')).toBe(true);
+    expect(isCollapsibleTool('Grep')).toBe(true);
+    expect(isCollapsibleTool('Glob')).toBe(true);
+    expect(isCollapsibleTool('ListFiles')).toBe(true);
+    expect(isCollapsibleTool('Read File')).toBe(true);
+    expect(isCollapsibleTool('Read File(s)')).toBe(true);
+    expect(isCollapsibleTool('Read Directory')).toBe(true);
+  });
+
+  it('returns false for mutation/command/agent tools', () => {
+    expect(isCollapsibleTool('Shell')).toBe(false);
+    expect(isCollapsibleTool('Edit')).toBe(false);
+    expect(isCollapsibleTool('WriteFile')).toBe(false);
+    expect(isCollapsibleTool('Agent')).toBe(false);
+    expect(isCollapsibleTool('Workflow')).toBe(false);
+    expect(isCollapsibleTool('NotebookEdit')).toBe(false);
+  });
+
+  it('returns false for unknown tool names', () => {
+    expect(isCollapsibleTool('CustomMcpTool')).toBe(false);
+    expect(isCollapsibleTool('unknown')).toBe(false);
+  });
+
+  it('handles legacy display names from ToolDisplayNamesMigration', () => {
+    // Legacy search tools → collapsible
+    expect(isCollapsibleTool('SearchFiles')).toBe(true);
+    expect(isCollapsibleTool('FindFiles')).toBe(true);
+    // Legacy list tool → collapsible
+    expect(isCollapsibleTool('ReadFolder')).toBe(true);
+    // Legacy agent tool → non-collapsible
+    expect(isCollapsibleTool('Task')).toBe(false);
+    // Legacy todo tool → non-collapsible
+    expect(isCollapsibleTool('TodoWrite')).toBe(false);
   });
 });
diff --git a/packages/cli/src/ui/components/messages/CompactToolGroupDisplay.tsx b/packages/cli/src/ui/components/messages/CompactToolGroupDisplay.tsx
index 3744f526b0a..e97a700b259 100644
--- a/packages/cli/src/ui/components/messages/CompactToolGroupDisplay.tsx
+++ b/packages/cli/src/ui/components/messages/CompactToolGroupDisplay.tsx
@@ -9,25 +9,18 @@ import { Box, Text } from 'ink';
 import type { IndividualToolCallDisplay } from '../../types.js';
 import { ToolCallStatus } from '../../types.js';
 import type { AnsiOutputDisplay } from '@qwen-code/qwen-code-core';
-import { theme } from '../../semantic-colors.js';
-import { localizeToolDisplayName, t } from '../../../i18n/index.js';
+import { ToolDisplayNames } from '@qwen-code/qwen-code-core';
+import { SHELL_COMMAND_NAME } from '../../constants.js';
 import { ToolStatusIndicator } from '../shared/ToolStatusIndicator.js';
 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
-function getOverallStatus(
+export function getOverallStatus(
   toolCalls: IndividualToolCallDisplay[],
 ): ToolCallStatus {
   if (toolCalls.some((t) => t.status === ToolCallStatus.Confirming))
@@ -54,10 +47,6 @@ function getActiveTool(
   );
 }
 
-// Pull the configured shell timeout off an AnsiOutputDisplay result so
-// ToolElapsedTime can surface it inline (matches the expanded
-// ToolMessage path). Non-ansi resultDisplay → undefined → legacy
-// quiet-then-elapsed behavior.
 function getShellTimeoutMs(
   tool: IndividualToolCallDisplay,
 ): number | undefined {
@@ -72,83 +61,197 @@ function getShellTimeoutMs(
   return undefined;
 }
 
+type ToolCategory =
+  | 'read'
+  | 'edit'
+  | 'write'
+  | 'search'
+  | 'list'
+  | 'command'
+  | 'agent'
+  | 'other';
+
+const TOOL_NAME_TO_CATEGORY: Record<string, ToolCategory> = {
+  [ToolDisplayNames.READ_FILE]: 'read',
+  [ToolDisplayNames.EDIT]: 'edit',
+  [ToolDisplayNames.WRITE_FILE]: 'write',
+  [ToolDisplayNames.NOTEBOOK_EDIT]: 'edit',
+  [ToolDisplayNames.GREP]: 'search',
+  [ToolDisplayNames.GLOB]: 'search',
+  [ToolDisplayNames.LS]: 'list',
+  [ToolDisplayNames.SHELL]: 'command',
+  [SHELL_COMMAND_NAME]: 'command',
+  [ToolDisplayNames.AGENT]: 'agent',
+  [ToolDisplayNames.WORKFLOW]: 'agent',
+  [ToolDisplayNames.SEND_MESSAGE]: 'agent',
+  'Read File': 'read',
+  'Read File(s)': 'read',
+  'Read Directory': 'list',
+  // Legacy display names (keys from ToolDisplayNamesMigration)
+  SearchFiles: 'search',
+  FindFiles: 'search',
+  ReadFolder: 'list',
+  Task: 'agent',
+  TodoWrite: 'other',
+};
+
+type CategoryTemplate = {
+  pastVerb: string;
+  activeVerb: string;
+  singular: string;
+  plural: string;
+};
+
+const CATEGORY_TEMPLATES: Record<ToolCategory, CategoryTemplate> = {
+  read: {
+    pastVerb: 'Read',
+    activeVerb: 'Reading',
+    singular: 'file',
+    plural: 'files',
+  },
+  edit: {
+    pastVerb: 'Edited',
+    activeVerb: 'Editing',
+    singular: 'file',
+    plural: 'files',
+  },
+  write: {
+    pastVerb: 'Wrote',
+    activeVerb: 'Writing',
+    singular: 'file',
+    plural: 'files',
+  },
+  search: {
+    pastVerb: 'Searched',
+    activeVerb: 'Searching',
+    singular: 'pattern',
+    plural: 'patterns',
+  },
+  list: {
+    pastVerb: 'Listed',
+    activeVerb: 'Listing',
+    singular: 'directory',
+    plural: 'directories',
+  },
+  command: {
+    pastVerb: 'Ran',
+    activeVerb: 'Running',
+    singular: 'command',
+    plural: 'commands',
+  },
+  agent: {
+    pastVerb: 'Ran',
+    activeVerb: 'Running',
+    singular: 'agent',
+    plural: 'agents',
+  },
+  other: {
+    pastVerb: 'Used',
+    activeVerb: 'Using',
+    singular: 'tool',
+    plural: 'tools',
+  },
+};
+
+const CATEGORY_ORDER: ToolCategory[] = [
+  'search',
+  'read',
+  'list',
+  'command',
+  'edit',
+  'write',
+  'agent',
+  'other',
+];
+
+const COLLAPSIBLE_CATEGORIES: ReadonlySet<ToolCategory> = new Set([
+  'read',
+  'search',
+  'list',
+]);
+
+function getToolCategory(toolName: string): ToolCategory {
+  return TOOL_NAME_TO_CATEGORY[toolName] ?? 'other';
+}
+
 /**
- * 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`.
+ * Whether a tool is information-gathering (read/search/list) vs mutation/action.
+ *
+ * Used at two decision points:
+ * 1. ToolGroupMessage — partitions collapsible tools into a summary line
+ * 2. ToolMessage.shouldCollapseResult — hides completed text/ANSI output
+ *
+ * Adding a category here suppresses individual rendering AND result output
+ * for completed tools of that type. Only add categories whose results are
+ * disposable (file contents, search hits) — never agent/command results.
  */
-function renderSummaryHeader(label: string, count: number) {
-  return (
-    <>
-      <Text bold>{label}</Text>
-      {count > 1 ? (
-        <Text color={theme.text.secondary}>
-          {'  · '}
-          {count} tools
-        </Text>
-      ) : null}
-    </>
-  );
+export function isCollapsibleTool(toolName: string): boolean {
+  return COLLAPSIBLE_CATEGORIES.has(getToolCategory(toolName));
 }
 
 /**
- * Default header: active tool name + " × N" count + first-line description.
- * Same N=1 suffix suppression as `renderSummaryHeader`.
+ * Build a semantic summary line from a batch of tool calls.
+ *
+ * Single tool  → "Read 1 file" / "Ran 1 command"
+ * Multi  same  → "Read 3 files"
+ * Multi mixed  → "Read 3 files, edited 2 files, ran 1 command"
+ *
+ * Uses past tense when all tools are done, present progressive when active.
  */
-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 function buildToolSummary(
+  toolCalls: IndividualToolCallDisplay[],
+  isActive: boolean,
+): string {
+  if (toolCalls.length === 0) return '';
+
+  // Group by category and count
+  const counts = new Map<ToolCategory, number>();
+
+  for (const tool of toolCalls) {
+    const cat = getToolCategory(tool.name);
+    counts.set(cat, (counts.get(cat) ?? 0) + 1);
+  }
+
+  const parts: string[] = [];
+  for (const cat of CATEGORY_ORDER) {
+    const count = counts.get(cat);
+    if (!count) continue;
+
+    const template = CATEGORY_TEMPLATES[cat];
+    const verb = isActive ? template.activeVerb : template.pastVerb;
+    const lower = parts.length > 0;
+    const v = lower ? verb.toLowerCase() : verb;
+
+    if (count === 1) {
+      parts.push(`${v} 1 ${template.singular}`);
+    } else {
+      parts.push(`${v} ${count} ${template.plural}`);
+    }
+  }
+
+  return parts.join(', ');
 }
 
 export const CompactToolGroupDisplay: React.FC<
   CompactToolGroupDisplayProps
-> = ({ toolCalls, contentWidth, compactLabel }) => {
+> = ({ toolCalls, contentWidth }) => {
   if (toolCalls.length === 0) return null;
 
   const overallStatus = getOverallStatus(toolCalls);
   const activeTool = getActiveTool(toolCalls);
-
-  // Take only the first line of description to prevent multi-line shell scripts
-  // from expanding the compact view (wrap="truncate-end" only handles width overflow,
-  // not literal \n characters in the content)
-  const activeToolDescription = activeTool.description
-    ? activeTool.description.split('\n')[0]
-    : '';
+  const isActive =
+    overallStatus === ToolCallStatus.Executing ||
+    overallStatus === ToolCallStatus.Pending ||
+    overallStatus === ToolCallStatus.Confirming;
 
   return (
     <Box flexDirection="column" width={contentWidth} paddingX={1} gap={0}>
-      {/* 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">
-            {compactLabel
-              ? renderSummaryHeader(compactLabel, toolCalls.length)
-              : renderDefaultHeader(
-                  localizeToolDisplayName(activeTool.name),
-                  activeToolDescription,
-                  toolCalls.length,
-                )}
+          <Text wrap="truncate-end" bold>
+            {buildToolSummary(toolCalls, isActive)}
+            {isActive && <Text key="ellipsis">…</Text>}
           </Text>
         </Box>
         <ToolElapsedTime
@@ -157,11 +260,6 @@ export const CompactToolGroupDisplay: React.FC<
           timeoutMs={getShellTimeoutMs(activeTool)}
         />
       </Box>
-
-      {/* Hint line */}
-      <Text color={theme.text.secondary}>
-        {t('Press Ctrl+O to show full tool output')}
-      </Text>
     </Box>
   );
 };
diff --git a/packages/cli/src/ui/components/messages/ToolGroupMessage.test.tsx b/packages/cli/src/ui/components/messages/ToolGroupMessage.test.tsx
index b6673456482..77ca16768e5 100644
--- a/packages/cli/src/ui/components/messages/ToolGroupMessage.test.tsx
+++ b/packages/cli/src/ui/components/messages/ToolGroupMessage.test.tsx
@@ -70,6 +70,7 @@ vi.mock('./ToolMessage.js', () => ({
     return (
       <Text>
         MockTool[{callId}]: {statusSymbol} {name} - {description} ({emphasis})
+        {forceShowResult ? ' [forceShow]' : ''}
       </Text>
     );
   },
@@ -155,7 +156,7 @@ describe('<ToolGroupMessage />', () => {
       expect(lastFrame()).toMatchSnapshot();
     });
 
-    it('renders expanded tool entries without blank separator rows', () => {
+    it('renders non-collapsible tools individually', () => {
       const toolCalls = [
         createToolCall({ callId: 'tool-1', name: 'first-tool' }),
         createToolCall({ callId: 'tool-2', name: 'second-tool' }),
@@ -167,12 +168,174 @@ describe('<ToolGroupMessage />', () => {
           toolCalls={toolCalls}
         />,
       );
-      const lines = (lastFrame() ?? '').split('\n');
-      const firstLine = lines.findIndex((line) => line.includes('tool-1'));
-      const secondLine = lines.findIndex((line) => line.includes('tool-2'));
+      const frame = lastFrame() ?? '';
+      // Non-collapsible tools (unknown → 'other') render individually
+      expect(frame).toContain('MockTool[tool-1]');
+      expect(frame).toContain('MockTool[tool-2]');
+    });
 
-      expect(firstLine).toBeGreaterThanOrEqual(0);
-      expect(secondLine).toBe(firstLine + 1);
+    it('renders collapsible tools as summary via CompactToolGroupDisplay', () => {
+      const toolCalls = [
+        createToolCall({ callId: 'r1', name: 'ReadFile', description: 'a.ts' }),
+        createToolCall({ callId: 'r2', name: 'ReadFile', description: 'b.ts' }),
+        createToolCall({ callId: 'g1', name: 'Grep', description: 'pattern' }),
+      ];
+      const { lastFrame } = renderWithProviders(
+        <ToolGroupMessage {...baseProps} toolCalls={toolCalls} />,
+      );
+      const frame = lastFrame() ?? '';
+      // CATEGORY_ORDER: search first (capitalized), then read (lowercased)
+      expect(frame).toContain('Searched 1 pattern');
+      expect(frame).toContain('read 2 files');
+      expect(frame).not.toContain('MockTool');
+    });
+
+    it('renders mixed group with summary + individual tools', () => {
+      const toolCalls = [
+        createToolCall({ callId: 'r1', name: 'ReadFile', description: 'a.ts' }),
+        createToolCall({
+          callId: 's1',
+          name: 'Shell',
+          description: 'npm test',
+        }),
+      ];
+      const { lastFrame } = renderWithProviders(
+        <ToolGroupMessage {...baseProps} toolCalls={toolCalls} />,
+      );
+      const frame = lastFrame() ?? '';
+      // Collapsible → summary line
+      expect(frame).toContain('Read 1 file');
+      // Non-collapsible → individual ToolMessage
+      expect(frame).toContain('MockTool[s1]');
+    });
+
+    it('forceExpandAll bypasses partition when group has error', () => {
+      const toolCalls = [
+        createToolCall({ callId: 'r1', name: 'ReadFile', description: 'a.ts' }),
+        createToolCall({
+          callId: 'e1',
+          name: 'Shell',
+          description: 'npm test',
+          status: ToolCallStatus.Error,
+        }),
+      ];
+      const { lastFrame } = renderWithProviders(
+        <ToolGroupMessage {...baseProps} toolCalls={toolCalls} />,
+      );
+      const frame = lastFrame() ?? '';
+      // All tools render individually — no summary line
+      expect(frame).toContain('MockTool[r1]');
+      expect(frame).toContain('MockTool[e1]');
+      expect(frame).not.toContain('Read 1 file');
+    });
+
+    it('forceExpandAll passes forceShowResult to Success siblings in error group', () => {
+      const toolCalls = [
+        createToolCall({
+          callId: 'ok1',
+          name: 'ReadFile',
+          description: 'a.ts',
+          status: ToolCallStatus.Success,
+        }),
+        createToolCall({
+          callId: 'err1',
+          name: 'Shell',
+          description: 'npm test',
+          status: ToolCallStatus.Error,
+        }),
+      ];
+      const { lastFrame } = renderWithProviders(
+        <ToolGroupMessage {...baseProps} toolCalls={toolCalls} />,
+      );
+      const frame = lastFrame() ?? '';
+      // forceShowResult is per-tool: only the errored tool gets it
+      expect(frame).toContain('MockTool[ok1]');
+      expect(frame).toContain('MockTool[err1]');
+      // Only the Error tool has [forceShow]
+      const forceShowCount = (frame.match(/\[forceShow\]/g) || []).length;
+      expect(forceShowCount).toBe(1);
+    });
+
+    it('canceled collapsible tool renders individually (not absorbed into summary)', () => {
+      const toolCalls = [
+        createToolCall({
+          callId: 'r1',
+          name: 'ReadFile',
+          description: 'a.ts',
+          status: ToolCallStatus.Success,
+        }),
+        createToolCall({
+          callId: 'r2',
+          name: 'ReadFile',
+          description: 'b.ts',
+          status: ToolCallStatus.Canceled,
+        }),
+      ];
+      const { lastFrame } = renderWithProviders(
+        <ToolGroupMessage {...baseProps} toolCalls={toolCalls} />,
+      );
+      const frame = lastFrame() ?? '';
+      // Successful ReadFile → summary line
+      expect(frame).toContain('Read 1 file');
+      // Canceled ReadFile → individual ToolMessage (partial output visible)
+      expect(frame).toContain('MockTool[r2]');
+    });
+
+    it('mixed group with memory counts renders memory badge', () => {
+      const toolCalls = [
+        createToolCall({
+          callId: 'r1',
+          name: 'ReadFile',
+          description: 'config.yaml',
+          status: ToolCallStatus.Success,
+        }),
+        createToolCall({
+          callId: 's1',
+          name: 'Shell',
+          description: 'npm test',
+          status: ToolCallStatus.Success,
+        }),
+      ];
+      const { lastFrame } = renderWithProviders(
+        <ToolGroupMessage
+          {...baseProps}
+          toolCalls={toolCalls}
+          memoryReadCount={2}
+        />,
+      );
+      const frame = lastFrame() ?? '';
+      expect(frame).toContain('Recalled 2 memories');
+      // Collapsible tool still summarized
+      expect(frame).toContain('Read 1 file');
+      // Non-collapsible tool rendered individually
+      expect(frame).toContain('MockTool[s1]');
+    });
+
+    it('all-collapsible group with memory counts renders memory badge', () => {
+      const toolCalls = [
+        createToolCall({
+          callId: 'r1',
+          name: 'ReadFile',
+          description: 'a.ts',
+          status: ToolCallStatus.Success,
+        }),
+        createToolCall({
+          callId: 'r2',
+          name: 'ReadFile',
+          description: 'b.ts',
+          status: ToolCallStatus.Success,
+        }),
+      ];
+      const { lastFrame } = renderWithProviders(
+        <ToolGroupMessage
+          {...baseProps}
+          toolCalls={toolCalls}
+          memoryReadCount={1}
+        />,
+      );
+      const frame = lastFrame() ?? '';
+      expect(frame).toContain('Read 2 files');
+      expect(frame).toContain('Recalled 1 memory');
     });
 
     it('renders tool call awaiting confirmation', () => {
@@ -302,6 +465,123 @@ describe('<ToolGroupMessage />', () => {
     });
   });
 
+  describe('Memory-only group', () => {
+    it('renders read/write counts for completed memory-only groups', () => {
+      const toolCalls = [
+        createToolCall({
+          callId: 'm1',
+          name: 'SaveMemory',
+          isMemoryOp: 'read',
+        }),
+        createToolCall({
+          callId: 'm2',
+          name: 'SaveMemory',
+          isMemoryOp: 'read',
+        }),
+        createToolCall({
+          callId: 'm3',
+          name: 'SaveMemory',
+          isMemoryOp: 'write',
+        }),
+      ];
+      const { lastFrame } = renderWithProviders(
+        <ToolGroupMessage
+          {...baseProps}
+          toolCalls={toolCalls}
+          memoryReadCount={2}
+          memoryWriteCount={1}
+        />,
+      );
+      const frame = lastFrame() ?? '';
+      expect(frame).toContain('Recalled 2 memories');
+      expect(frame).toContain('Wrote 1 memory');
+    });
+
+    it('renders singular form for single memory op', () => {
+      const toolCalls = [
+        createToolCall({
+          callId: 'm1',
+          name: 'SaveMemory',
+          isMemoryOp: 'read',
+        }),
+      ];
+      const { lastFrame } = renderWithProviders(
+        <ToolGroupMessage
+          {...baseProps}
+          toolCalls={toolCalls}
+          memoryReadCount={1}
+          memoryWriteCount={0}
+        />,
+      );
+      const frame = lastFrame() ?? '';
+      expect(frame).toContain('Recalled 1 memory');
+      expect(frame).not.toContain('Wrote');
+    });
+  });
+
+  describe('isUserInitiated', () => {
+    it('user-initiated group renders all collapsible tools individually', () => {
+      const toolCalls = [
+        createToolCall({
+          callId: 'r1',
+          name: 'ReadFile',
+          description: 'a.ts',
+          status: ToolCallStatus.Success,
+        }),
+        createToolCall({
+          callId: 'r2',
+          name: 'ReadFile',
+          description: 'b.ts',
+          status: ToolCallStatus.Success,
+        }),
+      ];
+      const { lastFrame } = renderWithProviders(
+        <ToolGroupMessage
+          {...baseProps}
+          toolCalls={toolCalls}
+          isUserInitiated={true}
+        />,
+      );
+      const frame = lastFrame() ?? '';
+      // All tools render individually, no summary line
+      expect(frame).toContain('MockTool[r1]');
+      expect(frame).toContain('MockTool[r2]');
+      expect(frame).not.toContain('Read 2 files');
+    });
+  });
+
+  describe('Memory-only group with error', () => {
+    it('memory-only group with errored tool falls through to expanded path', () => {
+      const toolCalls = [
+        createToolCall({
+          callId: 'm1',
+          name: 'SaveMemory',
+          isMemoryOp: 'read',
+          status: ToolCallStatus.Success,
+        }),
+        createToolCall({
+          callId: 'm2',
+          name: 'SaveMemory',
+          isMemoryOp: 'write',
+          status: ToolCallStatus.Error,
+          resultDisplay: 'Memory write failed',
+        }),
+      ];
+      const { lastFrame } = renderWithProviders(
+        <ToolGroupMessage
+          {...baseProps}
+          toolCalls={toolCalls}
+          memoryReadCount={1}
+          memoryWriteCount={1}
+        />,
+      );
+      const frame = lastFrame() ?? '';
+      // Should NOT show compact memory badge — error forces expanded path
+      expect(frame).toContain('MockTool[m1]');
+      expect(frame).toContain('MockTool[m2]');
+    });
+  });
+
   describe('SubAgent focus', () => {
     // Helper to build a running SubAgent result display
     const createRunningSubagentDisplay = (
@@ -508,6 +788,7 @@ describe('<ToolGroupMessage />', () => {
       const toolCalls = [
         createToolCall({
           callId: 'tool-1',
+          status: ToolCallStatus.Executing,
           resultDisplay: 'Result 1',
         }),
         createToolCall({
@@ -696,8 +977,9 @@ describe('<ToolGroupMessage />', () => {
         />,
       );
       const frame = lastFrame() ?? '';
-      // Sibling shown.
-      expect(frame).toContain('read_file');
+      // Sibling shown — read_file maps to 'other' (non-collapsible),
+      // renders individually via ToolMessage.
+      expect(frame).toContain('read config.yaml');
       // Subagent hidden — panel owns the live row.
       expect(frame).not.toContain('MockSubagent[task-running]');
     });
@@ -854,13 +1136,10 @@ describe('<ToolGroupMessage />', () => {
         />,
       );
       const frame = lastFrame() ?? '';
-      // Sibling is the only inline survivor → wins active-tool, count
-      // collapses to 1 (no `× N` suffix).
-      expect(frame).toContain('read_file');
-      expect(frame).not.toMatch(/× 2/);
-      // Sibling description should appear; subagent description
-      // should not.
+      // Sibling is the only inline survivor — read_file maps to 'other'
+      // (non-collapsible), renders individually via ToolMessage.
       expect(frame).toContain('read config.yaml');
+      expect(frame).not.toMatch(/× 2/);
       expect(frame).not.toContain('Delegate task to subagent');
     });
   });
diff --git a/packages/cli/src/ui/components/messages/ToolGroupMessage.tsx b/packages/cli/src/ui/components/messages/ToolGroupMessage.tsx
index e911dbb7a61..6bc962d0b72 100644
--- a/packages/cli/src/ui/components/messages/ToolGroupMessage.tsx
+++ b/packages/cli/src/ui/components/messages/ToolGroupMessage.tsx
@@ -11,10 +11,12 @@ import type { IndividualToolCallDisplay } from '../../types.js';
 import { ToolCallStatus } from '../../types.js';
 import { ToolMessage } from './ToolMessage.js';
 import { ToolConfirmationMessage } from './ToolConfirmationMessage.js';
-import { CompactToolGroupDisplay } from './CompactToolGroupDisplay.js';
+import {
+  CompactToolGroupDisplay,
+  isCollapsibleTool,
+} from './CompactToolGroupDisplay.js';
 import { InlineParallelAgentsDisplay } from './InlineParallelAgentsDisplay.js';
 import { useConfig } from '../../contexts/ConfigContext.js';
-import { useCompactMode } from '../../contexts/CompactModeContext.js';
 import type { AgentResultDisplay } from '@qwen-code/qwen-code-core';
 
 function isAgentWithPendingConfirmation(
@@ -126,10 +128,9 @@ interface ToolGroupMessageProps {
    *      emit already drops them from the panel snapshot, and the
    *      inline path must render `SubagentScrollbackSummary`
    *      immediately so the user keeps a record of the run.
-   *   2. Force-expand a compact group when committed AND carrying a
-   *      terminal subagent, so `SubagentScrollbackSummary` actually
-   *      lands in the persistent record (CompactToolGroupDisplay is
-   *      otherwise unaware of `task_execution` results).
+   *   2. Force-expand all tools individually when committed AND
+   *      carrying a terminal subagent, so `SubagentScrollbackSummary`
+   *      actually lands in the persistent record.
    *   3. Forward to `ToolMessage` for parity with sibling renderers
    *      and possible future gating; the prop is currently inert at
    *      that layer (the live-phase filter at #1 already prevents
@@ -146,12 +147,6 @@ 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 maps the tools using ToolMessage
@@ -166,10 +161,8 @@ export const ToolGroupMessage: React.FC<ToolGroupMessageProps> = ({
   memoryWriteCount,
   memoryReadCount,
   isUserInitiated,
-  compactLabel,
 }) => {
   const config = useConfig();
-  const { compactMode } = useCompactMode();
 
   const hasConfirmingTool = toolCalls.some(
     (t) => t.status === ToolCallStatus.Confirming,
@@ -196,20 +189,10 @@ export const ToolGroupMessage: React.FC<ToolGroupMessageProps> = ({
     [toolCalls],
   );
 
-  const allComplete = useMemo(
-    () =>
-      toolCalls.every(
-        (t) =>
-          t.status === ToolCallStatus.Success ||
-          t.status === ToolCallStatus.Error,
-      ),
-    [toolCalls],
-  );
-
   // Live-phase panel-ownership filter applied ONCE so every downstream
-  // decision (compact summary, sizing, render map) sees the same list.
+  // decision (summary, sizing, render map) sees the same list.
   // Without this, mixed live groups (running subagent + sibling tool)
-  // could leak the panel-owned subagent into `CompactToolGroupDisplay`'s
+  // could leak the panel-owned subagent into the collapsed summary's
   // count / active-tool selection, reintroducing the duplicate UI the
   // LiveAgentPanel hand-off was designed to prevent. Pending-approval
   // subagents pass through (the inline banner / queued marker is the
@@ -298,74 +281,19 @@ export const ToolGroupMessage: React.FC<ToolGroupMessageProps> = ({
   // and the inline path must render `SubagentScrollbackSummary`
   // immediately so the user keeps a record of the run.
   // (Gate on `isPending` so a degenerate empty `toolCalls=[]` in the
-  // committed phase still falls through to the legacy empty-container
-  // snapshot — the suppression is specifically about live-phase
-  // panel ownership, not about hiding empty inputs in general.)
+  // committed phase falls through to the expanded path harmlessly.)
   if (isPending && inlineToolCalls.length === 0) {
     return null;
   }
 
-  // Compact mode: entire group → single line summary
-  // Force-expand when: user must interact (Confirming or subagent pending
-  // confirmation), tool errored, shell is focused, or user-initiated.
-  // Also force-expand when this group carries a terminal subagent —
-  // `CompactToolGroupDisplay` doesn't know about `task_execution`
-  // results, so the compact path would skip `SubagentScrollbackSummary`
-  // entirely. Applies in BOTH live and committed phases:
-  //   - committed phase: the summary is the persistent audit trail.
-  //   - live phase: `unregisterForeground`'s post-delete emit has
-  //     already evicted the panel snapshot row by the time a foreground
-  //     subagent reaches a terminal status, so the inline summary is
-  //     the only surface that carries the run's outcome until the
-  //     parent commits. Mirrors the renderer-side decision in
-  //     `SubagentExecutionRenderer` (terminal summary fires regardless
-  //     of `isPending`) and the preprocessor in
-  //     `mergeCompactToolGroups.isForceExpandGroup` (no `isPending`
-  //     gate either).
-  const hasTerminalSubagent = inlineToolCalls.some(isTerminalSubagentTool);
-  const showCompact =
-    compactMode &&
-    !hasConfirmingTool &&
-    !hasSubagentPendingConfirmation &&
+  // Memory-only groups get their own compact rendering with read/write
+  // counts. Check BEFORE the partition logic so they aren't routed through
+  // the collapsible/non-collapsible split.
+  const allMemOpsComplete =
+    isMemoryOnlyGroup &&
     !hasErrorTool &&
-    !isEmbeddedShellFocused &&
-    !isUserInitiated &&
-    !hasTerminalSubagent;
-
-  if (showCompact) {
-    return (
-      <CompactToolGroupDisplay
-        toolCalls={inlineToolCalls}
-        contentWidth={contentWidth}
-        compactLabel={compactLabel}
-      />
-    );
-  }
-
-  // Full expanded view
-  const staticHeight = /* marginBottom */ 1;
-  const innerWidth = contentWidth - 2;
-
-  let countToolCallsWithResults = 0;
-  for (const tool of inlineToolCalls) {
-    if (tool.resultDisplay !== undefined && tool.resultDisplay !== '') {
-      countToolCallsWithResults++;
-    }
-  }
-  const countOneLineToolCalls =
-    inlineToolCalls.length - countToolCallsWithResults;
-  const availableTerminalHeightPerToolMessage = availableTerminalHeight
-    ? Math.max(
-        Math.floor(
-          (availableTerminalHeight - staticHeight - countOneLineToolCalls) /
-            Math.max(1, countToolCallsWithResults),
-        ),
-        1,
-      )
-    : undefined;
-
-  // For completed memory-only groups, show a compact summary instead of individual tool calls
-  if (isMemoryOnlyGroup && allComplete) {
+    toolCalls.every((t) => t.status === ToolCallStatus.Success);
+  if (allMemOpsComplete) {
     const readCount = memoryReadCount ?? 0;
     const writeCount = memoryWriteCount ?? 0;
     return (
@@ -390,42 +318,108 @@ export const ToolGroupMessage: React.FC<ToolGroupMessageProps> = ({
     );
   }
 
+  // Force-expand ALL tools individually when the user must interact or
+  // must see full details: confirmation prompts, errors, user-initiated
+  // batches, focused shells, terminal subagents.
+  const hasTerminalSubagent = inlineToolCalls.some(isTerminalSubagentTool);
+  const forceExpandAll =
+    hasConfirmingTool ||
+    hasSubagentPendingConfirmation ||
+    hasErrorTool ||
+    isEmbeddedShellFocused ||
+    isUserInitiated ||
+    hasTerminalSubagent;
+
+  // Partition tools into collapsible (read/search/list → summary line)
+  // and non-collapsible (edit/write/command/agent → individual display).
+  // Matches Claude Code's `collapseReadSearchGroups` philosophy.
+  // Canceled tools always render individually so partial output stays visible.
+  const collapsibleTools = forceExpandAll
+    ? []
+    : inlineToolCalls.filter(
+        (t) =>
+          isCollapsibleTool(t.name) && t.status !== ToolCallStatus.Canceled,
+      );
+  const nonCollapsibleTools = forceExpandAll
+    ? inlineToolCalls
+    : inlineToolCalls.filter(
+        (t) =>
+          !isCollapsibleTool(t.name) || t.status === ToolCallStatus.Canceled,
+      );
+
+  // Memory badge — shared between all-collapsible and mixed paths.
+  // In the all-collapsible path only read counts are reachable (write ops
+  // use non-collapsible tools like WriteFile/Edit).
+  const hasMemoryBadge =
+    !isMemoryOnlyGroup &&
+    ((memoryWriteCount ?? 0) > 0 || (memoryReadCount ?? 0) > 0);
+  const memoryBadge = hasMemoryBadge ? (
+    <Box paddingLeft={1}>
+      <Text dimColor>
+        {'● '}
+        {[
+          (memoryReadCount ?? 0) > 0 &&
+            `Recalled ${memoryReadCount} ${memoryReadCount === 1 ? 'memory' : 'memories'}`,
+          (memoryWriteCount ?? 0) > 0 &&
+            `Wrote ${memoryWriteCount} ${memoryWriteCount === 1 ? 'memory' : 'memories'}`,
+        ]
+          .filter(Boolean)
+          .join(', ')}
+      </Text>
+    </Box>
+  ) : null;
+
+  // When all tools are collapsible (pure read/search/list batch),
+  // render summary line + memory badge if applicable.
+  if (collapsibleTools.length > 0 && nonCollapsibleTools.length === 0) {
+    return (
+      <Box flexDirection="column" width={contentWidth}>
+        <CompactToolGroupDisplay
+          toolCalls={collapsibleTools}
+          contentWidth={contentWidth}
+        />
+        {memoryBadge}
+      </Box>
+    );
+  }
+
+  // Full expanded view for non-collapsible tools
+  const collapsibleSummaryHeight = collapsibleTools.length > 0 ? 1 : 0;
+  const memoryBadgeHeight = hasMemoryBadge ? 1 : 0;
+  const staticHeight =
+    /* marginBottom */ 1 + collapsibleSummaryHeight + memoryBadgeHeight;
+  const innerWidth = contentWidth - 2;
+
+  let countToolCallsWithResults = 0;
+  for (const tool of nonCollapsibleTools) {
+    if (tool.resultDisplay !== undefined && tool.resultDisplay !== '') {
+      countToolCallsWithResults++;
+    }
+  }
+  const countOneLineToolCalls =
+    nonCollapsibleTools.length - countToolCallsWithResults;
+  const availableTerminalHeightPerToolMessage = availableTerminalHeight
+    ? Math.max(
+        Math.floor(
+          (availableTerminalHeight - staticHeight - countOneLineToolCalls) /
+            Math.max(1, countToolCallsWithResults),
+        ),
+        1,
+      )
+    : undefined;
+
   return (
     <Box flexDirection="column" width={contentWidth} gap={0}>
-      {/* Memory badge for mixed groups (some memory ops + other ops) */}
-      {!isMemoryOnlyGroup &&
-        ((memoryWriteCount ?? 0) > 0 || (memoryReadCount ?? 0) > 0) &&
-        (() => {
-          const parts: string[] = [];
-          if ((memoryReadCount ?? 0) > 0) {
-            const n = memoryReadCount!;
-            parts.push(`Recalled ${n} ${n === 1 ? 'memory' : 'memories'}`);
-          }
-          if ((memoryWriteCount ?? 0) > 0) {
-            const n = memoryWriteCount!;
-            parts.push(`Wrote ${n} ${n === 1 ? 'memory' : 'memories'}`);
-          }
-          return (
-            <Box paddingLeft={1}>
-              <Text dimColor>● {parts.join(', ')}</Text>
-            </Box>
-          );
-        })()}
-      {inlineToolCalls.map((tool) => {
-        // `inlineToolCalls` already excludes panel-owned subagent
-        // entries during the live phase (LiveAgentPanel owns those
-        // rows). Terminal subagents and pending-approval subagents
-        // pass through the filter and render inline so the
-        // scrollback summary / approval banner lands.
+      {/* Summary line for collapsible tools (read/search/list) */}
+      {collapsibleTools.length > 0 && (
+        <CompactToolGroupDisplay
+          toolCalls={collapsibleTools}
+          contentWidth={contentWidth}
+        />
+      )}
+      {memoryBadge}
+      {nonCollapsibleTools.map((tool) => {
         const isConfirming = toolAwaitingApproval?.callId === tool.callId;
-        // A subagent's inline approval prompt should only receive keyboard
-        // focus when (1) there is no direct tool-level confirmation active
-        // and (2) this tool currently holds the subagent keyboard focus.
-        // Pending confirmations keep the first-come focus lock so users
-        // answer one approval at a time; LiveAgentPanel + BackgroundTasksDialog
-        // own all live progress / drill-down (the legacy Ctrl+E / Ctrl+F
-        // shortcuts on the inline AgentExecutionDisplay frame were retired
-        // alongside the frame itself).
         const isSubagentFocused =
           isFocused &&
           !toolAwaitingApproval &&
@@ -452,13 +446,6 @@ export const ToolGroupMessage: React.FC<ToolGroupMessageProps> = ({
                   tool.status === ToolCallStatus.Confirming ||
                   tool.status === ToolCallStatus.Error ||
                   isAgentWithPendingConfirmation(tool.resultDisplay) ||
-                  // Terminal subagents need their result block to render
-                  // even in compact mode — that's where
-                  // `SubagentScrollbackSummary` lands. ToolMessage's
-                  // compact-mode gate
-                  // (`!compactMode || forceShowResult ? renderer : 'none'`)
-                  // would otherwise drop the result block, leaving the
-                  // committed audit trail empty for compact-mode users.
                   isTerminalSubagentTool(tool)
                 }
                 isFocused={isSubagentFocused}
diff --git a/packages/cli/src/ui/components/messages/ToolMessage.test.tsx b/packages/cli/src/ui/components/messages/ToolMessage.test.tsx
index 68e8f1d22b9..15ea7bfe0ba 100644
--- a/packages/cli/src/ui/components/messages/ToolMessage.test.tsx
+++ b/packages/cli/src/ui/components/messages/ToolMessage.test.tsx
@@ -137,7 +137,9 @@ const renderWithContext = (
 };
 
 describe('<ToolMessage />', () => {
-  const mockConfig = {} as Config;
+  const mockConfig = {
+    getShouldUseNodePtyShell: () => false,
+  } as unknown as Config;
 
   const baseProps: ToolMessageProps = {
     callId: 'tool-123',
@@ -151,21 +153,64 @@ describe('<ToolMessage />', () => {
     config: mockConfig,
   };
 
-  it('renders basic tool information', () => {
+  it('collapses text/ANSI result for completed collapsible tool', () => {
+    const { lastFrame } = renderWithContext(
+      <ToolMessage {...baseProps} name="ReadFile" description="config.yaml" />,
+      StreamingState.Idle,
+    );
+    const output = lastFrame();
+    expect(output).toContain('✓');
+    expect(output).toContain('ReadFile');
+    expect(output).not.toContain('MockMarkdown:Test result'); // collapsed
+  });
+
+  it('collapses ANSI result for completed collapsible tool', () => {
+    const ansiResult: AnsiOutputDisplay = {
+      ansiOutput: [
+        [
+          {
+            text: 'file content',
+            bold: false,
+            italic: false,
+            underline: false,
+            dim: false,
+            inverse: false,
+            fg: '',
+            bg: '',
+          },
+        ],
+      ],
+      totalLines: 1,
+      totalBytes: 12,
+    };
+    const { lastFrame } = renderWithContext(
+      <ToolMessage
+        {...baseProps}
+        name="ReadFile"
+        description="config.yaml"
+        resultDisplay={ansiResult}
+      />,
+      StreamingState.Idle,
+    );
+    const output = lastFrame();
+    expect(output).toContain('ReadFile');
+    expect(output).not.toContain('MockAnsiOutput'); // collapsed
+  });
+
+  it('shows result for non-collapsible completed tool', () => {
     const { lastFrame } = renderWithContext(
       <ToolMessage {...baseProps} />,
       StreamingState.Idle,
     );
     const output = lastFrame();
-    expect(output).toContain('✓'); // Success indicator
+    expect(output).toContain('✓');
     expect(output).toContain('test-tool');
-    expect(output).toContain('A tool for testing');
-    expect(output).toContain('MockMarkdown:Test result');
+    expect(output).toContain('MockMarkdown:Test result'); // not collapsed
   });
 
-  it('renders tool results directly below the header row', () => {
+  it('renders tool results directly below the header row when forced', () => {
     const { lastFrame } = renderWithContext(
-      <ToolMessage {...baseProps} contentWidth={100} />,
+      <ToolMessage {...baseProps} contentWidth={100} forceShowResult />,
       StreamingState.Idle,
     );
     const lines = (lastFrame() ?? '').split('\n');
@@ -178,15 +223,14 @@ describe('<ToolMessage />', () => {
     expect(resultLine).toBe(headerLine + 1);
   });
 
-  it('hides result output in compact mode (compactMode=true)', () => {
+  it('hides text result output for completed collapsible tools', () => {
     const { lastFrame } = renderWithContext(
-      <ToolMessage {...baseProps} />,
+      <ToolMessage {...baseProps} name="Grep" description="search pattern" />,
       StreamingState.Idle,
-      true, // compact mode
     );
     const output = lastFrame();
-    expect(output).toContain('✓'); // status indicator still visible
-    expect(output).toContain('test-tool'); // tool name still visible
+    expect(output).toContain('✓');
+    expect(output).toContain('Grep');
     expect(output).not.toContain('MockMarkdown:Test result'); // result hidden
   });
 
@@ -217,11 +261,10 @@ describe('<ToolMessage />', () => {
     expect(lastFrame()).toContain('MockMarkdown:Test result');
   });
 
-  it('shows result when forceShowResult overrides compact collapse', () => {
+  it('shows result when forceShowResult overrides collapse', () => {
     const { lastFrame } = renderWithContext(
       <ToolMessage {...baseProps} forceShowResult />,
       StreamingState.Idle,
-      true,
     );
     expect(lastFrame()).toContain('MockMarkdown:Test result');
   });
@@ -305,13 +348,33 @@ describe('<ToolMessage />', () => {
       newContent: 'new',
     };
     const { lastFrame } = renderWithContext(
-      <ToolMessage {...baseProps} resultDisplay={diffResult} />,
+      <ToolMessage {...baseProps} resultDisplay={diffResult} forceShowResult />,
       StreamingState.Idle,
     );
     // Check that the output contains the MockDiff content as part of the whole message
     expect(lastFrame()).toMatch(/MockDiff:--- a\/file\.txt/);
   });
 
+  it('diff results are not collapsed for completed collapsible tools (bypass shouldCollapseResult)', () => {
+    const diffResult = {
+      fileDiff: '--- a/file.txt\n+++ b/file.txt\n@@ -1 +1 @@\n-old\n+new',
+      fileName: 'file.txt',
+      originalContent: 'old',
+      newContent: 'new',
+    };
+    const { lastFrame } = renderWithContext(
+      <ToolMessage
+        {...baseProps}
+        name="ReadFile"
+        description="a.ts"
+        resultDisplay={diffResult}
+        status={ToolCallStatus.Success}
+      />,
+      StreamingState.Idle,
+    );
+    expect(lastFrame()).toMatch(/MockDiff:--- a\/file\.txt/);
+  });
+
   it('renders a saved-session preview notice for truncated diff results', () => {
     const diffResult = {
       fileDiff: '--- file.txt\n+++ file.txt\n@@ -1 +1 @@\n-omitted\n+preview',
@@ -323,7 +386,7 @@ describe('<ToolMessage />', () => {
       fileDiffTruncated: true,
     };
     const { lastFrame } = renderWithContext(
-      <ToolMessage {...baseProps} resultDisplay={diffResult} />,
+      <ToolMessage {...baseProps} resultDisplay={diffResult} forceShowResult />,
       StreamingState.Idle,
     );
 
@@ -556,7 +619,11 @@ describe('<ToolMessage />', () => {
     ];
     const ansiOutputDisplay: AnsiOutputDisplay = { ansiOutput: ansiResult };
     const { lastFrame } = renderWithContext(
-      <ToolMessage {...baseProps} resultDisplay={ansiOutputDisplay} />,
+      <ToolMessage
+        {...baseProps}
+        resultDisplay={ansiOutputDisplay}
+        forceShowResult
+      />,
       StreamingState.Idle,
     );
     expect(lastFrame()).toContain('MockAnsiOutput:hello');
@@ -585,6 +652,7 @@ describe('<ToolMessage />', () => {
       <ToolMessage
         {...baseProps}
         name="Shell"
+        status={ToolCallStatus.Executing}
         resultDisplay={ansiOutputDisplay}
         availableTerminalHeight={100}
       />,
@@ -619,6 +687,7 @@ describe('<ToolMessage />', () => {
         name="some-other-tool"
         resultDisplay={ansiOutputDisplay}
         availableTerminalHeight={100}
+        forceShowResult
       />,
       StreamingState.Idle,
     );
@@ -688,6 +757,7 @@ describe('<ToolMessage />', () => {
             <ToolMessage
               {...baseProps}
               name="Shell"
+              status={ToolCallStatus.Executing}
               resultDisplay={ansiOutputDisplay}
               availableTerminalHeight={100}
             />
@@ -727,6 +797,7 @@ describe('<ToolMessage />', () => {
             <ToolMessage
               {...baseProps}
               name="Shell"
+              status={ToolCallStatus.Executing}
               resultDisplay={ansiOutputDisplay}
               availableTerminalHeight={100}
             />
@@ -752,7 +823,7 @@ describe('<ToolMessage />', () => {
         {...baseProps}
         name="Shell"
         resultDisplay={longString}
-        status={ToolCallStatus.Success}
+        status={ToolCallStatus.Executing}
         availableTerminalHeight={100}
       />,
       StreamingState.Idle,
@@ -782,6 +853,7 @@ describe('<ToolMessage />', () => {
         resultDisplay={longString}
         status={ToolCallStatus.Success}
         availableTerminalHeight={12}
+        forceShowResult
       />,
       StreamingState.Idle,
     );
@@ -808,6 +880,7 @@ describe('<ToolMessage />', () => {
         resultDisplay={longSingleLine}
         status={ToolCallStatus.Success}
         availableTerminalHeight={12}
+        forceShowResult
       />,
       StreamingState.Idle,
     );
@@ -830,6 +903,7 @@ describe('<ToolMessage />', () => {
         resultDisplay={exactFitString}
         status={ToolCallStatus.Success}
         availableTerminalHeight={12}
+        forceShowResult
       />,
       StreamingState.Idle,
     );
@@ -872,6 +946,7 @@ describe('<ToolMessage />', () => {
             <ToolMessage
               {...baseProps}
               name="Shell"
+              status={ToolCallStatus.Executing}
               resultDisplay={ansiOutputDisplay}
               availableTerminalHeight={100}
             />
@@ -906,6 +981,7 @@ describe('<ToolMessage />', () => {
         resultDisplay={longString}
         status={ToolCallStatus.Success}
         availableTerminalHeight={100}
+        forceShowResult
       />,
       StreamingState.Idle,
     );
@@ -955,6 +1031,7 @@ describe('<ToolMessage />', () => {
         description="Plan:"
         status={ToolCallStatus.Success}
         resultDisplay={planResultDisplay}
+        forceShowResult
       />,
       StreamingState.Idle,
     );
diff --git a/packages/cli/src/ui/components/messages/ToolMessage.tsx b/packages/cli/src/ui/components/messages/ToolMessage.tsx
index 1306e9dae20..e347d896405 100644
--- a/packages/cli/src/ui/components/messages/ToolMessage.tsx
+++ b/packages/cli/src/ui/components/messages/ToolMessage.tsx
@@ -28,12 +28,13 @@ import { ToolConfirmationMessage } from './ToolConfirmationMessage.js';
 import { PlanSummaryDisplay } from '../PlanSummaryDisplay.js';
 import { ShellInputPrompt } from '../ShellInputPrompt.js';
 import { SHELL_COMMAND_NAME, SHELL_NAME } from '../../constants.js';
+import { isCollapsibleTool } from './CompactToolGroupDisplay.js';
 import { localizeToolDisplayName } from '../../../i18n/index.js';
 import { formatDuration, formatTokenCount } from '../../utils/formatters.js';
 import { theme } from '../../semantic-colors.js';
 import { useSettings } from '../../contexts/SettingsContext.js';
 import type { LoadedSettings } from '../../../config/settings.js';
-import { useCompactMode } from '../../contexts/CompactModeContext.js';
+
 import {
   escapeAnsiCtrlCodes,
   getCachedStringWidth,
@@ -667,15 +668,18 @@ export const ToolMessage: React.FC<ToolMessageProps> = ({
     renderOutputAsMarkdown = false;
   }
 
-  // Use the custom hook to determine the display type
-  const displayRenderer = useResultDisplayRenderer(resultDisplay);
-  const { compactMode } = useCompactMode();
+  const effectiveDisplayRenderer = useResultDisplayRenderer(resultDisplay);
 
-  const isCompleted = status === ToolCallStatus.Success;
-  const shouldCollapse = compactMode && isCompleted && !forceShowResult;
-  const effectiveDisplayRenderer = shouldCollapse
-    ? { type: 'none' as const }
-    : displayRenderer;
+  // Collapse text/ANSI output for completed collapsible tools (read/search/list)
+  // to reduce scrollback noise. Non-collapsible tools (command/edit/agent/MCP/etc.)
+  // always show results — their output IS the answer. Canceled tools keep partial
+  // output visible. Diff, plan, todo, task results always render regardless.
+  const shouldCollapseResult =
+    !forceShowResult &&
+    status === ToolCallStatus.Success &&
+    isCollapsibleTool(name) &&
+    (effectiveDisplayRenderer.type === 'string' ||
+      effectiveDisplayRenderer.type === 'ansi');
 
   return (
     <Box paddingX={1} paddingY={0} flexDirection="column">
@@ -701,7 +705,7 @@ export const ToolMessage: React.FC<ToolMessageProps> = ({
         />
         {emphasis === 'high' && <TrailingIndicator />}
       </Box>
-      {effectiveDisplayRenderer.type !== 'none' && (
+      {effectiveDisplayRenderer.type !== 'none' && !shouldCollapseResult && (
         <Box paddingLeft={STATUS_INDICATOR_WIDTH} width="100%">
           <Box flexDirection="column">
             {effectiveDisplayRenderer.type === 'todo' && (
@@ -782,7 +786,6 @@ const ToolInfo: React.FC<ToolInfo> = ({
   status,
   emphasis,
 }) => {
-  const { compactMode } = useCompactMode();
   const nameColor = React.useMemo<string>(() => {
     switch (emphasis) {
       case 'high':
@@ -797,15 +800,13 @@ const ToolInfo: React.FC<ToolInfo> = ({
       }
     }
   }, [emphasis]);
-  const isDim = compactMode && status === ToolCallStatus.Success;
   return (
     <Box flexGrow={1}>
       <Text
         wrap="truncate-end"
         strikethrough={status === ToolCallStatus.Canceled}
-        dimColor={isDim}
       >
-        <Text color={nameColor} bold={!isDim}>
+        <Text color={nameColor} bold>
           {localizeToolDisplayName(name)}
         </Text>{' '}
         <Text color={theme.text.secondary}>{description}</Text>
diff --git a/packages/cli/src/ui/components/messages/__snapshots__/ToolGroupMessage.test.tsx.snap b/packages/cli/src/ui/components/messages/__snapshots__/ToolGroupMessage.test.tsx.snap
index a28231587c5..cf6abc1874b 100644
--- a/packages/cli/src/ui/components/messages/__snapshots__/ToolGroupMessage.test.tsx.snap
+++ b/packages/cli/src/ui/components/messages/__snapshots__/ToolGroupMessage.test.tsx.snap
@@ -1,9 +1,9 @@
 // Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
 
 exports[`<ToolGroupMessage /> > Confirmation Handling > shows confirmation dialog for first confirming tool only 1`] = `
-"MockTool[tool-1]: ? first-confirm - A tool for testing (high)
+"MockTool[tool-1]: ? first-confirm - A tool for testing (high) [forceShow]
 MockConfirmation: Confirm first tool
-MockTool[tool-2]: ? second-confirm - A tool for testing (low)"
+MockTool[tool-2]: ? second-confirm - A tool for testing (low) [forceShow]"
 `;
 
 exports[`<ToolGroupMessage /> > Golden Snapshots > renders empty tool calls array 1`] = `""`;
@@ -17,7 +17,7 @@ MockTool[tool-3]: o write_file - Write to file (medium)"
 exports[`<ToolGroupMessage /> > Golden Snapshots > renders multiple tool calls with different statuses 1`] = `
 "MockTool[tool-1]: ✓ successful-tool - This tool succeeded (medium)
 MockTool[tool-2]: o pending-tool - This tool is pending (medium)
-MockTool[tool-3]: x error-tool - This tool failed (medium)"
+MockTool[tool-3]: x error-tool - This tool failed (medium) [forceShow]"
 `;
 
 exports[`<ToolGroupMessage /> > Golden Snapshots > renders shell command 1`] = `"MockTool[shell-1]: ✓ run_shell_command - Execute shell command (medium)"`;
@@ -26,7 +26,7 @@ exports[`<ToolGroupMessage /> > Golden Snapshots > renders single successful too
 
 exports[`<ToolGroupMessage /> > Golden Snapshots > renders tool call awaiting confirmation 1`] = `
 "MockTool[tool-confirm]: ? confirmation-tool - This tool needs confirmation
-(high)
+(high) [forceShow]
 MockConfirmation: Are you sure you want to proceed?"
 `;
 
@@ -45,7 +45,7 @@ might cause wrapping issues (medium)"
 `;
 
 exports[`<ToolGroupMessage /> > Height Calculation > calculates available height correctly with multiple tools with results 1`] = `
-"MockTool[tool-1]: ✓ test-tool - A tool for testing (medium)
+"MockTool[tool-1]: ⊷ test-tool - A tool for testing (medium)
 MockTool[tool-2]: ✓ test-tool - A tool for testing (medium)
 MockTool[tool-3]: ✓ test-tool - A tool for testing (medium)"
 `;
diff --git a/packages/cli/src/ui/utils/mergeCompactToolGroups.test.ts b/packages/cli/src/ui/utils/mergeCompactToolGroups.test.ts
index f68e04da7fb..24ccb05b525 100644
--- a/packages/cli/src/ui/utils/mergeCompactToolGroups.test.ts
+++ b/packages/cli/src/ui/utils/mergeCompactToolGroups.test.ts
@@ -586,14 +586,14 @@ describe('compactToggleHasVisualEffect', () => {
     expect(compactToggleHasVisualEffect(history)).toBe(false);
   });
 
-  it('returns true when any tool_group is present', () => {
+  it('returns false when only tool_group is present (no compact mode effect)', () => {
     const history: HistoryItem[] = [
       { type: 'user', id: 1, text: 'run' },
       createToolGroup(2, [
         createTool('c1', 'shell', ToolCallStatus.Success),
       ]) as HistoryItem,
     ];
-    expect(compactToggleHasVisualEffect(history)).toBe(true);
+    expect(compactToggleHasVisualEffect(history)).toBe(false);
   });
 
   it('returns true when any gemini_thought is present', () => {
diff --git a/packages/cli/src/ui/utils/mergeCompactToolGroups.ts b/packages/cli/src/ui/utils/mergeCompactToolGroups.ts
index 5cdc1e2a2a9..31e078a7c2f 100644
--- a/packages/cli/src/ui/utils/mergeCompactToolGroups.ts
+++ b/packages/cli/src/ui/utils/mergeCompactToolGroups.ts
@@ -135,21 +135,15 @@ function isHiddenInCompactMode(item: HistoryItem): boolean {
  * Ctrl+O for plain-chat sessions that have neither tool calls nor thinking
  * blocks regardless of conversation length.
  *
- * Conservative: returns true for any `tool_group`, even though a history of
- * only force-expanded groups would technically render the same way in both
- * modes (force-expand groups bypass the compact-rendering path and their
- * adjacent `tool_use_summary` items are not absorbed). Distinguishing
- * force-expand from regular groups requires `embeddedShellFocused` and
- * `activePtyId`, which are not cheaply available at the keypress handler
- * call site — we accept the false-positive in exchange for keeping this
- * predicate self-contained and O(N).
+ * Currently only `gemini_thought` and `gemini_thought_content` items are
+ * affected by compact mode. Tool groups use type-based partitioning that
+ * is independent of compact mode.
  */
 export function compactToggleHasVisualEffect(
   history: readonly HistoryItem[],
 ): boolean {
   for (const item of history) {
     if (
-      item.type === 'tool_group' ||
       item.type === 'gemini_thought' ||
       item.type === 'gemini_thought_content'
     ) {