Option to hide/collapse internal tool call details in the VS Code UI

Preflight Checklist

• [x] I have searched existing requests and this feature hasn't been requested yet
• [x] This is a single feature request (not multiple features)

Problem Statement

When using Claude Code with a subagent architecture (Task tool spawning specialized agents), the UI displays the full input prompt sent to each subagent, including system instructions, context loading commands, and internal routing logic. This creates a noisy experience during conversational workflows like coaching sessions, where the user just wants to see the final response — not the internal orchestration.

For example, when an orchestrator dispatches to a coaching agent, the user sees the full Task block containing the agent's system prompt, file loading instructions, and handoff data before seeing the actual coaching response. In multi-phase workflows (e.g., data collection agent → coaching agent), this means scrolling past multiple blocks of internal prompt engineering to reach the conversational output.

The current behavior is great for debugging and development, but for conversational or end-user-facing use cases, it breaks the flow and makes the experience feel like watching a machine rather than having a conversation.

Proposed Solution

A setting (e.g., claudeCode.hideToolCallDetails or a verbosity level) that collapses or hides internal tool call inputs/outputs by default, while still allowing users to expand them on click if needed.
Ideal behavior:

• Collapsed by default: Task tool dispatches show a minimal one-line summary (e.g., "→ coaching-agent") instead of the full input prompt
• Expandable on click: Users can click to reveal full details when debugging
• Configurable: A setting with options like "auto" (collapse in non-terminal mode), "always" (always collapse), or "never" (current behavior)

This would make Claude Code viable for conversational workflows (coaching, planning, brainstorming) where the human experience matters, not just the technical output.

Alternative Solutions

• I've tried adding directives to my CLAUDE.md to suppress extended thinking blocks during conversational modes. This reduces content inside the blocks but doesn't hide the UI elements themselves.
• Currently I work around this by accepting the visual noise, but it breaks immersion in coaching/persona-based workflows where the interaction should feel like a conversation.
• Other tools like ChatGPT and Claude.ai web handle this by only showing the final response, with tool use details collapsed or hidden behind a toggle.

Priority

Medium - Would be very helpful

Feature Category

Configuration and settings

Use Case Example

I run a multi-agent system with six specialized agents (coaching, filing, research, review, building, and a kickoff assistant). A typical morning workflow:

1. I say "Good morning"
2. The orchestrator checks the time, then asks health check-in questions one at a time
3. Collected data is dispatched to a Sonnet-based kickoff assistant (Task tool) for logging
4. The kickoff assistant hands off to an Opus-based coaching agent (Task tool) for day planning

Current experience: I see two large Task blocks containing full system prompts, file paths, and routing instructions before I see the coaching agent's actual response. The conversational flow is interrupted by implementation details.

Desired experience: I see a subtle indicator like "→ kickoff-assistant" and "→ coaching-agent" (expandable if I want to inspect), and the coaching response appears cleanly as if I'm having a direct conversation.

Additional Context

This is increasingly relevant as more users adopt Claude Code's native subagent architecture (.claude/agents/) for workflows beyond pure coding — personal productivity, coaching, content creation, and life management systems. The current UI assumes the user is a developer debugging tool calls, but the subagent system enables use cases where the end experience should feel conversational.

A verbosity toggle would make Claude Code competitive with dedicated chat interfaces while retaining its power-user debugging capabilities.