Built-in tooling for managing multiple concurrent CLI sessions

[JoshLove-msft]

Describe the feature or problem you'd like to solve

The Copilot CLI is excellent for one focused session at a time, but power users frequently keep many concurrent sessions running across multiple repos/branches/tasks (especially with --yolo --autopilot). Today the CLI offers no first-class way to see, switch between, or manage that fleet:

• /resume lists historical sessions but doesn't surface which ones are currently running (a copilot process holding session.db open), and on busy days recent sessions can scroll off (see /resume list drops recent sessions — should sort by most recent first #2883).
• There's no built-in way to see at-a-glance what each running session is doing right now (mid-turn vs. waiting for input vs. exited), what its summary is, what repo/branch it's working on, or what PR it's tied to.
• There's no way to jump back to an existing terminal/tab that already has a given session open — users end up either spawning duplicates with copilot --resume=<id> (and losing scrollback / live state) or hunting through tabs by hand.
• Permissions, autopilot flags, and refresh/timing are all per-invocation; there's no central place to manage defaults across the fleet.

I prototyped a third-party tool that addresses this for Windows Terminal users — copilot-dashboard — and it has been useful enough that I think first-party tooling for fleet management would benefit a much wider audience.

Proposed solution

A built-in CLI command (e.g. copilot sessions or copilot dashboard) that opens a TUI for browsing and managing all local sessions, with at minimum:

1. Live process awareness — for each session, show whether a copilot process is currently holding it open (LIVE), and what the agent is doing right now (working / waiting / done), derived from events.jsonl.
2. Sortable, filterable, groupable list — by recency, repo, branch, summary, agent state; quick filter (/); group-by-repo with collapsible groups.
3. Jump-to-tab — pressing Enter on a row should focus the existing terminal tab/window already running that session (instead of spawning a duplicate). On Windows this is doable via UI Automation against WindowsTerminal.exe; equivalents exist on macOS (iTerm2 AppleScript) and Linux (tmux/wezterm IPC).
4. Launch / resume — n to start a fresh session in a new tab in the user's preferred terminal; Enter to focus-or-launch a resumed session.
5. Per-session metadata — show summary, repo/branch, cwd, turn count, linked PR (with click-to-open), last-updated timestamp.
6. Persistent preferences — defaults like --yolo, --autopilot, refresh interval, terminal-launch strategy, stored in a config file the user can edit.
7. Auto-refresh with a visible countdown so the user can trust what they're looking at.

The dashboard could ship as an optional copilot subcommand or as a separate small binary that's installed alongside, similar to gh dash for the GitHub CLI.

Example prompts or workflows

1. Multitasking across repos. I have 6 sessions running with --yolo --autopilot against different repos. I run copilot sessions, see at a glance which 2 are mid-turn and which 4 are waiting on me, hit Enter on a waiting one, and the existing tab pops to the foreground — no duplicate session.
2. "Where did I leave that thing?" A session from yesterday morning was about a build failure but I don't remember the ID. I open the dashboard, type /build to filter by summary, find it in 2 seconds, hit Enter, and it resumes (or focuses if still alive).
3. Triaging finished autopilot runs. I left 5 --autopilot sessions running overnight. In the morning I open the dashboard, sort by Agent state, see which finished cleanly (done), which are blocked (waiting), and which crashed (no recent events). I jump straight to the ones that need attention.
4. Per-repo focus. I press g to group by repo and → to collapse the noise from repos I don't care about right now, leaving just the 3 sessions in the repo I'm focused on.
5. One-keystroke "new yolo session here." From the dashboard, n opens a brand-new copilot --yolo --autopilot tab pre-cd'd to the selected row's working directory.

Additional context

I've been running a working prototype of this on Windows: https://github.com/JoshLove-msft/copilot-dashboard

It implements all of the above for Windows Terminal:

• Reads ~/.copilot/session-state/<uuid>/workspace.yaml and events.jsonl for metadata + live agent state.
• Uses psutil to detect which copilot processes are holding a session.db open (LIVE detection).
• Uses UI Automation against WindowsTerminal.exe to find and focus the right tab by title (the WT tab title equals the session summary because copilot sets it via OSC 0).
• Spawns new tabs via wt -w 0 new-tab --title "<summary>" -d <cwd> -- pwsh -NoExit -Command "copilot --yolo --autopilot --resume=<id>".
• For brand-new sessions the tab title initially says copilot:new and then auto-renames to the session summary once the workspace summary is computed (a Start-ThreadJob polls session-state/ and emits an OSC title sequence).
• Settings (yolo / autopilot / refresh interval) persist to ~/.copilot-dashboard/config.json.

Happy to contribute the design or relevant pieces if useful. The cross-platform parts (TUI, session metadata reading, agent-state derivation) are reusable; only the "find/launch the user's terminal tab" piece needs platform-specific backends.

Thanks for considering!

[JoshLove-msft]

Another tool that has sprung up to fill this gap - https://github.com/jongio/dispatch