[FEATURE] Add minimize / collapse control to side-chat panels (long-running sessions stack visual context)

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 working on multi-hour pair-programming sessions in Claude Code, I frequently spawn side chats to ask focused questions without polluting the main conversation's context (planning a sub-task, debugging an isolated issue, clarifying a decision). Each side chat opens a new panel.

The problem: once a side chat has run for a while, it accumulates a tall scroll history of long messages — code blocks, tables, multi-section responses. There is currently no way to collapse, minimize, or visually park that panel while I focus on the main chat or another side chat.

Concrete pain points:

1. Visual real estate. A side chat with 20+ messages occupies the entire side panel even when I'm actively working in the main chat. Scrolling the main chat means scrolling past the side chat's full content every time.

1. Mental context-switching cost. Multiple active side chats stack vertically. There's no way to say "park this one — I'll come back to it" without closing it (which loses history) or just leaving it open (which clutters the view).

1. Re-reading old plans. When a side chat has produced a long technical plan I want to refer back to, I have to either keep it fully expanded (taking up half my screen) or close it (and lose the ability to continue the conversation).

1. No equivalent of an IDE's collapsed panel. Every modern dev tool (VS Code's terminal/output panels, JetBrains' tool windows, browser DevTools panels) has a minimize/collapse affordance. Side chats currently behave more like modal dialogs — fully present or gone.

This is becoming more pronounced as I rely on side chats for parallel work streams during long sessions (planning a PR in one side chat while reviewing code in the main chat, for example).

Proposed Solution

Add a minimize button (and matching expand-to-restore affordance) to each side-chat panel header.

Behavior:

• Click "minimize" → the side chat collapses to a slim tab/header strip (similar to a chat-style minimized window) at the bottom of the screen, or as a row in a "minimized chats" tray.
• The strip shows: the side chat's title (or first user message truncated), a small unread indicator if the agent has produced new output since minimize, and a click-to-restore action.
• Clicking the strip re-expands the side chat in place with full scroll history preserved — no context lost.
• Multiple minimized side chats stack as multiple strips, so I can park 2–3 conversations and switch between them.

Keyboard shortcut would be ideal but not required for v1:

• Cmd/Ctrl + Shift + M to minimize the currently focused side chat
• Cmd/Ctrl + Shift + [number] to restore the Nth minimized chat

The minimize state should persist across the session (and ideally across CLI restarts so a long-running plan I've parked is still parked tomorrow).

Crucial: minimizing must not stop the agent if it's mid-task. A background agent should keep running and notify (via the strip's unread indicator) when it completes.

Alternative Solutions

Workarounds I've tried, all unsatisfactory:

1. Close the side chat — loses scroll history and breaks the ability to continue the conversation. Often the side chat has produced a multi-section plan I want to refer back to.

1. Scroll the side chat to the top and leave it — doesn't reclaim screen space; the panel still occupies its slot.

1. Resize the side chat panel to minimal width — partially helps but text becomes unreadable; not equivalent to true minimize. Also have to repeat for every side chat.

1. Copy the side chat content to a local note file before closing — works for preserving information but breaks the conversation continuity (can't continue the chat after).

1. Run only one side chat at a time — defeats the purpose; parallel side chats are genuinely useful for parallel sub-tasks.

I am not aware of any current feature in Claude Code that addresses this. Documentation search for "minimize", "collapse", "park", "panel state" returned nothing relevant.

Priority

Medium - Would be very helpful

Feature Category

Interactive mode (TUI)

Use Case Example

Scenario: shipping a small PR while planning the next one in parallel.

1. I'm in the main chat actively implementing a code change for PR A. The agent is editing files, running tests, and reporting back. This is the conversation I'm focused on.

1. While waiting for tests, I spawn a side chat to plan PR B: "draft the implementation plan for a new feature, considering tradeoffs X / Y / Z". The agent in the side chat produces a multi-section plan with code snippets, file paths, and a verification checklist — maybe 15 messages, 2000+ lines of total content.

1. The PR B plan is great. I want to keep it for reference and continue the conversation later (to refine specific sections). But right now I need to focus on PR A.

1. Today's reality: the PR B side chat sits open, taking up the entire side panel. Every time I scroll the main chat to review what the PR A agent is doing, I'm also scrolling past the PR B side chat's long content. My attention keeps drifting to the parked plan.

1. With minimize: I'd click "minimize" on the PR B side chat. It collapses to a strip at the bottom labeled "PR B: implementation plan". I get my full panel back for the main chat. When PR A ships, I click the strip → PR B side chat re-expands with full history → I continue refining the plan.

This is a daily pattern for me when working on multi-PR sprints or when juggling planning + execution.

Second scenario: handing off context to a teammate.

I produce a detailed technical plan in a side chat, want to share it with a teammate via screenshot. With minimize, I'd minimize the main chat so the screenshot is cleanly just the side-chat panel. Today I have to scroll/crop the screenshot to isolate the side chat.

Additional Context

Reference implementations of "minimize chat panel" patterns in other tools:

• Slack / Microsoft Teams — minimize active thread/DM panel to a strip at the bottom, restore on click
• Browser DevTools — collapse the Network/Console/Sources panel to icon row, click to re-expand
• VS Code — minimize the integrated terminal to the title bar, "Hide" preserves history, "Restore" brings it back
• macOS / Windows window management — Cmd+M / Win+Down minimizes any window to the dock/taskbar

Technical considerations:

• The minimized strip should be visually distinct from a closed chat (so users don't confuse "minimized" with "gone").
• Restore should be a single click — not behind a menu.
• The minimized state should preserve scroll position so when restored, the user is back where they were.
• The agent should continue running in a minimized chat. The unread indicator on the strip is the primary feedback channel that work has completed.
• If implemented as a bottom-stacked tray, consider a max-strips limit (e.g., 5) with overflow into a "+N more" menu, so the tray doesn't grow unbounded.

Related but distinct from:

• Conversation history / persistence (already exists)
• Multi-tab chat support (different feature — parallel chats, not parked chats)
• Background tasks (closer but applies to long-running operations, not idle conversations)

Mockup sketch (text-only):
+---------------------------+----------------------+
| | |
| Main chat | Side chat (active) |
| (focused) | ... |
| | ... |
| | |
+---------------------------+----------------------+
| [PR B plan ●] [Debug session] [Refactor plan] | <- minimized strips
+---------------------------------------------------+

Each strip is clickable to restore the corresponding side chat.