diff --git a/README.md b/README.md
index f8d60acb..0e87fb1f 100644
--- a/README.md
+++ b/README.md
@@ -51,9 +51,27 @@ A powerful, feature-rich command-line interface for interacting with Model Conte
 - **Session Persistence**: Save/load/list conversation sessions with auto-save every 10 turns (`/sessions`)
 - **Conversation Export**: Export conversations as Markdown or JSON with metadata (`/export`)
 
+### Dashboard (Real-Time Browser UI)
+- **`--dashboard` flag**: Launch a real-time browser dashboard alongside chat mode
+- **Agent Terminal**: Live conversation view with message bubbles, streaming tokens, and attachment rendering
+- **Activity Stream**: Tool call/result pairs, reasoning steps, and user attachment events
+- **Plan Viewer**: Visual execution plan progress with DAG rendering
+- **Tool Registry**: Browse discovered tools, trigger execution from the browser
+- **Config Panel**: View and switch providers, models, and system prompt
+- **File Attachments**: "+" button for browser file upload, drag-and-drop, and clipboard paste
+
+### Multi-Modal Attachments
+- **`/attach` command**: Stage files for the next message — images, text/code, and audio (aliases: `/file`, `/image`)
+- **`--attach` CLI flag**: Attach files to the first message (repeatable: `--attach img.png --attach code.py`)
+- **Inline `@file:` references**: Mention `@file:path/to/file` anywhere in a message to attach it
+- **Image URL detection**: HTTP/HTTPS image URLs in messages are automatically sent as vision content
+- **Supported formats**: PNG, JPEG, GIF, WebP, HEIC (images), MP3, WAV (audio), plus 25+ text/code extensions
+- **Dashboard rendering**: Image thumbnails, expandable text previews, audio players, file badges
+- **Browser upload**: "+" button in dashboard chat input with drag-and-drop and clipboard paste support
+
 ### Code Quality
 - **Core/UI Separation**: Core modules use `logging` only — no UI imports
-- **3,800+ tests**: Comprehensive test suite with branch coverage, integration tests, and 60% minimum threshold
+- **4,300+ tests**: Comprehensive test suite with branch coverage, integration tests, and 60% minimum threshold
 - **15 Architecture Principles**: Documented and enforced (see [architecture.md](architecture.md))
 - **Full [Roadmap](roadmap.md)**: Tiers 1-6 complete, Tiers 7-12 planned (traces, memory scopes, skills, scheduling, multi-agent)
 
@@ -82,6 +100,7 @@ The MCP CLI is built on a modular architecture with clean separation of concerns
 - **Performance Metrics**: Response timing, words/second, and execution statistics
 - **Rich Formatting**: Markdown rendering, syntax highlighting, and progress indicators
 - **Token Usage Tracking**: Per-turn and cumulative API token usage with `/usage` command
+- **Multi-Modal Attachments**: Attach images, text files, and audio to messages via `/attach`, `--attach`, `@file:` refs, or browser upload
 - **Session Persistence**: Auto-save and manual save/load of conversation sessions
 - **Conversation Export**: Export to Markdown or JSON with metadata and token usage
 
@@ -161,6 +180,8 @@ Comprehensive documentation is available in the `docs/` directory:
 
 ### Specialized Documentation
 - **[Execution Plans](docs/PLANNING.md)** - Plan creation, parallel execution, variable resolution, checkpointing, guards, and re-planning
+- **[Dashboard](docs/DASHBOARD.md)** - Real-time browser UI with agent terminal, activity stream, and file uploads
+- **[Attachments](docs/ATTACHMENTS.md)** - Multi-modal file attachments: images, text, audio, and browser upload
 - **[MCP Apps](docs/MCP_APPS.md)** - Interactive browser UIs served by MCP servers (SEP-1865)
 - **[OAuth Authentication](docs/OAUTH.md)** - OAuth flows, storage backends, and MCP server integration
 - **[Streaming Integration](docs/STREAMING.md)** - Real-time response streaming architecture
@@ -290,6 +311,9 @@ Global options available for all modes and commands:
 - `--vm`: [Experimental] Enable AI virtual memory for context management
 - `--vm-budget`: Token budget for conversation events in VM mode (default: 128000, on top of system prompt)
 - `--vm-mode`: VM mode — `passive` (default), `relaxed`, or `strict`
+- `--dashboard`: Launch a real-time browser dashboard UI alongside chat mode
+- `--attach`: Attach files to the first message (repeatable: `--attach img.png --attach code.py`)
+- `--plan-tools`: Enable model-driven planning — the LLM autonomously creates and executes multi-step plans
 
 ### Environment Variables
 
@@ -332,6 +356,12 @@ mcp-cli --server sqlite --model qwen2.5-coder
 # Switch to cloud providers (requires API keys)
 mcp-cli chat --server sqlite --provider openai --model gpt-5
 mcp-cli chat --server sqlite --provider anthropic --model claude-4-5-sonnet
+
+# Launch with real-time browser dashboard
+mcp-cli --server sqlite --dashboard
+
+# Attach files to the first message
+mcp-cli --server sqlite --attach image.png --attach data.csv
 ```
 
 ### 2. Interactive Mode
@@ -527,6 +557,23 @@ mcp-cli --server sqlite --provider anthropic --model claude-4-5-opus
 
 **Note**: Servers added via `/server add` are stored in `~/.mcp-cli/preferences.json` and persist across sessions. Project servers remain in `server_config.json`.
 
+#### Multi-Modal Attachments
+```bash
+/attach image.png                  # Stage an image for the next message
+/attach code.py                    # Stage a text file
+/attach list                       # Show currently staged files
+/attach clear                      # Clear staged files
+/file data.csv                     # Alias for /attach
+/image screenshot.heic             # Alias for /attach
+
+# Inline file references (in any message)
+@file:screenshot.png describe what you see
+@file:data.csv summarize this data
+
+# Image URLs are auto-detected
+https://example.com/photo.jpg what is in this image?
+```
+
 #### Conversation Management
 ```bash
 /conversation                      # Show conversation history
@@ -613,6 +660,14 @@ See [Token Management Guide](docs/TOKEN_MANAGEMENT.md) for comprehensive documen
 - Verbose and compact display modes
 - Complete execution history and timing
 
+#### Multi-Modal Attachments
+- Attach images, text files, and audio to any message
+- `/attach` command with staging, list, and clear (aliases: `/file`, `/image`)
+- Inline `@file:path` references in any message
+- `--attach` CLI flag for first-message attachments
+- Browser "+" button with drag-and-drop and clipboard paste (with `--dashboard`)
+- Dashboard renders thumbnails, text previews, and audio players
+
 #### Provider Integration
 - Seamless switching between providers
 - Model-specific optimizations
diff --git a/docs/ATTACHMENTS.md b/docs/ATTACHMENTS.md
new file mode 100644
index 00000000..a87de92b
--- /dev/null
+++ b/docs/ATTACHMENTS.md
@@ -0,0 +1,201 @@
+# Multi-Modal Attachments
+
+MCP CLI supports attaching images, text files, and audio to messages. Attachments are converted to content blocks that multimodal LLMs can process (vision, text analysis, audio understanding).
+
+## Quick Start
+
+```bash
+# Attach files to the first message via CLI flag
+mcp-cli --server sqlite --attach photo.png --attach data.csv
+
+# In chat, use the /attach command
+/attach screenshot.png
+/attach code.py
+Tell me what you see and review the code
+
+# Or use inline @file: references
+@file:image.png describe what's in this image
+```
+
+## Three Ways to Attach
+
+### 1. `/attach` Command (Chat Mode)
+
+Stage files before sending a message:
+
+```bash
+/attach photo.png              # Stage an image
+/attach src/main.py            # Stage a code file
+/attach recording.mp3          # Stage an audio file
+```
+
+Aliases: `/file`, `/image`
+
+**Manage staging:**
+```bash
+/attach list                   # Show currently staged files
+/attach clear                  # Clear all staged files
+```
+
+Staged files are sent with your next message and automatically cleared.
+
+### 2. `--attach` CLI Flag
+
+Attach files to the first message when starting chat:
+
+```bash
+mcp-cli --server sqlite --attach image.png
+mcp-cli --server sqlite --attach img.png --attach data.csv --attach code.py
+```
+
+The flag is repeatable — use it multiple times for multiple files.
+
+### 3. Inline `@file:` References
+
+Reference files directly in any message:
+
+```bash
+@file:screenshot.png describe what you see
+@file:report.txt @file:data.csv compare these two files
+Look at @file:diagram.png and explain the architecture
+```
+
+The `@file:` prefix is removed from the message text before sending.
+
+### Image URL Detection
+
+HTTP/HTTPS image URLs in messages are automatically detected and sent as vision content:
+
+```
+https://example.com/chart.png what does this chart show?
+```
+
+Supported URL patterns: `.png`, `.jpg`, `.jpeg`, `.gif`, `.webp`
+
+## Supported File Types
+
+### Images
+| Extension | MIME Type |
+|-----------|-----------|
+| `.png` | `image/png` |
+| `.jpg`, `.jpeg` | `image/jpeg` |
+| `.gif` | `image/gif` |
+| `.webp` | `image/webp` |
+| `.heic` | `image/heic` |
+
+Images are base64-encoded and sent as `image_url` content blocks with configurable detail level.
+
+### Audio
+| Extension | MIME Type |
+|-----------|-----------|
+| `.mp3` | `audio/mpeg` |
+| `.wav` | `audio/wav` |
+
+Audio is base64-encoded and sent as `input_audio` content blocks.
+
+### Text & Code
+| Extension | MIME Type |
+|-----------|-----------|
+| `.txt` | `text/plain` |
+| `.md` | `text/markdown` |
+| `.csv` | `text/csv` |
+| `.json` | `application/json` |
+| `.html` | `text/html` |
+| `.xml` | `text/xml` |
+| `.yaml`, `.yml` | `text/yaml` |
+| `.py` | `text/plain` |
+| `.js`, `.jsx` | `text/plain` |
+| `.ts`, `.tsx` | `text/plain` |
+| `.sh`, `.bash` | `text/plain` |
+| `.rs` | `text/plain` |
+| `.go` | `text/plain` |
+| `.java` | `text/plain` |
+| `.c`, `.cpp` | `text/plain` |
+| `.h`, `.hpp` | `text/plain` |
+| `.rb` | `text/plain` |
+| `.swift` | `text/plain` |
+| `.kt` | `text/plain` |
+| `.sql` | `text/plain` |
+| `.toml` | `text/plain` |
+| `.ini`, `.cfg` | `text/plain` |
+| `.env` | `text/plain` |
+| `.log` | `text/plain` |
+
+Text files are read as UTF-8 (with Latin-1 fallback) and wrapped in labeled text blocks.
+
+## Size Limits
+
+| Limit | Value |
+|-------|-------|
+| Maximum file size | 20 MB |
+| Maximum attachments per message | 10 |
+
+These defaults are configured in `src/mcp_cli/config/defaults.py`.
+
+## Browser Upload (Dashboard)
+
+When using `--dashboard`, the agent terminal provides browser-based file attachment:
+
+### "+" Button
+Click the "+" button next to the chat input to open a file picker. Select one or more files to stage them.
+
+### Drag and Drop
+Drag files from your file manager onto the chat area. A drop overlay appears to confirm the target.
+
+### Clipboard Paste
+Paste images directly into the chat input (Ctrl/Cmd+V). Screenshots and copied images are automatically staged.
+
+### Staging Strip
+Staged files appear as removable badges above the chat input:
+- Image files show a small thumbnail preview
+- All files show the filename with a "x" remove button
+- Click "x" to remove a file before sending
+
+Files are sent when you press Enter or click Send. The staging strip clears automatically.
+
+## Dashboard Rendering
+
+When messages with attachments appear in the dashboard, they render as:
+
+- **Small images (<100KB)**: Inline thumbnail previews (max 200x150px)
+- **Large images (>100KB)**: Metadata badge showing filename and size
+- **URL images**: Thumbnail loaded from the URL
+- **Text files**: Expandable preview showing the first 2000 characters
+- **Audio files**: HTML5 `<audio>` player with playback controls
+
+The activity stream shows attachment events as badge cards with a paperclip icon, filenames, and total size.
+
+## How It Works
+
+### Content Block Construction
+
+Each file type produces specific OpenAI-compatible content blocks:
+
+- **Images** → `{"type": "image_url", "image_url": {"url": "data:image/png;base64,...", "detail": "auto"}}`
+- **Audio** → `{"type": "input_audio", "input_audio": {"data": "...", "format": "mp3"}}`
+- **Text** → `{"type": "text", "text": "--- filename ---\n...\n--- end filename ---"}`
+
+When attachments are present, the user message `content` field becomes a list of content blocks (multimodal format) instead of a plain string.
+
+### Attachment Staging
+
+The `AttachmentStaging` class on `ChatContext` manages the staging lifecycle:
+
+1. Files are staged via `/attach`, `--attach`, or browser upload
+2. The chat loop calls `drain()` to collect and clear staged files
+3. Combined with inline `@file:` refs and detected image URLs
+4. `build_multimodal_content()` assembles the final content block list
+5. If no attachments exist, the message stays as a plain string (backward compatible)
+
+### Dashboard Descriptors
+
+To avoid sending large base64 payloads over WebSocket, the dashboard uses lightweight **attachment descriptors**:
+
+- `display_name`, `size_bytes`, `mime_type`, `kind` (image/text/audio/unknown)
+- `preview_url`: data URI for small images, HTTP URL for URL images, `None` for large files
+- `text_preview`: first 2000 characters for text files
+- `audio_data_uri`: data URI for small audio files
+
+These thresholds are configured in `src/mcp_cli/config/defaults.py`:
+- `DEFAULT_DASHBOARD_INLINE_IMAGE_THRESHOLD`: 100 KB
+- `DEFAULT_DASHBOARD_TEXT_PREVIEW_CHARS`: 2000
diff --git a/docs/COMMANDS.md b/docs/COMMANDS.md
index e8bd26e4..9f1637e3 100644
--- a/docs/COMMANDS.md
+++ b/docs/COMMANDS.md
@@ -377,6 +377,50 @@ Save and restore conversation sessions:
 
 Sessions are stored as JSON in `~/.mcp-cli/sessions/`. Auto-save triggers every 10 turns by default.
 
+### Multi-Modal Attachments
+
+Stage files to include in your next message. Supports images, text/code files, and audio.
+
+**Stage Files:**
+```bash
+/attach photo.png                  # Stage an image
+/attach code.py                    # Stage a text/code file
+/attach clip.mp3                   # Stage an audio file
+/file data.csv                     # Alias for /attach
+/image screenshot.heic             # Alias for /attach
+```
+
+**Manage Staging:**
+```bash
+/attach list                       # Show currently staged files
+/attach clear                      # Clear all staged files
+```
+
+**Inline References (in any message):**
+```bash
+@file:screenshot.png describe what you see in this image
+@file:report.txt @file:data.csv compare these two files
+```
+
+Image URLs in messages are automatically detected and sent as vision content.
+
+**Supported File Types:**
+- **Images:** `.png`, `.jpg`, `.jpeg`, `.gif`, `.webp`, `.heic`
+- **Audio:** `.mp3`, `.wav`
+- **Text/Code:** `.txt`, `.md`, `.csv`, `.json`, `.html`, `.xml`, `.yaml`, `.yml`, `.py`, `.js`, `.ts`, `.jsx`, `.tsx`, `.sh`, `.bash`, `.rs`, `.go`, `.java`, `.c`, `.cpp`, `.h`, `.hpp`, `.rb`, `.swift`, `.kt`, `.sql`, `.toml`, `.ini`, `.cfg`, `.env`, `.log`
+
+**Size Limits:**
+- Maximum file size: 20 MB per file
+- Maximum attachments per message: 10
+
+**CLI Flag:**
+```bash
+# Attach files to the first message (repeatable)
+mcp-cli --server sqlite --attach image.png --attach data.csv
+```
+
+See [ATTACHMENTS.md](./ATTACHMENTS.md) for comprehensive attachments documentation.
+
 ### Conversation Export
 
 Export conversations in structured formats:
diff --git a/docs/DASHBOARD.md b/docs/DASHBOARD.md
new file mode 100644
index 00000000..a63ba750
--- /dev/null
+++ b/docs/DASHBOARD.md
@@ -0,0 +1,145 @@
+# Dashboard — Real-Time Browser UI
+
+The dashboard provides a real-time browser interface that runs alongside chat mode, giving you visual feedback on conversations, tool execution, plans, and more.
+
+## Quick Start
+
+```bash
+# Launch chat with the dashboard
+mcp-cli --server sqlite --dashboard
+
+# With a specific model
+mcp-cli --server sqlite --provider openai --model gpt-5 --dashboard
+```
+
+A browser tab opens automatically at `http://localhost:<port>` with the dashboard UI.
+
+## Views
+
+The dashboard is a tabbed interface with five views:
+
+### Agent Terminal
+
+The primary conversation view — a chat interface mirroring the CLI terminal.
+
+- **Message bubbles**: User messages (right-aligned) and assistant messages (left-aligned) with markdown rendering and syntax highlighting
+- **Streaming tokens**: Watch assistant responses appear token-by-token in real time
+- **Attachment rendering**: Image thumbnails, expandable text previews, audio players, and file badges (see below)
+- **Chat input**: Type messages and press Enter to send — same as the CLI
+- **"+" attach button**: Click to attach files from the browser (see [Attachments](./ATTACHMENTS.md))
+- **Drag-and-drop**: Drag files onto the chat area to attach them
+- **Clipboard paste**: Paste screenshots or images directly into the chat input
+- **Search**: Ctrl/Cmd+F to search through conversation history
+
+### Activity Stream
+
+A chronological log of all chat-engine events:
+
+- **Tool calls**: Shows tool name, arguments, server, and timing
+- **Tool results**: Shows success/failure status, result previews, and errors
+- **Reasoning steps**: Displays the model's thinking/reasoning content when using reasoning models
+- **User attachments**: Shows file badges with names and sizes when attachments are included
+- **State transitions**: Agent state changes (idle, thinking, tool_calling, streaming)
+
+### Plan Viewer
+
+Visual rendering of execution plans (requires `--plan-tools`):
+
+- **DAG visualization**: Shows plan steps with dependency arrows and parallel markers
+- **Real-time progress**: Step status updates as the plan executes (pending, running, completed, failed)
+- **Step details**: Click a step to see its tool call, arguments, and result
+
+### Tool Registry
+
+Browse all discovered MCP tools:
+
+- **Tool list**: Name, description, server, and parameter schema
+- **Execute from browser**: Trigger tool execution directly from the dashboard
+- **Dynamic discovery**: New tools from `_meta.ui` annotations appear automatically
+
+### Config Panel
+
+View and modify runtime configuration:
+
+- **Provider/model**: See current provider and model, switch to a different one
+- **System prompt**: View and edit the system prompt
+- **Server list**: Connected MCP servers and their status
+
+## Architecture
+
+```
+Browser                          Python Backend
+┌─────────────────────┐         ┌──────────────────────┐
+│  shell.html         │◄──WS──►│  server.py (HTTP+WS) │
+│  ├─ agent-terminal  │         │  └─ router.py        │
+│  ├─ activity-stream │         │     └─ bridge.py     │
+│  ├─ plan-viewer     │         │        └─ ChatContext │
+│  ├─ tool-registry   │         └──────────────────────┘
+│  └─ config-panel    │
+└─────────────────────┘
+```
+
+- **`server.py`** — HTTP server for static files + WebSocket endpoint on a single port
+- **`shell.html`** — Host page that manages view iframes, tab switching, and WebSocket connection
+- **`router.py`** — Routes messages between views and agent bridges (supports multi-agent)
+- **`bridge.py`** — Integration layer between the chat engine and browser clients
+
+### Message Flow
+
+1. User types in agent-terminal → `postMessage` to shell.html
+2. Shell.html forwards via WebSocket → server.py → router.py → bridge.py
+3. Bridge puts message into `_input_queue` → chat loop picks it up
+4. Chat engine processes and broadcasts events back through the bridge
+5. Bridge sends WebSocket envelopes → shell.html → views update
+
+### WebSocket Protocol
+
+All messages use a standard envelope:
+
+```json
+{
+  "protocol": "mcp-dashboard",
+  "version": 2,
+  "type": "MESSAGE_TYPE",
+  "payload": { ... }
+}
+```
+
+Key message types:
+- `CONVERSATION_MESSAGE` — Chat messages (role, content, attachments)
+- `AGENT_STATE` — State transitions (idle, thinking, tool_calling, streaming)
+- `TOOL_RESULT` — Tool execution results
+- `STREAMING_TOKEN` — Individual streaming tokens
+- `CONVERSATION_HISTORY` — Full conversation replay on connect
+- `ACTIVITY_HISTORY` — Activity stream replay on connect
+
+## Session Replay
+
+When a browser connects (or reconnects), the dashboard automatically replays:
+
+1. **Conversation history** — All messages with their attachments, so the chat view is fully populated
+2. **Activity history** — Tool calls, results, reasoning steps, and user attachment events
+
+This means you can refresh the browser at any time without losing context.
+
+## File Attachments in the Dashboard
+
+The dashboard supports attaching files directly from the browser:
+
+- **"+" button**: Click to open a file picker
+- **Drag-and-drop**: Drag files onto the chat area
+- **Clipboard paste**: Paste images from the clipboard
+
+Staged files appear as removable badges above the chat input. When sent, files are base64-encoded and transmitted over WebSocket to the bridge, which stages them on `ChatContext.attachment_staging`. The existing chat loop drains staging and processes attachments — the same pipeline used by the CLI `/attach` command.
+
+Attachments render in message bubbles as:
+- **Images <100KB**: Inline thumbnail previews (clickable)
+- **Images >100KB**: Metadata badge (name + size)
+- **Text files**: Expandable code preview (first 2000 chars)
+- **Audio**: HTML5 audio player
+
+See [ATTACHMENTS.md](./ATTACHMENTS.md) for full attachment documentation.
+
+## Multi-Agent Support
+
+The dashboard architecture supports multiple agents via the router. Each agent gets its own bridge instance and can have a dedicated agent terminal view. See `src/mcp_cli/dashboard/MULTI_AGENT_SPEC.md` for the multi-agent specification.
diff --git a/pyproject.toml b/pyproject.toml
index dc2d661d..5980f937 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "mcp-cli"
-version = "0.16"
+version = "0.17"
 description = "A cli for the Model Context Provider"
 requires-python = ">=3.11"
 readme = "README.md"
diff --git a/roadmap.md b/roadmap.md
index f2666251..e686b0e4 100644
--- a/roadmap.md
+++ b/roadmap.md
@@ -547,6 +547,255 @@ With 6.8: User asks a question → model decides it needs a plan → creates and
 
 ---
 
+## Dashboard & Multi-Modal ✅ COMPLETE
+
+> **Goal:** Give users a real-time browser UI for conversations and enable multi-modal input (images, text files, audio) across CLI and browser.
+
+### D.1 Dashboard Infrastructure ✅
+
+Real-time browser dashboard alongside chat mode via `--dashboard` flag.
+
+**Files:** `src/mcp_cli/dashboard/` — `server.py`, `bridge.py`, `launcher.py`, `config.py`, `router.py`
+
+- HTTP + WebSocket server on a single port (`server.py`)
+- Bridge integrates chat engine events → browser clients (`bridge.py`)
+- Router supports multi-agent coordination (`router.py`)
+- Shell host page manages view iframes and WebSocket connection (`shell.html`)
+- Session replay on connect: `CONVERSATION_HISTORY` + `ACTIVITY_HISTORY`
+
+### D.2 Dashboard Views ✅
+
+Five tabbed views in the browser UI.
+
+**Files:** `src/mcp_cli/dashboard/static/views/` — `agent-terminal.html`, `activity-stream.html`, `plan-viewer.html`, `tool-registry.html`, `config-panel.html`
+
+- **Agent Terminal**: Chat bubbles, streaming tokens, markdown rendering, syntax highlighting, search
+- **Activity Stream**: Tool call/result pairs, reasoning steps, state transitions
+- **Plan Viewer**: DAG visualization with real-time step progress
+- **Tool Registry**: Browse tools, trigger execution from browser
+- **Config Panel**: View/switch providers, models, system prompt
+
+### D.3 Multi-Modal Attachments ✅
+
+Attach images, text files, and audio to messages via CLI and browser.
+
+**Files:** `src/mcp_cli/chat/attachments.py`, `src/mcp_cli/chat/chat_handler.py`, `src/mcp_cli/chat/chat_context.py`, `src/mcp_cli/commands/attach/attach.py`, `src/mcp_cli/main.py`
+
+- `/attach` command with staging, list, clear (aliases: `/file`, `/image`)
+- `--attach` CLI flag (repeatable) for first-message attachments
+- Inline `@file:path` references parsed from message text
+- Image URL auto-detection (HTTP/HTTPS `.png`, `.jpg`, `.gif`, `.webp`)
+- `AttachmentStaging` on `ChatContext` — drain-on-send lifecycle
+- `build_multimodal_content()` assembles content block lists
+- Supported: PNG, JPEG, GIF, WebP, HEIC, MP3, WAV, 25+ text/code extensions
+- 20 MB max per file, 10 attachments per message
+
+### D.4 Dashboard Attachment Visualization ✅
+
+Render attachments in the browser UI.
+
+**Files:** `src/mcp_cli/dashboard/bridge.py`, `src/mcp_cli/dashboard/static/views/agent-terminal.html`, `src/mcp_cli/dashboard/static/views/activity-stream.html`
+
+- Lightweight attachment descriptors over WebSocket (no large base64 payloads)
+- Image thumbnails for files <100KB, metadata badges for larger files
+- Expandable text previews (first 2000 chars)
+- Audio players (HTML5 `<audio>`)
+- Activity stream shows attachment events with paperclip badges
+
+### D.5 Browser File Upload ✅
+
+Attach files directly from the dashboard browser UI.
+
+**Files:** `src/mcp_cli/dashboard/static/views/agent-terminal.html`, `src/mcp_cli/dashboard/static/shell.html`, `src/mcp_cli/dashboard/bridge.py`, `src/mcp_cli/dashboard/server.py`
+
+- "+" attach button in chat input area
+- Hidden file input with supported extension filter
+- Staging strip with removable badges and image thumbnails
+- Drag-and-drop overlay
+- Clipboard paste support (images)
+- `process_browser_file()` constructs `Attachment` from browser base64 data
+- Bridge stages files on `ChatContext.attachment_staging`
+- WebSocket `max_size` increased to 25 MB
+
+---
+
+## Dashboard v2: Intelligence Layer
+
+> **Goal:** Evolve the dashboard from a passive conversation viewer into an active operations console — memory visualization, token economics, tool analytics, session management, and multi-agent oversight.
+
+### Original Spec Compliance
+
+The v0.1.0 Dashboard Shell Specification is nearly fully implemented:
+
+| Spec Section | Status | Notes |
+|-------------|--------|-------|
+| §2 Launch (`--dashboard`, port, browser) | ✅ | Port auto-select from 9120, `--no-browser` flag |
+| §3 Architecture (server, bridge, shell, iframes) | ✅ | Exact architecture as specified |
+| §4 Shell page (CSS Grid, panel chrome, toolbar) | ✅ | Pop-out, minimize, close, drag-swap, resize handles |
+| §5 View protocol (postMessage, INIT, READY, TOOL_RESULT) | ✅ | Full protocol with 5s READY timeout |
+| §6.1 Agent terminal (markdown, streaming, /commands) | ✅ | Plus attachments, search, drag-drop |
+| §6.2 Activity stream (events, filters, virtual scroll) | ✅ | Plus agent badges, plan updates |
+| §7 View discovery (_meta.ui → VIEW_REGISTRY) | ✅ | Dynamic discovery + "+ Add Panel" |
+| §8 Themes (8 themes, CSS variables, THEME message) | ✅ | Full theme sync |
+| §9 Layout presets (Minimal, Standard, Full, custom) | ✅ | Save/load/delete in localStorage + JSON file |
+| §10 Module structure | ✅ | Exact structure as specified |
+| §11 Bridge protocol | ✅ | All message types + extras (sessions, config) |
+| §14 Design principles (dumb shell, no build, sandbox) | ✅ | All 8 principles followed |
+| Panel min-size enforcement during drag | ⚠️ | CSS min 200×200px but no runtime clamp in resize handlers |
+| Dashboard-only mode (`mcp-cli dashboard --config`) | ❌ | Spec §2 "future, Phase 5" — not started |
+
+**Beyond spec:** The implementation added features not in the original spec: multi-modal attachments ("+" button, drag-drop, paste), plan-viewer view, tool-registry/browser view, config-panel view, agent-overview view, multi-agent router, session management (new/switch/delete/rename), and the full multi-agent spec (MULTI_AGENT_SPEC.md).
+
+### D2.1 Memory Panel
+
+Visual representation of the AI Virtual Memory subsystem (mirrors `/memory` command). The CLI already exposes working set stats, page table, per-page content, and full subsystem stats — the panel makes this visual and live.
+
+**New view:** `memory-panel.html`
+
+- **Summary gauges**: Working set utilization bar (tokens used / budget), L0/L1 page counts, page fault and eviction counters
+- **Page table**: Sortable table of all pages — ID, type (text/image/tool), tier (L0–L4), token count, pinned status, age in turns
+- **Page inspector**: Click a page to see content preview, creation turn, access history, eviction score
+- **Live metrics**: Page faults, evictions, TLB hit rate — updating in real time as conversation progresses
+- **Tier distribution**: Visual breakdown of pages across storage tiers (stacked bar or treemap)
+- **Budget pressure indicator**: Warning state when utilization >80%, critical at >95%
+- **Page lifecycle animation**: Visual indication when pages are faulted in, evicted, or migrated between tiers
+
+**Bridge changes:** New `on_memory_event()` hook called from VM subsystem on page fault, eviction, and tier migration. New `MEMORY_STATE` WebSocket message type for full state broadcast on connect. `MEMORY_EVENT` for incremental updates (fault, evict, migrate).
+
+**Shell integration:** New tab in shell.html, only visible when `--vm` flag is active (bridge advertises `vm_enabled` in CONFIG_STATE).
+
+**Data source:** `vm.working_set.get_stats()`, `vm.page_table.get_stats()`, `vm.page_table.entries` — same data the `/memory` command already reads.
+
+### D2.2 Token Usage Dashboard
+
+Live token economics — per-turn and cumulative cost tracking.
+
+**New view:** `token-usage.html`
+
+- **Per-turn bar chart**: Input/output tokens per turn, stacked bars
+- **Cumulative line**: Running total with estimated cost (provider-specific pricing)
+- **Rate limit gauge**: Visual indicator showing proximity to provider rate limits
+- **Model comparison**: When model is switched mid-session, show cost delta at the switch point
+- **Context window utilization**: How much of the model's context window is in use
+- **Export**: Download token usage report as CSV
+
+**Bridge changes:** Extend `CONVERSATION_MESSAGE` payload to include `usage` (input_tokens, output_tokens) when available. New `TOKEN_USAGE_HISTORY` aggregate message on connect for replay.
+
+### D2.3 Tool Execution Timeline
+
+Visual Gantt-style view of tool calls with timing and concurrency.
+
+**New view:** `tool-timeline.html`
+
+- **Gantt chart**: Horizontal bars showing tool call start → end, color-coded by server
+- **Concurrent calls**: Overlapping bars visible when tools run in parallel (plan batch execution)
+- **Drill-down**: Click a bar to see arguments, result preview, error details
+- **Timing stats**: Min/max/avg/p95 execution time per tool
+- **Server health**: Aggregate success rate and latency per server
+
+**Bridge changes:** Add `started_at` timestamp to tool call initiation (new `on_tool_call()` hook alongside existing `on_tool_result()`). Activity history pairs start + end for timeline rendering.
+
+### D2.4 Session Management Panel
+
+Manage conversation sessions entirely from the browser.
+
+**Backend status:** Bridge already handles `REQUEST_SESSIONS`, `LOAD_SESSION`, `SAVE_SESSION`, `DELETE_SESSION`, `RENAME_SESSION`, `NEW_SESSION`, `SWITCH_SESSION` — all wired to ChatContext. What's missing is a dedicated view UI.
+
+**New view or config-panel extension:**
+
+- **Session list**: Browse saved sessions with preview (first message, turn count, date, model used)
+- **Load session**: Click to load — replays conversation and activity history in all views
+- **Save session**: Manual save button with optional name
+- **Delete/rename session**: Manage old sessions
+- **Session comparison**: Side-by-side diff of two session transcripts
+- **Auto-save indicator**: Show when auto-save triggers, link to saved file
+
+### D2.5 Tool Approval UI
+
+Interactive tool approval from the browser when confirmation is required.
+
+**Backend status:** Bridge already has `request_tool_approval()` and `TOOL_APPROVAL_RESPONSE` handler with pending futures. What's missing is the frontend modal.
+
+- **Approval modal**: Shows tool name, arguments (syntax-highlighted JSON), server — approve/deny buttons
+- **Approval queue**: Multiple pending approvals shown as stacked cards with countdown timer
+- **Auto-approve toggle**: Per-tool or global toggle for trusted tools
+- **Audit trail**: Log of approved/denied tool calls with timestamps
+- **CLI fallback**: If no browser clients connected, falls back to CLI confirmation (already implemented)
+
+### D2.6 Inline Tool Execution
+
+Execute tools directly from the tool browser view.
+
+**Backend status:** `REQUEST_TOOL` message type already handled by bridge. Needs frontend form UI.
+
+- **Run button**: Each tool card gets a "Run" button
+- **Argument form**: Auto-generated from JSON schema (text inputs, number spinners, dropdowns for enums, textarea for objects, checkbox for booleans)
+- **Validation**: Client-side validation against schema before sending
+- **Result display**: Inline result rendering below the tool card (syntax-highlighted JSON)
+- **History**: Recent executions per tool with timing and success/failure indicators
+
+### D2.7 Export from Browser
+
+Download conversations and data directly from the dashboard.
+
+- **Markdown export**: Download formatted conversation as `.md` (reuse existing export logic)
+- **JSON export**: Download structured conversation with metadata as `.json`
+- **Activity log export**: Download tool call history as CSV
+- **Screenshot**: Capture current view as PNG (via browser Canvas API)
+
+**Bridge changes:** New `REQUEST_EXPORT` message type. Bridge calls existing export logic (`/export` command internals) and returns file content as download.
+
+### D2.8 Dashboard-Only Mode
+
+Run the dashboard without a CLI terminal — browser-first experience.
+
+```bash
+# Future: standalone dashboard mode
+mcp-cli dashboard --server sqlite --config workspace.yaml
+```
+
+- Dashboard opens as the primary interface (no terminal chat loop)
+- Agent terminal view is the sole conversation input
+- All `/commands` work through the browser input
+- Workspace configs define layout + servers + default views
+- Useful for: demos, shared screens, non-technical users, remote operation
+
+**Requires:** Decoupling the chat loop from terminal stdin — the input queue already supports this (browser messages go through `_input_queue`), but startup assumes terminal mode.
+
+### D2.9 MCP Apps as Dashboard Panels
+
+Embed MCP App UIs (tool `_meta.ui.resourceUri` web apps) as panels within the dashboard, with the ability to maximize into a full browser window.
+
+**Current state:** MCP Apps run on separate `AppHostServer` instances (ports 9470+) using JSON-RPC protocol. Dashboard runs on `DashboardServer` (port 9120+) with mcp-dashboard envelope protocol v2. The two systems are fully independent — apps open in standalone browser tabs.
+
+**Integration approach:** Keep WebSocket servers separate; embed app iframes inside dashboard panels pointing to their existing `localhost:947X` endpoints.
+
+- **Apps panel**: New dashboard view listing all running MCP apps with name, description, status, and "Open" button
+- **Inline embedding**: Clicking "Open" adds the app as a resizable iframe panel in the current layout (same panel system as existing views)
+- **Maximize / pop-out**: Each embedded app panel gets a maximize button (full dashboard area) and a pop-out button (⤢) to open in a standalone browser window — reuses the shell's existing pop-out mechanism
+- **Suppress standalone launch**: When `--dashboard` is active, tools with `_meta.ui.resourceUri` route to an embedded dashboard panel instead of opening a new browser tab
+- **Auto-placement**: New apps triggered by tool execution appear as panels in the current layout automatically, with focus
+- **Tool result routing**: Tool calls that return `_meta.ui.resourceUri` in their result metadata display the app inline in the activity stream with an "Open in panel" action
+- **Lifecycle management**: Apps panel shows running/stopped status; closing a panel doesn't kill the app server (can re-open)
+- **Multi-app support**: Multiple app panels can be open simultaneously in the dashboard layout
+
+**Bridge changes:** New `APP_OPENED` / `APP_CLOSED` / `APP_LIST` message types. Dashboard bridge tracks active `AppHostServer` instances and their ports. Shell.html manages app iframe lifecycle.
+
+**Requires:** D2.8 (Dashboard-Only Mode) benefits from this — apps become first-class dashboard citizens.
+
+### D2.10 Dashboard Polish
+
+Quality-of-life improvements.
+
+- **Runtime panel min-size enforcement**: Clamp resize drag handlers to 200×200px minimum (spec gap — CSS minimums exist but no JS enforcement)
+- **Theme sync**: Dashboard matches CLI `/theme` selection live (THEME message exists, needs CLI→bridge hook)
+- **Keyboard shortcuts**: `Ctrl+1/2/3` for tab switching, `Ctrl+N` to focus chat input, `Ctrl+Shift+F` for global search
+- **Background notifications**: Browser Notification API when agent completes while tab is in background
+- **Mobile-responsive**: Single-column layout for narrow screens (<768px), collapsible sidebar
+- **Message queue during disconnect**: Buffer outbound messages while WebSocket reconnects (reconnection backoff already implemented)
+
+---
+
 ## Tier 7: Observability & Traces
 
 > **Goal:** Turn mcp-cli into a debugger for AI behavior. No other agent CLI has a proper observability layer yet.
@@ -1033,8 +1282,9 @@ mcp remote logs --follow
 | **5** | Production hardening | Observable, auditable | ✅ Complete |
 | **VM** | AI Virtual Memory | OS-style context management | ✅ Complete (Experimental) |
 | **Review** | Code review fixes | Silent exceptions, dead code, test gaps | ✅ Complete |
-| **6** | Plans & execution graphs | Reproducible workflows | ✅ Complete (6.0–6.7) |
-| **6.8** | Model-driven planning | Model creates & executes plans as tools | High |
+| **6** | Plans & execution graphs | Reproducible workflows | ✅ Complete (6.0–6.8) |
+| **Dashboard** | Dashboard & multi-modal | Real-time browser UI, file attachments | ✅ Complete |
+| **Dashboard v2** | Dashboard intelligence | Memory panel, token usage, tool timeline, session mgmt, approvals, MCP Apps panels, dashboard-only mode | High |
 | **7** | Observability & traces | Debugger for AI behavior | High |
 | **8** | Memory scopes | Long-running assistants | High |
 | **9** | Skills & capabilities | Portable behaviour layer | High |
diff --git a/server_config.json b/server_config.json
index b7cec9b9..cc46273a 100644
--- a/server_config.json
+++ b/server_config.json
@@ -72,8 +72,7 @@
       "args": ["--directory", "/Users/christopherhay/chris-source/chuk-ai/mcp-servers/chuk-mcp-stac", "run", "chuk-mcp-stac", "stdio"]
     },
     "dem": {
-      "command": "uv",
-      "args": ["--directory", "/Users/christopherhay/chris-source/chuk-ai/mcp-servers/chuk-mcp-dem", "run", "chuk-mcp-dem", "stdio"]
+      "url": "https://dem.chukai.io/mcp"
     },
     "maritime": {
       "url": "https://maritime-archives.chukai.io/mcp"
diff --git a/src/mcp_cli/agents/__init__.py b/src/mcp_cli/agents/__init__.py
new file mode 100644
index 00000000..6a642147
--- /dev/null
+++ b/src/mcp_cli/agents/__init__.py
@@ -0,0 +1,7 @@
+# mcp_cli/agents — Multi-agent orchestration
+"""Agent orchestration: config, lifecycle management, and supervisor tools."""
+
+from mcp_cli.agents.config import AgentConfig
+from mcp_cli.agents.manager import AgentManager
+
+__all__ = ["AgentConfig", "AgentManager"]
diff --git a/src/mcp_cli/agents/config.py b/src/mcp_cli/agents/config.py
new file mode 100644
index 00000000..3c9c1f80
--- /dev/null
+++ b/src/mcp_cli/agents/config.py
@@ -0,0 +1,27 @@
+# mcp_cli/agents/config.py
+"""Agent configuration for per-agent tool/server restrictions."""
+
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+
+class AgentConfig(BaseModel):
+    """Configuration for a spawned agent.
+
+    Controls identity, model selection, tool access, and parent relationship.
+    """
+
+    agent_id: str
+    name: str = ""
+    role: str = ""
+    model: str | None = None
+    provider: str | None = None
+    system_prompt: str | None = None
+    allowed_tools: list[str] | None = None  # None = all tools
+    denied_tools: list[str] | None = None  # explicit blocklist
+    allowed_servers: list[str] | None = None  # None = all servers
+    tool_timeout_override: float | None = None
+    auto_approve_tools: list[str] | None = None  # skip confirmation
+    parent_agent_id: str | None = None
+    initial_prompt: str = ""
diff --git a/src/mcp_cli/agents/group_store.py b/src/mcp_cli/agents/group_store.py
new file mode 100644
index 00000000..8abcec37
--- /dev/null
+++ b/src/mcp_cli/agents/group_store.py
@@ -0,0 +1,155 @@
+# mcp_cli/agents/group_store.py
+"""Save and restore multi-agent groups.
+
+A *group* is a snapshot of all agents' configurations and their sessions,
+stored on disk so the entire multi-agent setup can be resumed later.
+
+Layout::
+
+    ~/.mcp-cli/groups/{group_id}/
+        group.json                 # AgentDescriptors + relationships
+        {agent_id}/session.json    # Each agent's session state
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import time
+from pathlib import Path
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from mcp_cli.agents.manager import AgentManager
+
+logger = logging.getLogger(__name__)
+
+_DEFAULT_GROUPS_DIR = Path.home() / ".mcp-cli" / "groups"
+
+
+async def save_group(
+    agent_manager: AgentManager,
+    description: str = "",
+    group_dir: Path | None = None,
+) -> Path:
+    """Save all agents' configs and sessions to disk.
+
+    Parameters
+    ----------
+    agent_manager:
+        The AgentManager whose agents to save.
+    description:
+        Human-readable description for the group snapshot.
+    group_dir:
+        Override directory. Default: ``~/.mcp-cli/groups/{group_id}/``
+
+    Returns
+    -------
+    Path
+        The directory where the group was saved.
+    """
+    group_id = f"group-{int(time.time())}"
+    base = group_dir or (_DEFAULT_GROUPS_DIR / group_id)
+    base.mkdir(parents=True, exist_ok=True)
+
+    agents_data: list[dict[str, Any]] = []
+
+    for status in agent_manager.list_agents():
+        agent_id = status["agent_id"]
+        snapshot = agent_manager.get_agent_snapshot(agent_id)
+        if snapshot is None:
+            continue
+
+        # Save agent config
+        config_dict = snapshot["config"].model_dump()
+        agents_data.append(
+            {
+                **config_dict,
+                "status": status.get("status", "unknown"),
+            }
+        )
+
+        # Save session if available
+        ctx = snapshot["context"]
+        agent_dir = base / agent_id
+        agent_dir.mkdir(parents=True, exist_ok=True)
+        try:
+            history = getattr(ctx, "conversation_history", [])
+            session_data = {
+                "agent_id": agent_id,
+                "session_id": getattr(ctx, "session_id", ""),
+                "messages": [
+                    m.to_dict() if hasattr(m, "to_dict") else dict(m) for m in history
+                ],
+            }
+            (agent_dir / "session.json").write_text(
+                json.dumps(session_data, indent=2, default=str)
+            )
+        except Exception as exc:
+            logger.warning("Failed to save session for %s: %s", agent_id, exc)
+
+    # Write group manifest
+    group_manifest = {
+        "group_id": group_id,
+        "created_at": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()),
+        "description": description,
+        "agents": agents_data,
+    }
+    (base / "group.json").write_text(json.dumps(group_manifest, indent=2, default=str))
+
+    logger.info("Group saved to %s (%d agents)", base, len(agents_data))
+    return base
+
+
+def load_group_manifest(group_path: Path) -> dict[str, Any]:
+    """Load a group manifest from disk.
+
+    Parameters
+    ----------
+    group_path:
+        Path to the group directory containing ``group.json``.
+
+    Returns
+    -------
+    dict
+        The parsed group manifest.
+    """
+    manifest_file = group_path / "group.json"
+    if not manifest_file.exists():
+        raise FileNotFoundError(f"No group.json in {group_path}")
+    result: dict[str, Any] = json.loads(manifest_file.read_text())
+    return result
+
+
+def list_groups(groups_dir: Path | None = None) -> list[dict[str, Any]]:
+    """List all saved groups.
+
+    Returns
+    -------
+    list[dict]
+        List of ``{group_id, description, created_at, agent_count, path}``
+    """
+    base = groups_dir or _DEFAULT_GROUPS_DIR
+    if not base.exists():
+        return []
+
+    results = []
+    for d in sorted(base.iterdir()):
+        manifest_file = d / "group.json"
+        if not manifest_file.exists():
+            continue
+        try:
+            manifest = json.loads(manifest_file.read_text())
+            results.append(
+                {
+                    "group_id": manifest.get("group_id", d.name),
+                    "description": manifest.get("description", ""),
+                    "created_at": manifest.get("created_at", ""),
+                    "agent_count": len(manifest.get("agents", [])),
+                    "path": str(d),
+                }
+            )
+        except Exception as exc:
+            logger.debug("Skipping invalid group %s: %s", d, exc)
+
+    return results
diff --git a/src/mcp_cli/agents/headless_ui.py b/src/mcp_cli/agents/headless_ui.py
new file mode 100644
index 00000000..f465e228
--- /dev/null
+++ b/src/mcp_cli/agents/headless_ui.py
@@ -0,0 +1,88 @@
+# mcp_cli/agents/headless_ui.py
+"""Headless UI manager for spawned agents.
+
+Provides the same interface as ChatUIManager but with no terminal output.
+All display operations are logged at DEBUG level instead.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+
+class HeadlessUIManager:
+    """UIManager for headless agents — no terminal output, logs only.
+
+    Implements the subset of ChatUIManager used by ConversationProcessor
+    and ToolProcessor so spawned agents can run without a terminal.
+    """
+
+    def __init__(self, agent_id: str = "default") -> None:
+        self.agent_id = agent_id
+        self.verbose_mode = False
+        self.tool_calls: list[dict[str, Any]] = []
+        self.tool_times: list[float] = []
+        self.tool_start_time: float | None = None
+        self.current_tool_start_time: float | None = None
+        self.streaming_handler: Any = None
+        self.tools_running = False
+        self.display: Any = None  # no display manager
+        self.console: Any = None  # no rich console
+
+    # -- Streaming ----------------------------------------------------------
+
+    @property
+    def is_streaming_response(self) -> bool:
+        return self.streaming_handler is not None
+
+    async def start_streaming_response(self) -> None:
+        logger.debug("[%s] streaming response started", self.agent_id)
+
+    async def stop_streaming_response(self) -> None:
+        logger.debug("[%s] streaming response stopped", self.agent_id)
+        self.streaming_handler = None
+
+    # -- Tool display -------------------------------------------------------
+
+    def print_tool_call(self, tool_name: str, arguments: Any) -> None:
+        logger.debug("[%s] tool call: %s(%s)", self.agent_id, tool_name, arguments)
+
+    async def start_tool_execution(self, tool_name: str, arguments: Any) -> None:
+        logger.debug("[%s] tool start: %s", self.agent_id, tool_name)
+
+    async def finish_tool_execution(
+        self, result: str = "", success: bool = True
+    ) -> None:
+        logger.debug("[%s] tool finish: success=%s", self.agent_id, success)
+
+    async def finish_tool_calls(self) -> None:
+        logger.debug("[%s] all tool calls finished", self.agent_id)
+
+    # -- Confirmation -------------------------------------------------------
+
+    async def do_confirm_tool_execution(
+        self,
+        tool_name: str,
+        arguments: dict[str, Any],
+        server_name: str = "",
+    ) -> bool:
+        """Headless agents auto-approve all tool executions."""
+        return True
+
+    # -- Message display ----------------------------------------------------
+
+    async def print_assistant_message(self, content: str) -> None:
+        logger.debug("[%s] assistant: %.200s", self.agent_id, content)
+
+    # -- Input (not used by headless agents) --------------------------------
+
+    async def get_user_input(self) -> str | None:
+        return None
+
+    # -- Cleanup ------------------------------------------------------------
+
+    async def cleanup(self) -> None:
+        pass
diff --git a/src/mcp_cli/agents/loop.py b/src/mcp_cli/agents/loop.py
new file mode 100644
index 00000000..e4a43823
--- /dev/null
+++ b/src/mcp_cli/agents/loop.py
@@ -0,0 +1,113 @@
+# mcp_cli/agents/loop.py
+"""Headless agent loop for spawned agents.
+
+Runs the ConversationProcessor in a background task, reading prompts from
+an asyncio.Queue instead of stdin.  No terminal I/O, no signal handlers.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+
+async def run_agent_loop(
+    context: Any,
+    ui_manager: Any,
+    input_queue: asyncio.Queue,
+    done_event: asyncio.Event,
+    max_turns: int = 50,
+) -> str:
+    """Run a headless chat loop for a spawned agent.
+
+    Similar to ``_run_enhanced_chat_loop`` in ``chat_handler.py`` but:
+
+    * No terminal I/O — reads prompts from *input_queue*.
+    * Uses ``HeadlessUIManager`` (no rich/curses).
+    * Reports completion via *done_event*.
+    * Returns a summary of the final assistant response.
+
+    Parameters
+    ----------
+    context:
+        ChatContext for this agent.
+    ui_manager:
+        HeadlessUIManager instance.
+    input_queue:
+        ``asyncio.Queue`` that receives user/supervisor prompts.
+    done_event:
+        Set when the loop finishes.
+    max_turns:
+        Maximum conversation turns per prompt.
+
+    Returns
+    -------
+    str
+        Summary of the agent's last response, or error description.
+    """
+    from mcp_cli.chat.conversation import ConversationProcessor
+
+    convo = ConversationProcessor(context, ui_manager)
+    last_response = ""
+
+    # Wire dashboard bridge if present
+    if bridge := getattr(context, "dashboard_bridge", None):
+        bridge.set_input_queue(input_queue)
+
+    try:
+        while not context.exit_requested:
+            try:
+                # Wait for a prompt (with timeout so we can check exit)
+                try:
+                    user_msg = await asyncio.wait_for(input_queue.get(), timeout=1.0)
+                except asyncio.TimeoutError:
+                    continue
+
+                if user_msg is None:
+                    continue
+
+                # Exit signals
+                msg_lower = str(user_msg).lower().strip()
+                if msg_lower in ("exit", "quit", "__stop__"):
+                    break
+
+                # Skip empty
+                if not str(user_msg).strip():
+                    continue
+
+                # Add to conversation and process
+                await context.add_user_message(str(user_msg))
+
+                # Broadcast to dashboard if wired
+                if dash := getattr(context, "dashboard_bridge", None):
+                    try:
+                        await dash.on_message("user", str(user_msg))
+                    except Exception as exc:
+                        logger.debug("Dashboard on_message error: %s", exc)
+
+                await convo.process_conversation(max_turns=max_turns)
+
+                # Capture last assistant response for summary
+                for msg in reversed(context.conversation_history):
+                    if hasattr(msg, "role") and msg.role == "assistant":
+                        last_response = getattr(msg, "content", "") or ""
+                        break
+                    elif isinstance(msg, dict) and msg.get("role") == "assistant":
+                        last_response = msg.get("content", "") or ""
+                        break
+
+            except asyncio.CancelledError:
+                logger.info("Agent loop cancelled: %s", context.agent_id)
+                break
+            except Exception as exc:
+                logger.exception("Error in agent loop: %s", exc)
+                last_response = f"Error: {exc}"
+                break
+
+    finally:
+        done_event.set()
+
+    return last_response[:500] if last_response else "Agent completed."
diff --git a/src/mcp_cli/agents/manager.py b/src/mcp_cli/agents/manager.py
new file mode 100644
index 00000000..6b151012
--- /dev/null
+++ b/src/mcp_cli/agents/manager.py
@@ -0,0 +1,323 @@
+# mcp_cli/agents/manager.py
+"""AgentManager — orchestration hub for multi-agent scenarios.
+
+Manages agent lifecycle (spawn, stop, wait), inter-agent messaging,
+and shared artifacts.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+import time
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, Any
+
+from mcp_cli.agents.config import AgentConfig
+from mcp_cli.chat.agent_tool_state import remove_agent_tool_state
+from mcp_cli.dashboard.router import AgentDescriptor
+
+if TYPE_CHECKING:
+    from mcp_cli.dashboard.router import AgentRouter
+    from mcp_cli.tools.manager import ToolManager
+
+logger = logging.getLogger(__name__)
+
+MAX_AGENTS = 10
+
+
+@dataclass
+class _AgentHandle:
+    """Internal bookkeeping for a spawned agent."""
+
+    agent_id: str
+    config: AgentConfig
+    context: Any  # ChatContext
+    bridge: Any  # DashboardBridge | None
+    task: asyncio.Task
+    input_queue: asyncio.Queue
+    done_event: asyncio.Event
+    result_summary: str = ""
+    created_at: float = field(default_factory=time.time)
+
+
+class AgentManager:
+    """Manages spawning, stopping, and communicating with agents."""
+
+    def __init__(
+        self,
+        tool_manager: ToolManager,
+        router: AgentRouter,
+        model_manager: Any = None,
+    ) -> None:
+        self._tool_manager = tool_manager
+        self._router = router
+        self._model_manager = model_manager
+        self._agents: dict[str, _AgentHandle] = {}
+        self._artifacts: dict[str, dict[str, Any]] = {}  # id → {agent_id, content, ...}
+        self._message_queues: dict[str, asyncio.Queue] = {}
+
+    # ------------------------------------------------------------------ #
+    #  Lifecycle                                                           #
+    # ------------------------------------------------------------------ #
+
+    async def spawn_agent(self, config: AgentConfig) -> str:
+        """Spawn a new agent from *config*. Returns the agent_id."""
+        if len(self._agents) >= MAX_AGENTS:
+            raise RuntimeError(f"Maximum of {MAX_AGENTS} concurrent agents reached.")
+        if config.agent_id in self._agents:
+            raise ValueError(f"Agent {config.agent_id!r} already exists.")
+
+        agent_id = config.agent_id
+        registered = False  # track router registration for rollback
+
+        # Lazy imports to avoid circular deps
+        from mcp_cli.agents.headless_ui import HeadlessUIManager
+        from mcp_cli.agents.loop import run_agent_loop
+        from mcp_cli.chat.chat_context import ChatContext
+        from mcp_cli.dashboard.bridge import DashboardBridge
+
+        try:
+            # Create agent's ChatContext
+            ctx = ChatContext.create(
+                tool_manager=self._tool_manager,
+                provider=config.provider,
+                model=config.model,
+                model_manager=self._model_manager,
+                agent_id=agent_id,
+            )
+            if not await ctx.initialize():
+                raise RuntimeError(f"Failed to initialize context for {agent_id}")
+
+            # Apply system prompt override
+            if config.system_prompt:
+                ctx._system_prompt = config.system_prompt
+                ctx._system_prompt_dirty = True
+
+            # Apply tool filtering
+            if config.allowed_tools is not None:
+                allowed = set(config.allowed_tools)
+                ctx.openai_tools = [
+                    t
+                    for t in ctx.openai_tools
+                    if t.get("function", {}).get("name", "") in allowed
+                ]
+            if config.denied_tools is not None:
+                denied = set(config.denied_tools)
+                ctx.openai_tools = [
+                    t
+                    for t in ctx.openai_tools
+                    if t.get("function", {}).get("name", "") not in denied
+                ]
+
+            # Create bridge and register with router
+            bridge = DashboardBridge(self._router, agent_id=agent_id)
+            bridge.set_context(ctx)
+            ctx.dashboard_bridge = bridge
+
+            descriptor = AgentDescriptor(
+                agent_id=agent_id,
+                name=config.name or agent_id,
+                role=config.role,
+                model=config.model or "",
+                parent_agent_id=config.parent_agent_id,
+                tool_count=len(ctx.openai_tools),
+            )
+            self._router.register_agent(agent_id, bridge, descriptor=descriptor)
+            registered = True
+
+            # Create headless UI and input queue
+            ui = HeadlessUIManager(agent_id=agent_id)
+            input_queue: asyncio.Queue = asyncio.Queue()
+            done_event = asyncio.Event()
+
+            # Message queue for inter-agent messaging
+            self._message_queues[agent_id] = asyncio.Queue()
+
+            # Launch the agent loop
+            task = asyncio.create_task(
+                run_agent_loop(ctx, ui, input_queue, done_event),
+                name=f"agent-loop-{agent_id}",
+            )
+
+            handle = _AgentHandle(
+                agent_id=agent_id,
+                config=config,
+                context=ctx,
+                bridge=bridge,
+                task=task,
+                input_queue=input_queue,
+                done_event=done_event,
+            )
+            self._agents[agent_id] = handle
+
+            # Inject initial prompt
+            if config.initial_prompt:
+                await input_queue.put(config.initial_prompt)
+
+            logger.info("Spawned agent %s (role=%s)", agent_id, config.role)
+            return agent_id
+
+        except BaseException:
+            # Rollback partial state so the system stays consistent
+            if registered:
+                self._router.unregister_agent(agent_id)
+            self._message_queues.pop(agent_id, None)
+            remove_agent_tool_state(agent_id)
+            logger.error("Failed to spawn agent %s — rolled back", agent_id)
+            raise
+
+    async def stop_agent(self, agent_id: str) -> bool:
+        """Stop an agent. Returns True if it existed."""
+        handle = self._agents.pop(agent_id, None)
+        if handle is None:
+            return False
+
+        # Cancel the task
+        handle.task.cancel()
+        try:
+            await asyncio.wait_for(asyncio.shield(handle.task), timeout=5.0)
+        except (asyncio.CancelledError, asyncio.TimeoutError):
+            pass
+
+        # Update status and unregister
+        await self._router.update_agent_status(agent_id, "completed")
+        self._router.unregister_agent(agent_id)
+
+        # Cleanup tool state
+        remove_agent_tool_state(agent_id)
+        self._message_queues.pop(agent_id, None)
+
+        logger.info("Stopped agent %s", agent_id)
+        return True
+
+    async def wait_agent(self, agent_id: str, timeout: float = 300) -> dict[str, Any]:
+        """Wait for an agent to finish. Returns status dict."""
+        handle = self._agents.get(agent_id)
+        if handle is None:
+            return {"error": f"Unknown agent: {agent_id}"}
+
+        try:
+            await asyncio.wait_for(handle.done_event.wait(), timeout=timeout)
+        except asyncio.TimeoutError:
+            return {
+                "agent_id": agent_id,
+                "status": "timeout",
+                "summary": f"Agent did not finish within {timeout}s",
+            }
+
+        # Capture summary
+        try:
+            handle.result_summary = handle.task.result()
+        except (asyncio.CancelledError, Exception) as exc:
+            handle.result_summary = f"Error: {exc}"
+
+        return {
+            "agent_id": agent_id,
+            "status": "completed",
+            "summary": handle.result_summary,
+        }
+
+    # ------------------------------------------------------------------ #
+    #  Messaging                                                           #
+    # ------------------------------------------------------------------ #
+
+    async def send_message(self, from_id: str, to_id: str, content: str) -> bool:
+        """Send a message from one agent to another.
+
+        The message is injected into the target agent's input queue
+        as a system-annotated prompt.
+        """
+        handle = self._agents.get(to_id)
+        if handle is None:
+            return False
+
+        annotated = f"[Message from {from_id}]: {content}"
+        await handle.input_queue.put(annotated)
+        logger.debug("Message from %s → %s: %.100s", from_id, to_id, content)
+        return True
+
+    async def get_messages(self, agent_id: str) -> list[dict[str, Any]]:
+        """Drain pending inter-agent messages for *agent_id*.
+
+        Returns list of ``{from_agent, content}`` dicts.
+        """
+        queue = self._message_queues.get(agent_id)
+        if queue is None:
+            return []
+        messages = []
+        while not queue.empty():
+            try:
+                messages.append(queue.get_nowait())
+            except asyncio.QueueEmpty:
+                break
+        return messages
+
+    # ------------------------------------------------------------------ #
+    #  Artifacts                                                           #
+    # ------------------------------------------------------------------ #
+
+    def publish_artifact(self, agent_id: str, artifact_id: str, content: Any) -> None:
+        """Publish an artifact to the shared store."""
+        self._artifacts[artifact_id] = {
+            "agent_id": agent_id,
+            "content": content,
+            "created_at": time.time(),
+        }
+        logger.debug("Artifact published: %s by %s", artifact_id, agent_id)
+
+    def get_artifact(self, artifact_id: str) -> Any | None:
+        """Retrieve an artifact by ID, or None."""
+        entry = self._artifacts.get(artifact_id)
+        return entry["content"] if entry else None
+
+    def list_artifacts(self) -> list[dict[str, Any]]:
+        """List all published artifacts."""
+        return [
+            {"artifact_id": k, "agent_id": v["agent_id"]}
+            for k, v in self._artifacts.items()
+        ]
+
+    # ------------------------------------------------------------------ #
+    #  Status                                                              #
+    # ------------------------------------------------------------------ #
+
+    def get_agent_status(self, agent_id: str) -> dict[str, Any] | None:
+        """Return status dict for a single agent, or None."""
+        handle = self._agents.get(agent_id)
+        if handle is None:
+            return None
+        return {
+            "agent_id": handle.agent_id,
+            "name": handle.config.name,
+            "role": handle.config.role,
+            "model": handle.config.model,
+            "provider": handle.config.provider,
+            "status": "active" if not handle.done_event.is_set() else "completed",
+            "parent_agent_id": handle.config.parent_agent_id,
+        }
+
+    def list_agents(self) -> list[dict[str, Any]]:
+        """Return status dicts for all managed agents."""
+        return [self.get_agent_status(aid) for aid in self._agents]  # type: ignore[misc]
+
+    def get_agent_snapshot(self, agent_id: str) -> dict[str, Any] | None:
+        """Return config and context for an agent (used by group_store).
+
+        Returns ``{config: AgentConfig, context: ChatContext}`` or None.
+        """
+        handle = self._agents.get(agent_id)
+        if handle is None:
+            return None
+        return {"config": handle.config, "context": handle.context}
+
+    # ------------------------------------------------------------------ #
+    #  Cleanup                                                             #
+    # ------------------------------------------------------------------ #
+
+    async def stop_all(self) -> None:
+        """Stop all managed agents."""
+        agent_ids = list(self._agents.keys())
+        for agent_id in agent_ids:
+            await self.stop_agent(agent_id)
+        logger.info("All agents stopped.")
diff --git a/src/mcp_cli/agents/tools.py b/src/mcp_cli/agents/tools.py
new file mode 100644
index 00000000..b91f15e7
--- /dev/null
+++ b/src/mcp_cli/agents/tools.py
@@ -0,0 +1,287 @@
+# mcp_cli/agents/tools.py
+"""Supervisor tool definitions and handler for agent orchestration.
+
+Provides internal tools that the LLM can call to spawn, stop, and
+communicate with other agents.  These tools are intercepted in
+tool_processor.py before MCP routing (same pattern as plan tools).
+
+Tools:
+- agent_spawn: Spawn a new agent with a role and initial prompt
+- agent_stop: Stop a running agent
+- agent_message: Send a message to another agent
+- agent_wait: Wait for an agent to finish
+- agent_status: Query an agent's current status
+- agent_list: List all managed agents
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from mcp_cli.agents.manager import AgentManager
+
+logger = logging.getLogger(__name__)
+
+_AGENT_TOOL_NAMES = frozenset(
+    {
+        "agent_spawn",
+        "agent_stop",
+        "agent_message",
+        "agent_wait",
+        "agent_status",
+        "agent_list",
+    }
+)
+
+
+def get_agent_tools_as_dicts() -> list[dict[str, Any]]:
+    """Return OpenAI-format tool definitions for agent orchestration."""
+    return [
+        {
+            "type": "function",
+            "function": {
+                "name": "agent_spawn",
+                "description": (
+                    "Spawn a new agent to work on a sub-task in parallel. "
+                    "The agent runs independently and can be monitored or stopped."
+                ),
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "name": {
+                            "type": "string",
+                            "description": "Human-readable name for the agent.",
+                        },
+                        "role": {
+                            "type": "string",
+                            "description": (
+                                "Role description (e.g. 'researcher', 'coder')."
+                            ),
+                        },
+                        "model": {
+                            "type": "string",
+                            "description": "Model to use (optional, defaults to current).",
+                        },
+                        "provider": {
+                            "type": "string",
+                            "description": "Provider to use (optional, defaults to current).",
+                        },
+                        "initial_prompt": {
+                            "type": "string",
+                            "description": "The task/prompt to give the new agent.",
+                        },
+                    },
+                    "required": ["name", "initial_prompt"],
+                },
+            },
+        },
+        {
+            "type": "function",
+            "function": {
+                "name": "agent_stop",
+                "description": "Stop a running agent by its agent_id.",
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "agent_id": {
+                            "type": "string",
+                            "description": "The ID of the agent to stop.",
+                        },
+                    },
+                    "required": ["agent_id"],
+                },
+            },
+        },
+        {
+            "type": "function",
+            "function": {
+                "name": "agent_message",
+                "description": (
+                    "Send a message to another agent. The message is injected "
+                    "into that agent's input as a prompt."
+                ),
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "agent_id": {
+                            "type": "string",
+                            "description": "The target agent's ID.",
+                        },
+                        "content": {
+                            "type": "string",
+                            "description": "Message content to send.",
+                        },
+                    },
+                    "required": ["agent_id", "content"],
+                },
+            },
+        },
+        {
+            "type": "function",
+            "function": {
+                "name": "agent_wait",
+                "description": (
+                    "Wait for an agent to finish its task. Returns the agent's "
+                    "completion summary."
+                ),
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "agent_id": {
+                            "type": "string",
+                            "description": "The agent to wait for.",
+                        },
+                        "timeout": {
+                            "type": "number",
+                            "description": "Max seconds to wait (default: 300).",
+                        },
+                    },
+                    "required": ["agent_id"],
+                },
+            },
+        },
+        {
+            "type": "function",
+            "function": {
+                "name": "agent_status",
+                "description": "Get the current status of a specific agent.",
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "agent_id": {
+                            "type": "string",
+                            "description": "The agent to query.",
+                        },
+                    },
+                    "required": ["agent_id"],
+                },
+            },
+        },
+        {
+            "type": "function",
+            "function": {
+                "name": "agent_list",
+                "description": "List all currently managed agents and their statuses.",
+                "parameters": {
+                    "type": "object",
+                    "properties": {},
+                },
+            },
+        },
+    ]
+
+
+async def handle_agent_tool(
+    tool_name: str,
+    arguments: dict[str, Any],
+    agent_manager: AgentManager,
+    caller_agent_id: str = "default",
+) -> str:
+    """Execute an agent orchestration tool.
+
+    Parameters
+    ----------
+    tool_name:
+        One of the ``_AGENT_TOOL_NAMES``.
+    arguments:
+        Tool arguments from the LLM.
+    agent_manager:
+        The AgentManager instance.
+    caller_agent_id:
+        The agent_id of the caller (for message attribution).
+
+    Returns
+    -------
+    str
+        JSON string with the result.
+    """
+    try:
+        if tool_name == "agent_spawn":
+            return await _handle_spawn(arguments, agent_manager, caller_agent_id)
+        if tool_name == "agent_stop":
+            return await _handle_stop(arguments, agent_manager)
+        if tool_name == "agent_message":
+            return await _handle_message(arguments, agent_manager, caller_agent_id)
+        if tool_name == "agent_wait":
+            return await _handle_wait(arguments, agent_manager)
+        if tool_name == "agent_status":
+            return _handle_status(arguments, agent_manager)
+        if tool_name == "agent_list":
+            return _handle_list(agent_manager)
+        return json.dumps({"error": f"Unknown agent tool: {tool_name}"})
+    except Exception as exc:
+        logger.error("Agent tool %s failed: %s", tool_name, exc)
+        return json.dumps({"error": str(exc)})
+
+
+async def _handle_spawn(
+    arguments: dict[str, Any],
+    manager: AgentManager,
+    caller_id: str,
+) -> str:
+    from mcp_cli.agents.config import AgentConfig
+
+    name = arguments.get("name", "unnamed")
+    # Generate agent_id from name
+    agent_id = f"agent-{name.lower().replace(' ', '-')}"
+
+    config = AgentConfig(
+        agent_id=agent_id,
+        name=name,
+        role=arguments.get("role", ""),
+        model=arguments.get("model"),
+        provider=arguments.get("provider"),
+        parent_agent_id=caller_id,
+        initial_prompt=arguments.get("initial_prompt", ""),
+    )
+
+    result_id = await manager.spawn_agent(config)
+    return json.dumps({"success": True, "agent_id": result_id, "name": name})
+
+
+async def _handle_stop(arguments: dict[str, Any], manager: AgentManager) -> str:
+    agent_id = arguments.get("agent_id", "")
+    if not agent_id:
+        return json.dumps({"error": "agent_id is required"})
+    stopped = await manager.stop_agent(agent_id)
+    return json.dumps({"success": stopped, "agent_id": agent_id})
+
+
+async def _handle_message(
+    arguments: dict[str, Any],
+    manager: AgentManager,
+    caller_id: str,
+) -> str:
+    agent_id = arguments.get("agent_id", "")
+    content = arguments.get("content", "")
+    if not agent_id or not content:
+        return json.dumps({"error": "agent_id and content are required"})
+    sent = await manager.send_message(caller_id, agent_id, content)
+    return json.dumps({"success": sent, "to": agent_id})
+
+
+async def _handle_wait(arguments: dict[str, Any], manager: AgentManager) -> str:
+    agent_id = arguments.get("agent_id", "")
+    if not agent_id:
+        return json.dumps({"error": "agent_id is required"})
+    timeout = float(arguments.get("timeout", 300))
+    result = await manager.wait_agent(agent_id, timeout=timeout)
+    return json.dumps(result, default=str)
+
+
+def _handle_status(arguments: dict[str, Any], manager: AgentManager) -> str:
+    agent_id = arguments.get("agent_id", "")
+    if not agent_id:
+        return json.dumps({"error": "agent_id is required"})
+    status = manager.get_agent_status(agent_id)
+    if status is None:
+        return json.dumps({"error": f"Unknown agent: {agent_id}"})
+    return json.dumps(status, default=str)
+
+
+def _handle_list(manager: AgentManager) -> str:
+    agents = manager.list_agents()
+    return json.dumps({"agents": agents}, default=str)
diff --git a/src/mcp_cli/chat/agent_tool_state.py b/src/mcp_cli/chat/agent_tool_state.py
new file mode 100644
index 00000000..5170de09
--- /dev/null
+++ b/src/mcp_cli/chat/agent_tool_state.py
@@ -0,0 +1,41 @@
+"""Per-agent tool state isolation.
+
+Wraps the global get_tool_state() singleton from chuk_ai_session_manager
+with a per-agent registry.  The ``"default"`` agent_id delegates to the
+global singleton; other agent_ids get independent ToolStateManager instances.
+"""
+
+from __future__ import annotations
+
+import logging
+
+from chuk_ai_session_manager.guards import get_tool_state
+from chuk_ai_session_manager.guards.manager import ToolStateManager
+
+logger = logging.getLogger(__name__)
+
+_registry: dict[str, ToolStateManager] = {}
+
+
+def get_agent_tool_state(agent_id: str = "default") -> ToolStateManager:
+    """Return a ToolStateManager scoped to the given *agent_id*.
+
+    * ``"default"`` → delegates to the upstream global singleton
+    * anything else → per-agent instance (created on first access)
+    """
+    if agent_id == "default":
+        return get_tool_state()
+    if agent_id not in _registry:
+        _registry[agent_id] = ToolStateManager()
+        logger.debug("Created tool state for agent %s", agent_id)
+    return _registry[agent_id]
+
+
+def remove_agent_tool_state(agent_id: str) -> None:
+    """Remove tool state for an agent (call when the agent is stopped)."""
+    _registry.pop(agent_id, None)
+
+
+def _reset_registry() -> None:
+    """Clear the registry — for testing only."""
+    _registry.clear()
diff --git a/src/mcp_cli/chat/attachments.py b/src/mcp_cli/chat/attachments.py
new file mode 100644
index 00000000..eb970ae6
--- /dev/null
+++ b/src/mcp_cli/chat/attachments.py
@@ -0,0 +1,482 @@
+# mcp_cli/chat/attachments.py
+"""Multi-modal attachment processing.
+
+Handles file detection, MIME typing, base64 encoding, content block
+construction, and staging for the ``/attach`` command.  This is a
+**core module** — logging only, no ``chuk_term`` imports.
+"""
+
+from __future__ import annotations
+
+import base64
+import logging
+import re
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+from mcp_cli.config.defaults import (
+    DEFAULT_DASHBOARD_INLINE_IMAGE_THRESHOLD,
+    DEFAULT_DASHBOARD_TEXT_PREVIEW_CHARS,
+    DEFAULT_IMAGE_DETAIL_LEVEL,
+    DEFAULT_MAX_ATTACHMENT_SIZE_BYTES,
+)
+
+logger = logging.getLogger(__name__)
+
+# ------------------------------------------------------------------ #
+#  MIME / extension maps                                               #
+# ------------------------------------------------------------------ #
+
+MIME_MAP: dict[str, str] = {
+    # Images
+    ".png": "image/png",
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".gif": "image/gif",
+    ".webp": "image/webp",
+    ".heic": "image/heic",
+    # Audio
+    ".mp3": "audio/mpeg",
+    ".wav": "audio/wav",
+    # Text / code
+    ".txt": "text/plain",
+    ".md": "text/markdown",
+    ".csv": "text/csv",
+    ".json": "application/json",
+    ".html": "text/html",
+    ".xml": "text/xml",
+    ".yaml": "text/yaml",
+    ".yml": "text/yaml",
+    # Programming languages
+    ".py": "text/plain",
+    ".js": "text/plain",
+    ".ts": "text/plain",
+    ".jsx": "text/plain",
+    ".tsx": "text/plain",
+    ".sh": "text/plain",
+    ".bash": "text/plain",
+    ".rs": "text/plain",
+    ".go": "text/plain",
+    ".java": "text/plain",
+    ".c": "text/plain",
+    ".cpp": "text/plain",
+    ".h": "text/plain",
+    ".hpp": "text/plain",
+    ".rb": "text/plain",
+    ".swift": "text/plain",
+    ".kt": "text/plain",
+    ".sql": "text/plain",
+    ".toml": "text/plain",
+    ".ini": "text/plain",
+    ".cfg": "text/plain",
+    ".env": "text/plain",
+    ".log": "text/plain",
+}
+
+IMAGE_EXTENSIONS = frozenset({".png", ".jpg", ".jpeg", ".gif", ".webp", ".heic"})
+AUDIO_EXTENSIONS = frozenset({".mp3", ".wav"})
+TEXT_EXTENSIONS = frozenset(MIME_MAP.keys()) - IMAGE_EXTENSIONS - AUDIO_EXTENSIONS
+
+# Audio format mapping (extension → OpenAI input_audio format value)
+_AUDIO_FORMAT: dict[str, str] = {".mp3": "mp3", ".wav": "wav"}
+
+
+# ------------------------------------------------------------------ #
+#  Data types                                                          #
+# ------------------------------------------------------------------ #
+
+
+@dataclass
+class Attachment:
+    """A single processed attachment ready for content-block injection."""
+
+    source: str
+    content_blocks: list[dict[str, Any]]
+    display_name: str
+    size_bytes: int
+    mime_type: str
+
+
+class AttachmentStaging:
+    """Staging area for ``/attach`` command.  Lives on ChatContext."""
+
+    def __init__(self) -> None:
+        self._pending: list[Attachment] = []
+
+    def stage(self, attachment: Attachment) -> None:
+        """Add an attachment to the staging area."""
+        self._pending.append(attachment)
+
+    def drain(self) -> list[Attachment]:
+        """Return all pending attachments and clear the staging area."""
+        items = list(self._pending)
+        self._pending.clear()
+        return items
+
+    def peek(self) -> list[Attachment]:
+        """Return pending attachments without clearing."""
+        return list(self._pending)
+
+    def clear(self) -> None:
+        """Clear the staging area."""
+        self._pending.clear()
+
+    @property
+    def count(self) -> int:
+        return len(self._pending)
+
+
+# ------------------------------------------------------------------ #
+#  MIME detection                                                      #
+# ------------------------------------------------------------------ #
+
+
+def detect_mime_type(path: Path) -> str:
+    """Detect MIME type from file extension."""
+    return MIME_MAP.get(path.suffix.lower(), "application/octet-stream")
+
+
+# ------------------------------------------------------------------ #
+#  File processing                                                     #
+# ------------------------------------------------------------------ #
+
+
+def process_local_file(path: str | Path) -> Attachment:
+    """Read a local file and build content blocks.
+
+    Raises
+    ------
+    FileNotFoundError
+        If the file does not exist.
+    ValueError
+        If the file is too large or has an unsupported extension.
+    """
+    p = Path(path).expanduser().resolve()
+    if not p.exists():
+        raise FileNotFoundError(f"File not found: {path}")
+    if not p.is_file():
+        raise ValueError(f"Not a file: {path}")
+
+    size = p.stat().st_size
+    if size > DEFAULT_MAX_ATTACHMENT_SIZE_BYTES:
+        raise ValueError(
+            f"File too large: {size:,} bytes "
+            f"(max {DEFAULT_MAX_ATTACHMENT_SIZE_BYTES:,})"
+        )
+
+    ext = p.suffix.lower()
+    mime = detect_mime_type(p)
+
+    if ext in IMAGE_EXTENSIONS:
+        blocks = _build_image_blocks(p, mime)
+    elif ext in AUDIO_EXTENSIONS:
+        blocks = _build_audio_blocks(p, ext)
+    elif ext in TEXT_EXTENSIONS:
+        blocks = _build_text_blocks(p)
+    else:
+        raise ValueError(
+            f"Unsupported file type: {ext}. "
+            f"Supported: images ({', '.join(sorted(IMAGE_EXTENSIONS))}), "
+            f"audio ({', '.join(sorted(AUDIO_EXTENSIONS))}), "
+            f"text ({', '.join(sorted(TEXT_EXTENSIONS))})"
+        )
+
+    logger.debug("Processed attachment: %s (%s, %d bytes)", p.name, mime, size)
+    return Attachment(
+        source=str(path),
+        content_blocks=blocks,
+        display_name=p.name,
+        size_bytes=size,
+        mime_type=mime,
+    )
+
+
+def _image_blocks_from_b64(b64: str, mime: str) -> list[dict[str, Any]]:
+    """Build image content blocks from base64-encoded data."""
+    return [
+        {
+            "type": "image_url",
+            "image_url": {
+                "url": f"data:{mime};base64,{b64}",
+                "detail": DEFAULT_IMAGE_DETAIL_LEVEL,
+            },
+        }
+    ]
+
+
+def _audio_blocks_from_b64(b64: str, ext: str) -> list[dict[str, Any]]:
+    """Build audio content blocks from base64-encoded data."""
+    fmt = _AUDIO_FORMAT.get(ext, "mp3")
+    return [{"type": "input_audio", "input_audio": {"data": b64, "format": fmt}}]
+
+
+def _text_blocks_from_string(text: str, label: str) -> list[dict[str, Any]]:
+    """Build text content blocks from a string."""
+    return [
+        {
+            "type": "text",
+            "text": f"--- {label} ---\n{text}\n--- end {label} ---",
+        }
+    ]
+
+
+def _build_image_blocks(path: Path, mime: str) -> list[dict[str, Any]]:
+    raw = path.read_bytes()
+    b64 = base64.b64encode(raw).decode("ascii")
+    return _image_blocks_from_b64(b64, mime)
+
+
+def _build_audio_blocks(path: Path, ext: str) -> list[dict[str, Any]]:
+    raw = path.read_bytes()
+    b64 = base64.b64encode(raw).decode("ascii")
+    return _audio_blocks_from_b64(b64, ext)
+
+
+def _build_text_blocks(path: Path) -> list[dict[str, Any]]:
+    try:
+        text = path.read_text(encoding="utf-8")
+    except UnicodeDecodeError:
+        text = path.read_text(encoding="latin-1")
+    return _text_blocks_from_string(text, path.name)
+
+
+# ------------------------------------------------------------------ #
+#  Browser file processing                                             #
+# ------------------------------------------------------------------ #
+
+
+def process_browser_file(
+    filename: str,
+    data_b64: str,
+    mime_type: str,
+) -> Attachment:
+    """Build an ``Attachment`` from browser-uploaded file data.
+
+    Parameters
+    ----------
+    filename:
+        Original filename from the browser ``File`` object.
+    data_b64:
+        Base64-encoded file contents.
+    mime_type:
+        MIME type reported by the browser (e.g. ``image/png``).
+
+    Raises
+    ------
+    ValueError
+        If the file is too large or has an unsupported extension.
+    """
+    raw = base64.b64decode(data_b64)
+    size = len(raw)
+    if size > DEFAULT_MAX_ATTACHMENT_SIZE_BYTES:
+        raise ValueError(
+            f"File too large: {size:,} bytes "
+            f"(max {DEFAULT_MAX_ATTACHMENT_SIZE_BYTES:,})"
+        )
+
+    ext = Path(filename).suffix.lower()
+    # Fall back to provided mime_type if extension not in our map
+    mime = MIME_MAP.get(ext, mime_type)
+
+    if ext in IMAGE_EXTENSIONS:
+        b64 = base64.b64encode(raw).decode("ascii")
+        blocks = _image_blocks_from_b64(b64, mime)
+    elif ext in AUDIO_EXTENSIONS:
+        b64 = base64.b64encode(raw).decode("ascii")
+        blocks = _audio_blocks_from_b64(b64, ext)
+    elif ext in TEXT_EXTENSIONS:
+        try:
+            text = raw.decode("utf-8")
+        except UnicodeDecodeError:
+            text = raw.decode("latin-1")
+        blocks = _text_blocks_from_string(text, filename)
+    else:
+        raise ValueError(
+            f"Unsupported file type: {ext or '(none)'}. "
+            f"Supported: images ({', '.join(sorted(IMAGE_EXTENSIONS))}), "
+            f"audio ({', '.join(sorted(AUDIO_EXTENSIONS))}), "
+            f"text ({', '.join(sorted(TEXT_EXTENSIONS))})"
+        )
+
+    logger.debug(
+        "Processed browser attachment: %s (%s, %d bytes)", filename, mime, size
+    )
+    return Attachment(
+        source=f"browser:{filename}",
+        content_blocks=blocks,
+        display_name=filename,
+        size_bytes=size,
+        mime_type=mime,
+    )
+
+
+# ------------------------------------------------------------------ #
+#  URL processing                                                      #
+# ------------------------------------------------------------------ #
+
+
+def process_url(url: str) -> Attachment:
+    """Build an image_url content block from a URL (no download)."""
+    return Attachment(
+        source=url,
+        content_blocks=[
+            {
+                "type": "image_url",
+                "image_url": {"url": url, "detail": DEFAULT_IMAGE_DETAIL_LEVEL},
+            }
+        ],
+        display_name=url.rsplit("/", 1)[-1][:60],
+        size_bytes=0,
+        mime_type="image/unknown",
+    )
+
+
+# ------------------------------------------------------------------ #
+#  Inline @file:path parsing                                           #
+# ------------------------------------------------------------------ #
+
+_INLINE_REF_RE = re.compile(r"@file:(\S+)")
+
+
+def parse_inline_refs(text: str) -> tuple[str, list[str]]:
+    """Extract ``@file:path`` references from message text.
+
+    Returns
+    -------
+    (cleaned_text, list_of_paths)
+        *cleaned_text* has the ``@file:...`` tokens removed.
+    """
+    paths = _INLINE_REF_RE.findall(text)
+    if not paths:
+        return text, []
+    cleaned = _INLINE_REF_RE.sub("", text).strip()
+    # Collapse multiple spaces left by removal
+    cleaned = re.sub(r"  +", " ", cleaned)
+    return cleaned, paths
+
+
+# ------------------------------------------------------------------ #
+#  Image URL detection                                                 #
+# ------------------------------------------------------------------ #
+
+_IMAGE_URL_RE = re.compile(
+    r"(https?://\S+\.(?:png|jpg|jpeg|gif|webp)(?:\?\S*)?)",
+    re.IGNORECASE,
+)
+
+
+def detect_image_urls(text: str) -> list[str]:
+    """Find image URLs in message text."""
+    return _IMAGE_URL_RE.findall(text)
+
+
+# ------------------------------------------------------------------ #
+#  Multi-modal content builder                                         #
+# ------------------------------------------------------------------ #
+
+
+def build_multimodal_content(
+    user_text: str,
+    attachments: list[Attachment],
+    image_urls: list[str],
+) -> str | list[dict[str, Any]]:
+    """Build the ``content`` field for a user message.
+
+    Returns the plain string when there are no attachments or image URLs
+    (backward compatible).  Otherwise returns a list of content blocks.
+    """
+    if not attachments and not image_urls:
+        return user_text
+
+    blocks: list[dict[str, Any]] = []
+
+    # Text always first
+    if user_text:
+        blocks.append({"type": "text", "text": user_text})
+
+    # Staged / inline attachments
+    for att in attachments:
+        blocks.extend(att.content_blocks)
+
+    # Auto-detected image URLs (deduplicate against attachment URLs)
+    seen_urls: set[str] = set()
+    for att in attachments:
+        for blk in att.content_blocks:
+            if blk.get("type") == "image_url":
+                seen_urls.add(blk.get("image_url", {}).get("url", ""))
+    for url in image_urls:
+        if url not in seen_urls:
+            blocks.append(
+                {
+                    "type": "image_url",
+                    "image_url": {"url": url, "detail": DEFAULT_IMAGE_DETAIL_LEVEL},
+                }
+            )
+
+    return blocks
+
+
+# ------------------------------------------------------------------ #
+#  Dashboard attachment descriptors                                    #
+# ------------------------------------------------------------------ #
+
+
+def _classify_kind(mime_type: str) -> str:
+    """Map MIME type to a UI kind: image, text, audio, or unknown."""
+    if mime_type.startswith("image/"):
+        return "image"
+    if mime_type.startswith("audio/"):
+        return "audio"
+    if mime_type.startswith("text/") or mime_type in ("application/json",):
+        return "text"
+    return "unknown"
+
+
+def attachment_descriptor(
+    att: Attachment,
+    inline_threshold: int = DEFAULT_DASHBOARD_INLINE_IMAGE_THRESHOLD,
+    text_preview_chars: int = DEFAULT_DASHBOARD_TEXT_PREVIEW_CHARS,
+) -> dict[str, Any]:
+    """Build a dashboard-safe descriptor for an Attachment.
+
+    Keeps payloads small by applying thresholds:
+    - Images < *inline_threshold* bytes: include data URI preview
+    - URL images: pass through the URL
+    - Text files: include first *text_preview_chars* chars
+    - Audio < *inline_threshold* bytes: include data URI
+    """
+    desc: dict[str, Any] = {
+        "display_name": att.display_name,
+        "size_bytes": att.size_bytes,
+        "mime_type": att.mime_type,
+        "kind": _classify_kind(att.mime_type),
+    }
+
+    for block in att.content_blocks:
+        btype = block.get("type")
+
+        if btype == "image_url":
+            url = block["image_url"]["url"]
+            if url.startswith("http"):
+                desc["preview_url"] = url
+            elif att.size_bytes <= inline_threshold:
+                desc["preview_url"] = url
+            else:
+                desc["preview_url"] = None
+
+        elif btype == "text":
+            text = block.get("text", "")
+            desc["text_preview"] = text[:text_preview_chars]
+            desc["text_truncated"] = len(text) > text_preview_chars
+
+        elif btype == "input_audio":
+            if att.size_bytes <= inline_threshold:
+                audio_data = block["input_audio"]["data"]
+                audio_fmt = block["input_audio"]["format"]
+                mime = "audio/mpeg" if audio_fmt == "mp3" else f"audio/{audio_fmt}"
+                desc["audio_data_uri"] = f"data:{mime};base64,{audio_data}"
+            else:
+                desc["audio_data_uri"] = None
+
+    return desc
diff --git a/src/mcp_cli/chat/chat_context.py b/src/mcp_cli/chat/chat_context.py
index 78538b10..768c2469 100644
--- a/src/mcp_cli/chat/chat_context.py
+++ b/src/mcp_cli/chat/chat_context.py
@@ -63,6 +63,7 @@ def __init__(
         vm_budget: int = 128_000,
         health_interval: int = 0,
         enable_plan_tools: bool = False,
+        agent_id: str = "default",
     ):
         """
         Create chat context with required managers.
@@ -84,6 +85,7 @@ def __init__(
         self.tool_manager = tool_manager
         self.model_manager = model_manager
         self.session_id = session_id or self._generate_session_id()
+        self.agent_id = agent_id
 
         # Context management
         self._max_history_messages = max_history_messages
@@ -125,7 +127,7 @@ def __init__(
         self.token_tracker = TokenTracker()
 
         # Session persistence
-        self._session_store = SessionStore()
+        self._session_store = SessionStore(agent_id=self.agent_id)
         self._auto_save_counter = 0
 
         # ToolProcessor back-reference (set by ToolProcessor.__init__)
@@ -134,6 +136,14 @@ def __init__(
         # Dashboard bridge (set by chat_handler when --dashboard is active, else None)
         self.dashboard_bridge: Any = None
 
+        # Agent manager (set by chat_handler when multi-agent enabled, else None)
+        self.agent_manager: Any = None
+
+        # Attachment staging for multi-modal input (/attach command)
+        from mcp_cli.chat.attachments import AttachmentStaging
+
+        self.attachment_staging = AttachmentStaging()
+
         # Tool state (filled during initialization)
         self.tools: list[ToolInfo] = []
         self.internal_tools: list[ToolInfo] = []
@@ -169,6 +179,7 @@ def create(
         vm_budget: int = 128_000,
         health_interval: int = 0,
         enable_plan_tools: bool = False,
+        agent_id: str = "default",
     ) -> "ChatContext":
         """
         Factory method for convenient creation.
@@ -223,6 +234,7 @@ def create(
             vm_budget=vm_budget,
             health_interval=health_interval,
             enable_plan_tools=enable_plan_tools,
+            agent_id=agent_id,
         )
 
     # ── Properties ────────────────────────────────────────────────────────
@@ -646,10 +658,28 @@ async def get_server_for_tool(self, tool_name: str) -> str:
         return await self.tool_manager.get_server_for_tool(tool_name) or "Unknown"
 
     # ── Conversation management ───────────────────────────────────────────
-    async def add_user_message(self, content: str) -> None:
-        """Add user message to conversation."""
-        await self.session.user_says(content)
-        logger.debug(f"User message added: {content[:50]}...")
+    async def add_user_message(self, content: str | list[dict[str, Any]]) -> None:
+        """Add user message to conversation.
+
+        Accepts plain text (str) or multi-modal content blocks (list[dict]).
+        Multi-modal content is injected as a raw event since
+        SessionManager.user_says() only accepts strings.
+        """
+        if isinstance(content, str):
+            await self.session.user_says(content)
+            logger.debug(f"User message added: {content[:50]}...")
+        else:
+            # Multi-modal: inject as dict event (same pattern as inject_tool_message)
+            msg = HistoryMessage(role=MessageRole.USER, content=content)
+            event = SessionEvent(
+                message=msg.to_dict(),
+                source=EventSource.USER,
+                type=EventType.TOOL_CALL,
+            )
+            self.session._session.events.append(event)
+            logger.debug(
+                f"Multi-modal user message added: {len(content)} content blocks"
+            )
 
     async def add_assistant_message(self, content: str) -> None:
         """Add assistant message to conversation."""
@@ -838,6 +868,7 @@ def save_session(self) -> str | None:
             data = SessionData(
                 metadata=SessionMetadata(
                     session_id=self.session_id,
+                    agent_id=self.agent_id,
                     provider=self.provider,
                     model=self.model,
                     message_count=len(message_dicts),
@@ -875,27 +906,35 @@ def load_session(self, session_id: str) -> bool:
                     continue  # System prompt is regenerated
                 elif role == MessageRole.USER:
                     event = SessionEvent(
-                        event_type=EventType.USER_MESSAGE,
+                        type=EventType.MESSAGE,
                         source=EventSource.USER,
-                        content=content,
+                        message=content,
                     )
                 elif role == MessageRole.ASSISTANT:
-                    event = SessionEvent(
-                        event_type=EventType.ASSISTANT_MESSAGE,
-                        source=EventSource.ASSISTANT,
-                        content=content,
-                    )
+                    # Assistant messages with tool_calls need full dict
+                    if msg_dict.get("tool_calls"):
+                        event = SessionEvent(
+                            type=EventType.TOOL_CALL,
+                            source=EventSource.SYSTEM,
+                            message=msg_dict,
+                        )
+                    else:
+                        event = SessionEvent(
+                            type=EventType.MESSAGE,
+                            source=EventSource.LLM,
+                            message=content,
+                        )
                 elif role == MessageRole.TOOL:
+                    # Tool result messages stored as full dict for reconstruction
                     event = SessionEvent(
-                        event_type=EventType.TOOL_RESULT,
-                        source=EventSource.TOOL,
-                        content=content,
-                        metadata={"tool_call_id": msg_dict.get("tool_call_id", "")},
+                        type=EventType.TOOL_CALL,
+                        source=EventSource.SYSTEM,
+                        message=msg_dict,
                     )
                 else:
                     continue
 
-                self.session.add_event(event)
+                self.session._session.events.append(event)
 
             logger.info(
                 f"Loaded session {session_id} with {len(data.messages)} messages"
@@ -949,6 +988,7 @@ def to_dict(self) -> dict[str, Any]:
             "tool_to_server_map": self.tool_to_server_map,
             "tool_manager": self.tool_manager,
             "session_id": self.session_id,
+            "agent_id": self.agent_id,
         }
 
     def update_from_dict(self, context_dict: dict[str, Any]) -> None:
diff --git a/src/mcp_cli/chat/chat_handler.py b/src/mcp_cli/chat/chat_handler.py
index 599435c1..e1f7a2ae 100644
--- a/src/mcp_cli/chat/chat_handler.py
+++ b/src/mcp_cli/chat/chat_handler.py
@@ -52,6 +52,9 @@ async def handle_chat_mode(
     dashboard: bool = False,
     no_browser: bool = False,
     dashboard_port: int = 0,
+    agent_id: str = "default",
+    multi_agent: bool = False,
+    initial_attachments: list[str] | None = None,
 ) -> bool:
     """
     Launch the interactive chat loop with streaming support.
@@ -74,12 +77,18 @@ async def handle_chat_mode(
         dashboard: Launch browser dashboard alongside chat (requires websockets).
         no_browser: If True, print dashboard URL but do not open the browser.
         dashboard_port: Preferred dashboard port (0 = auto-select).
+        multi_agent: Enable multi-agent orchestration tools (implies dashboard).
 
     Returns:
         True if session ended normally, False on failure
     """
+    # Multi-agent implies dashboard (needs the router for agent bridges)
+    if multi_agent:
+        dashboard = True
+
     ui: ChatUIManager | None = None
     ctx = None
+    agent_manager = None
 
     try:
         # Initialize configuration manager
@@ -115,12 +124,25 @@ def on_progress(msg: str) -> None:
             vm_budget=vm_budget,
             health_interval=health_interval,
             enable_plan_tools=enable_plan_tools,
+            agent_id=agent_id,
         )
 
         if not await ctx.initialize(on_progress=on_progress):
             output.error("Failed to initialize chat context.")
             return False
 
+        # Stage initial attachments from --attach CLI flag
+        if initial_attachments:
+            from mcp_cli.chat.attachments import process_local_file
+
+            for path in initial_attachments:
+                try:
+                    att = process_local_file(path)
+                    ctx.attachment_staging.stage(att)
+                    logger.info("Staged initial attachment: %s", att.display_name)
+                except (FileNotFoundError, ValueError) as exc:
+                    output.error(f"Cannot attach {path}: {exc}")
+
         # Update global context with initialized data
         await app_context.initialize()
 
@@ -130,11 +152,15 @@ def on_progress(msg: str) -> None:
                 from mcp_cli.dashboard.launcher import launch_dashboard
                 from mcp_cli.dashboard.bridge import DashboardBridge
 
-                _dash_server, _dash_port = await launch_dashboard(
+                _dash_server, _dash_router, _dash_port = await launch_dashboard(
                     dashboard_port, no_browser
                 )
                 output.info(f"Dashboard: http://localhost:{_dash_port}")
-                ctx.dashboard_bridge = DashboardBridge(_dash_server)
+                ctx.dashboard_bridge = DashboardBridge(
+                    _dash_router, agent_id=ctx.agent_id
+                )
+                ctx.dashboard_bridge.set_context(ctx)
+                _dash_router.register_agent(ctx.agent_id, ctx.dashboard_bridge)
 
                 # Wire REQUEST_TOOL from browser → tool_manager, result back to browser
                 _bridge_ref = ctx.dashboard_bridge
@@ -152,6 +178,19 @@ async def _dashboard_execute_tool(
                     )
 
                 ctx.dashboard_bridge.set_tool_call_callback(_dashboard_execute_tool)
+
+                # Multi-agent: create AgentManager and set on context
+                if multi_agent:
+                    from mcp_cli.agents.manager import AgentManager as _AM
+
+                    agent_manager = _AM(
+                        tool_manager=tool_manager,
+                        router=_dash_router,
+                        model_manager=app_context.model_manager,
+                    )
+                    ctx.agent_manager = agent_manager
+                    logger.info("Multi-agent mode enabled (%s)", ctx.agent_id)
+
             except ImportError:
                 output.warning(
                     "Dashboard requires 'websockets'. Install with: pip install mcp-cli[dashboard]"
@@ -220,13 +259,30 @@ async def _dashboard_execute_tool(
         return False
 
     finally:
+        # Auto-save session on exit
+        if ctx is not None and ctx.conversation_history:
+            try:
+                saved = ctx.save_session()
+                if saved:
+                    logger.info("Session auto-saved: %s", saved)
+            except Exception as exc:
+                logger.warning("Failed to auto-save session: %s", exc)
+
         # Cleanup
         if ui:
             await _safe_cleanup(ui)
 
+        # Stop all managed agents before tearing down dashboard
+        if agent_manager is not None:
+            try:
+                await agent_manager.stop_all()
+            except Exception as exc:
+                logger.warning("Error stopping agents: %s", exc)
+
         # Stop dashboard server if running
         if ctx is not None and ctx.dashboard_bridge is not None:
             try:
+                await ctx.dashboard_bridge.on_shutdown()
                 await ctx.dashboard_bridge.server.stop()
             except Exception as exc:
                 logger.warning("Error stopping dashboard server: %s", exc)
@@ -310,10 +366,26 @@ async def handle_chat_mode_for_testing(
 _INTERRUPT = object()
 
 
-async def _terminal_reader(ui: ChatUIManager, queue: asyncio.Queue) -> None:
-    """Background task: reads terminal input and puts it on the shared queue."""
+async def _terminal_reader(
+    ui: ChatUIManager,
+    queue: asyncio.Queue,
+    ready: asyncio.Event | None = None,
+) -> None:
+    """Background task: reads terminal input and puts it on the shared queue.
+
+    When *ready* is provided the reader waits for it before showing the prompt.
+    This prevents the prompt from being overwritten by streaming / tool output.
+    The reader clears the event immediately (one-shot) so it won't re-enter
+    ``get_user_input`` until the main loop explicitly re-sets the event.
+    """
     while True:
         try:
+            # Wait until the main loop signals it's ready for new input.
+            # Clear immediately so we only get ONE prompt per signal.
+            if ready is not None:
+                await ready.wait()
+                ready.clear()
+
             msg = await ui.get_user_input()
             await queue.put(msg)
         except EOFError:
@@ -362,8 +434,15 @@ async def _run_enhanced_chat_loop(
     if bridge := getattr(ctx, "dashboard_bridge", None):
         bridge.set_input_queue(input_queue)
 
+    # Gate the prompt display: the reader waits for this event before showing
+    # the "💬 You:" prompt, preventing streaming / tool output from overwriting it.
+    prompt_ready = asyncio.Event()
+    prompt_ready.set()  # Ready immediately for the first prompt
+
     # Background task: reads terminal input and forwards to the queue.
-    reader_task = asyncio.create_task(_terminal_reader(ui, input_queue))
+    reader_task = asyncio.create_task(
+        _terminal_reader(ui, input_queue, ready=prompt_ready)
+    )
 
     try:
         while True:
@@ -387,10 +466,12 @@ async def _run_enhanced_chat_loop(
                         ui._interrupt_now()
                     else:
                         output.warning("\nInterrupted - type 'exit' to quit.")
+                    prompt_ready.set()
                     continue
 
                 # Skip empty messages
                 if not user_msg:
+                    prompt_ready.set()
                     continue
 
                 # Handle plain exit commands (without slash)
@@ -405,34 +486,89 @@ async def _run_enhanced_chat_loop(
                         if ui.is_streaming_response:
                             ui.interrupt_streaming()
                             output.warning("Streaming response interrupted.")
+                            prompt_ready.set()
                             continue
                         elif ui.tools_running:
                             ui._interrupt_now()
+                            prompt_ready.set()
                             continue
                         else:
                             output.info("Nothing to interrupt.")
+                            prompt_ready.set()
                             continue
 
                     handled = await ui.handle_command(user_msg)
                     if ctx.exit_requested:
                         break
                     if handled:
+                        prompt_ready.set()
                         continue
 
                 # Normal conversation turn with streaming support
                 if ui.verbose_mode:
                     ui.print_user_message(user_msg)
-                await ctx.add_user_message(user_msg)
 
-                # Dashboard: broadcast user message
+                # Multi-modal processing: inline refs, staged attachments, image URLs
+                from mcp_cli.chat.attachments import (
+                    parse_inline_refs,
+                    process_local_file,
+                    detect_image_urls,
+                    build_multimodal_content,
+                )
+
+                cleaned_text, inline_paths = parse_inline_refs(user_msg)
+
+                # Process inline @file: references
+                inline_atts = []
+                for p in inline_paths:
+                    try:
+                        inline_atts.append(process_local_file(p))
+                    except (FileNotFoundError, ValueError) as exc:
+                        output.error(f"Cannot attach {p}: {exc}")
+
+                # Drain staged attachments from /attach command
+                staged = ctx.attachment_staging.drain()
+
+                # Detect image URLs in message text
+                image_urls = detect_image_urls(cleaned_text)
+
+                # Build content (str when text-only, list[dict] when multi-modal)
+                content = build_multimodal_content(
+                    cleaned_text, staged + inline_atts, image_urls
+                )
+
+                await ctx.add_user_message(content)
+
+                # Dashboard: broadcast user message with attachment metadata
                 if _dash := getattr(ctx, "dashboard_bridge", None):
                     try:
-                        await _dash.on_message("user", user_msg)
+                        att_descriptors = None
+                        all_atts = staged + inline_atts
+                        if all_atts or image_urls:
+                            from mcp_cli.chat.attachments import (
+                                attachment_descriptor,
+                                process_url as _process_url,
+                            )
+
+                            att_descriptors = [
+                                attachment_descriptor(a) for a in all_atts
+                            ]
+                            for _url in image_urls:
+                                att_descriptors.append(
+                                    attachment_descriptor(_process_url(_url))
+                                )
+                        await _dash.on_message(
+                            "user", user_msg, attachments=att_descriptors
+                        )
                     except Exception as _e:
                         logger.debug("Dashboard on_message(user) error: %s", _e)
 
-                # Use the enhanced conversation processor that handles streaming
-                await convo.process_conversation(max_turns=max_turns)
+                # Process the conversation. The reader already cleared
+                # prompt_ready so no new prompt is shown during streaming.
+                try:
+                    await convo.process_conversation(max_turns=max_turns)
+                finally:
+                    prompt_ready.set()
 
             except (KeyboardInterrupt, asyncio.CancelledError):
                 # Handle Ctrl+C gracefully
@@ -451,6 +587,7 @@ async def _run_enhanced_chat_loop(
                     output.warning("\nInterrupted - type 'exit' to quit.")
                 # CRITICAL: Continue the loop instead of exiting
                 logger.info("Continuing chat loop after interrupt...")
+                prompt_ready.set()
                 continue
             except EOFError:
                 output.panel("EOF detected - exiting chat.", style="red", title="Exit")
@@ -458,6 +595,7 @@ async def _run_enhanced_chat_loop(
             except Exception as exc:
                 logger.exception("Error processing message")
                 output.error(f"Error processing message: {exc}")
+                prompt_ready.set()
                 continue
     finally:
         reader_task.cancel()
diff --git a/src/mcp_cli/chat/conversation.py b/src/mcp_cli/chat/conversation.py
index f9dc82c4..062bfb2c 100644
--- a/src/mcp_cli/chat/conversation.py
+++ b/src/mcp_cli/chat/conversation.py
@@ -24,7 +24,7 @@
 from mcp_cli.chat.tool_processor import ToolProcessor
 from mcp_cli.chat.token_tracker import TokenTracker, TurnUsage
 from mcp_cli.config.defaults import DEFAULT_MAX_CONSECUTIVE_DUPLICATES
-from chuk_ai_session_manager.guards import get_tool_state
+from mcp_cli.chat.agent_tool_state import get_agent_tool_state
 
 logger = logging.getLogger(__name__)
 
@@ -68,7 +68,7 @@ def __init__(
         # Store runtime_config for passing to streaming handler
         self.runtime_config = runtime_config
         # Tool state manager for caching and variable binding
-        self._tool_state = get_tool_state()
+        self._tool_state = get_agent_tool_state(getattr(context, "agent_id", "default"))
         # Counter for consecutive duplicate detections (for escalation)
         self._consecutive_duplicate_count = 0
         self._max_consecutive_duplicates = DEFAULT_MAX_CONSECUTIVE_DUPLICATES
@@ -201,6 +201,8 @@ async def process_conversation(self, max_turns: int = 100):
                     )
                     if last_msg:
                         content = last_msg.content or ""
+                        if isinstance(content, list):
+                            content = ""
                         if last_msg.role == MessageRole.USER and content.startswith(
                             "/"
                         ):
@@ -891,6 +893,29 @@ async def _inject_internal_tools(self):
             except Exception as exc:
                 logger.warning(f"Could not load plan tools: {exc}")
 
+        # Inject agent orchestration tools when agent_manager is set
+        if (
+            getattr(self.context, "agent_manager", None) is not None
+            and "agent_spawn" not in existing
+        ):
+            try:
+                from mcp_cli.agents.tools import get_agent_tools_as_dicts
+
+                agent_tools = get_agent_tools_as_dicts()
+                new_agent = [
+                    t
+                    for t in agent_tools
+                    if t.get("function", {}).get("name", "") not in existing
+                ]
+                if new_agent:
+                    self.context.openai_tools.extend(new_agent)
+                    existing.update(
+                        t.get("function", {}).get("name", "") for t in new_agent
+                    )
+                    logger.info(f"Injected {len(new_agent)} agent tools")
+            except Exception as exc:
+                logger.warning(f"Could not load agent tools: {exc}")
+
         # Inject persistent memory scope tools
         store = getattr(self.context, "memory_store", None)
         if store and "memory_store_page" not in existing:
@@ -1058,7 +1083,18 @@ def _register_user_literals_from_history(self) -> int:
         # Scan recent messages for user content
         for msg in reversed(self.context.conversation_history):
             if msg.role == MessageRole.USER and msg.content:
-                count = self._tool_state.register_user_literals(msg.content)
+                # Extract text from multimodal content blocks
+                if isinstance(msg.content, list):
+                    text = " ".join(
+                        b.get("text", "")
+                        for b in msg.content
+                        if isinstance(b, dict) and b.get("type") == "text"
+                    )
+                else:
+                    text = msg.content
+                if not text:
+                    break
+                count = self._tool_state.register_user_literals(text)
                 total_registered += count
                 logger.debug(f"Registered {count} user literals from message")
                 # Only process the most recent user message
diff --git a/src/mcp_cli/chat/models.py b/src/mcp_cli/chat/models.py
index 5494ee71..c33aefe1 100644
--- a/src/mcp_cli/chat/models.py
+++ b/src/mcp_cli/chat/models.py
@@ -350,7 +350,7 @@ def print_tool_call(self, tool_name: str, arguments: dict[str, Any]) -> None:
         """Print tool call info to console."""
         ...
 
-    def do_confirm_tool_execution(
+    async def do_confirm_tool_execution(
         self,
         tool_name: str,
         arguments: dict[str, Any],
@@ -358,6 +358,7 @@ def do_confirm_tool_execution(
         """Ask user to confirm tool execution.
 
         Returns True if user confirms, False otherwise.
+        May route to dashboard if browser clients are connected.
         """
         ...
 
diff --git a/src/mcp_cli/chat/session_store.py b/src/mcp_cli/chat/session_store.py
index e2987a6c..23e2abac 100644
--- a/src/mcp_cli/chat/session_store.py
+++ b/src/mcp_cli/chat/session_store.py
@@ -13,7 +13,7 @@
 
 from pydantic import BaseModel, Field
 
-from mcp_cli.config.defaults import DEFAULT_SESSIONS_DIR
+from mcp_cli.config.defaults import DEFAULT_AGENT_ID, DEFAULT_SESSIONS_DIR
 
 logger = logging.getLogger(__name__)
 
@@ -22,6 +22,7 @@ class SessionMetadata(BaseModel):
     """Metadata for a saved session."""
 
     session_id: str
+    agent_id: str = DEFAULT_AGENT_ID
     created_at: str = Field(
         default_factory=lambda: datetime.now(timezone.utc).isoformat()
     )
@@ -48,11 +49,19 @@ class SessionStore:
     Stores sessions as JSON files in a configurable directory.
     """
 
-    def __init__(self, sessions_dir: Path | None = None):
+    def __init__(
+        self,
+        sessions_dir: Path | None = None,
+        agent_id: str = DEFAULT_AGENT_ID,
+    ):
         if sessions_dir is None:
             sessions_dir = Path(DEFAULT_SESSIONS_DIR).expanduser()
-        self.sessions_dir = sessions_dir
+        self.agent_id = agent_id
+        # Agent-namespaced subdirectory
+        self.sessions_dir = sessions_dir / agent_id
         self.sessions_dir.mkdir(parents=True, exist_ok=True)
+        # Keep reference to root for backward-compat migration
+        self._root_dir = sessions_dir
 
     def _session_path(self, session_id: str) -> Path:
         """Get the file path for a session."""
@@ -80,6 +89,9 @@ def save(self, data: SessionData) -> Path:
     def load(self, session_id: str) -> SessionData | None:
         """Load session data from disk.
 
+        If the file isn't found in the agent-namespaced directory, checks the
+        flat root directory for backward compatibility and auto-migrates.
+
         Args:
             session_id: Session ID to load
 
@@ -88,8 +100,12 @@ def load(self, session_id: str) -> SessionData | None:
         """
         path = self._session_path(session_id)
         if not path.exists():
-            logger.warning(f"Session not found: {session_id}")
-            return None
+            # Backward-compat: check flat root directory and migrate
+            migrated = self._migrate_from_root(session_id)
+            if migrated is None:
+                logger.warning(f"Session not found: {session_id}")
+                return None
+            path = migrated
 
         try:
             raw = path.read_text(encoding="utf-8")
@@ -99,6 +115,26 @@ def load(self, session_id: str) -> SessionData | None:
             logger.error(f"Failed to load session {session_id}: {e}")
             return None
 
+    def _migrate_from_root(self, session_id: str) -> Path | None:
+        """Check flat root dir for a legacy session file and migrate it.
+
+        Returns the new path if migration succeeded, None otherwise.
+        """
+        safe_id = session_id.replace("/", "_").replace("\\", "_").replace("..", "_")
+        legacy_path = self._root_dir / f"{safe_id}.json"
+        if not legacy_path.exists() or not legacy_path.is_file():
+            return None
+        dest = self._session_path(session_id)
+        try:
+            import shutil
+
+            shutil.move(str(legacy_path), str(dest))
+            logger.info(f"Migrated session {session_id} from flat dir to {dest}")
+            return dest
+        except Exception as e:
+            logger.warning(f"Failed to migrate session {session_id}: {e}")
+            return None
+
     def list_sessions(self) -> list[SessionMetadata]:
         """List all saved sessions.
 
diff --git a/src/mcp_cli/chat/streaming_handler.py b/src/mcp_cli/chat/streaming_handler.py
index aa746531..2bef143b 100644
--- a/src/mcp_cli/chat/streaming_handler.py
+++ b/src/mcp_cli/chat/streaming_handler.py
@@ -438,22 +438,19 @@ async def stream_chunks():
                         f"(first_chunk={not first_chunk_received}, "
                         f"after_tools={after_tool_calls})"
                     )
-                    # Display user-friendly error message
-                    from chuk_term.ui import output
-
                     if not first_chunk_received and after_tool_calls:
-                        output.error(
-                            f"\n⏱️  Streaming timeout after {effective_timeout:.0f}s waiting for first response after tool calls.\n"
-                            "The model may need more time to process tool results.\n"
-                            f"You can increase this with: MCP_STREAMING_FIRST_CHUNK_TIMEOUT={effective_timeout * 2:.0f}\n"
-                            f"Or set in config: timeouts.streamingFirstChunk = {effective_timeout * 2:.0f}"
+                        logger.warning(
+                            "Streaming timeout after %.0fs waiting for first response after tool calls. "
+                            "Increase with MCP_STREAMING_FIRST_CHUNK_TIMEOUT=%.0f",
+                            effective_timeout,
+                            effective_timeout * 2,
                         )
                     else:
-                        output.error(
-                            f"\n⏱️  Streaming timeout after {effective_timeout:.0f}s waiting for response.\n"
-                            "The model may be taking longer than expected to respond.\n"
-                            f"You can increase this timeout with: --tool-timeout {effective_timeout * 2:.0f}\n"
-                            f"Or set in config file: timeouts.streamingChunkTimeout = {effective_timeout * 2:.0f}"
+                        logger.warning(
+                            "Streaming timeout after %.0fs waiting for response. "
+                            "Increase with --tool-timeout %.0f",
+                            effective_timeout,
+                            effective_timeout * 2,
                         )
                     break
 
@@ -461,15 +458,12 @@ async def stream_chunks():
         try:
             await asyncio.wait_for(stream_chunks(), timeout=global_timeout)
         except asyncio.TimeoutError:
-            logger.error(f"Global streaming timeout after {global_timeout}s")
-            # Display user-friendly error message
-            from chuk_term.ui import output
-
-            output.error(
-                f"\n⏱️  Global streaming timeout after {global_timeout:.0f}s.\n"
-                f"The total streaming time exceeded the maximum allowed.\n"
-                f"You can increase this timeout with: --tool-timeout {global_timeout * 2:.0f}\n"
-                f"Or set MCP_STREAMING_GLOBAL_TIMEOUT={global_timeout * 2:.0f}"
+            logger.error(
+                "Global streaming timeout after %.0fs. "
+                "Increase with --tool-timeout %.0f or MCP_STREAMING_GLOBAL_TIMEOUT=%.0f",
+                global_timeout,
+                global_timeout * 2,
+                global_timeout * 2,
             )
             self._interrupted = True
 
@@ -519,16 +513,13 @@ async def _handle_non_streaming(
         **kwargs,
     ) -> dict[str, Any]:
         """Fallback for non-streaming clients."""
-        from chuk_term.ui import output
-
         start_time = time.time()
 
-        with output.loading("Generating response..."):
-            # Try to call client
-            if hasattr(client, "complete"):
-                result = await client.complete(messages=messages, tools=tools, **kwargs)
-            else:
-                raise RuntimeError("Client has no streaming or completion method")
+        logger.debug("Non-streaming fallback: generating response...")
+        if hasattr(client, "complete"):
+            result = await client.complete(messages=messages, tools=tools, **kwargs)
+        else:
+            raise RuntimeError("Client has no streaming or completion method")
 
         elapsed = time.time() - start_time
 
diff --git a/src/mcp_cli/chat/tool_processor.py b/src/mcp_cli/chat/tool_processor.py
index 732ed4a9..6a10492e 100644
--- a/src/mcp_cli/chat/tool_processor.py
+++ b/src/mcp_cli/chat/tool_processor.py
@@ -30,9 +30,11 @@
     DEFAULT_MAX_CONSECUTIVE_TRANSPORT_FAILURES,
     TRANSPORT_ERROR_PATTERNS,
 )
-from chuk_ai_session_manager.guards import get_tool_state, SoftBlockReason
+from chuk_ai_session_manager.guards import SoftBlockReason
+from mcp_cli.chat.agent_tool_state import get_agent_tool_state
 from chuk_tool_processor.discovery import get_search_engine
 from mcp_cli.llm.content_models import ContentBlockType
+from mcp_cli.agents.tools import _AGENT_TOOL_NAMES
 from mcp_cli.memory.tools import _MEMORY_TOOL_NAMES
 from mcp_cli.planning.tools import _PLAN_TOOL_NAMES
 from mcp_cli.utils.preferences import get_preference_manager
@@ -45,6 +47,7 @@
 # VM tools handled locally via MemoryManager, not routed to MCP ToolManager
 _VM_TOOL_NAMES = frozenset({"page_fault", "search_pages"})
 
+# _AGENT_TOOL_NAMES imported from mcp_cli.agents.tools (single source of truth)
 # _MEMORY_TOOL_NAMES imported from mcp_cli.memory.tools (single source of truth)
 # _PLAN_TOOL_NAMES imported from mcp_cli.planning.tools (single source of truth)
 
@@ -175,7 +178,7 @@ async def process_tool_calls(
                 # Handle user confirmation
                 server_url = self._get_server_url_for_tool(execution_tool_name)
                 if self._should_confirm_tool(execution_tool_name, server_url):
-                    confirmed = self.ui_manager.do_confirm_tool_execution(
+                    confirmed = await self.ui_manager.do_confirm_tool_execution(
                         tool_name=display_name, arguments=raw_arguments
                     )
                     if not confirmed:
@@ -189,30 +192,46 @@ async def process_tool_calls(
                 # Parse arguments
                 arguments = self._parse_arguments(raw_arguments)
 
+                # Resolve actual tool name for call_tool proxy
+                actual_tool = execution_tool_name
+                if execution_tool_name == DYNAMIC_TOOL_PROXY_NAME:
+                    proxy_name = arguments.get("tool_name")
+                    if proxy_name and isinstance(proxy_name, str):
+                        actual_tool = proxy_name
+
                 # ── VM tool interception ────────────────────────────────
                 # page_fault and search_pages are internal VM operations,
                 # handled by MemoryManager — not routed to MCP ToolManager.
-                if execution_tool_name in _VM_TOOL_NAMES:
+                if actual_tool in _VM_TOOL_NAMES:
                     await self._handle_vm_tool(
-                        execution_tool_name, arguments, llm_tool_name, call_id
+                        actual_tool, arguments, llm_tool_name, call_id
                     )
                     continue
 
                 # ── Memory scope tool interception ─────────────────────
                 # remember, recall, forget are persistent memory ops,
                 # handled locally — not routed to MCP ToolManager.
-                if execution_tool_name in _MEMORY_TOOL_NAMES:
+                if actual_tool in _MEMORY_TOOL_NAMES:
                     await self._handle_memory_tool(
-                        execution_tool_name, arguments, llm_tool_name, call_id
+                        actual_tool, arguments, llm_tool_name, call_id
                     )
                     continue
 
                 # ── Plan tool interception ─────────────────────────────
                 # plan_create, plan_execute, plan_create_and_execute are
                 # internal planning ops — not routed to MCP ToolManager.
-                if execution_tool_name in _PLAN_TOOL_NAMES:
+                if actual_tool in _PLAN_TOOL_NAMES:
                     await self._handle_plan_tool(
-                        execution_tool_name, arguments, llm_tool_name, call_id
+                        actual_tool, arguments, llm_tool_name, call_id
+                    )
+                    continue
+
+                # ── Agent tool interception ────────────────────────────
+                # agent_spawn, agent_stop, etc. are orchestration tools
+                # handled by AgentManager — not routed to MCP ToolManager.
+                if actual_tool in _AGENT_TOOL_NAMES:
+                    await self._handle_agent_tool(
+                        actual_tool, arguments, llm_tool_name, call_id
                     )
                     continue
 
@@ -248,7 +267,9 @@ async def process_tool_calls(
                     continue
 
                 # Check $vN references in arguments (dataflow validation)
-                tool_state = get_tool_state()
+                tool_state = get_agent_tool_state(
+                    getattr(self.context, "agent_id", "default")
+                )
                 ref_check = tool_state.check_references(arguments)
                 if not ref_check.valid:
                     logger.warning(
@@ -460,7 +481,7 @@ async def _on_tool_result(self, result: CTPToolResult) -> None:
             f"Tool result ({actual_tool_name}): success={success}, error='{result.error}'"
         )
 
-        tool_state = get_tool_state()
+        tool_state = get_agent_tool_state(getattr(self.context, "agent_id", "default"))
         value_binding = None
 
         # Cache successful results and create value bindings
@@ -581,6 +602,7 @@ async def _on_tool_result(self, result: CTPToolResult) -> None:
                     duration_ms=duration_ms,
                     meta_ui=meta_ui,
                     call_id=result.id,
+                    arguments=actual_arguments,
                 )
             except Exception as _bridge_exc:
                 logger.debug("Dashboard bridge on_tool_result error: %s", _bridge_exc)
@@ -733,6 +755,20 @@ async def _handle_plan_tool(
         # Get model_manager for LLM-driven step execution
         model_manager = getattr(self.context, "model_manager", None)
 
+        # Broadcast plan start to dashboard
+        bridge = getattr(self.context, "dashboard_bridge", None)
+        plan_title = arguments.get("goal", "Plan")
+        if bridge is not None:
+            try:
+                await bridge.on_plan_update(
+                    plan_id=call_id,
+                    title=plan_title,
+                    steps=[],
+                    status="running",
+                )
+            except Exception as _e:
+                logger.debug("Dashboard plan start update error: %s", _e)
+
         # Pass the UI manager so handle_plan_tool can show step-by-step progress
         result_text = await handle_plan_tool(
             tool_name,
@@ -742,6 +778,66 @@ async def _handle_plan_tool(
             ui_manager=self.ui_manager,
         )
 
+        # Re-fetch bridge in case it changed during plan execution
+        bridge = getattr(self.context, "dashboard_bridge", None)
+        if bridge is not None:
+            try:
+                import json as _json
+
+                plan_result = (
+                    _json.loads(result_text) if isinstance(result_text, str) else {}
+                )
+                steps = plan_result.get("steps", [])
+                await bridge.on_plan_update(
+                    plan_id=plan_result.get("plan_id", call_id),
+                    title=plan_result.get("title", plan_title),
+                    steps=[
+                        {
+                            "index": s.get("index", i),
+                            "title": s.get("title", ""),
+                            "tool": s.get("tool", ""),
+                            "status": "complete" if s.get("success") else "failed",
+                            "error": s.get("error"),
+                        }
+                        for i, s in enumerate(steps)
+                    ],
+                    status="complete" if plan_result.get("success") else "failed",
+                    error=plan_result.get("error"),
+                )
+            except Exception as _e:
+                logger.debug("Dashboard plan update error: %s", _e)
+
+        self._add_tool_result_to_history(llm_tool_name, call_id, result_text)
+
+    async def _handle_agent_tool(
+        self,
+        tool_name: str,
+        arguments: dict,
+        llm_tool_name: str,
+        call_id: str,
+    ) -> None:
+        """Execute an agent orchestration tool (agent_spawn, agent_stop, etc.).
+
+        Agent tools are internal operations that bypass the MCP ToolManager
+        and all guard checks.  They delegate to the AgentManager stored on
+        the ChatContext.
+        """
+        agent_manager = getattr(self.context, "agent_manager", None)
+        if agent_manager is None:
+            self._add_tool_result_to_history(
+                llm_tool_name, call_id, "Agent tools are not enabled."
+            )
+            return
+
+        logger.info("Agent tool %s called with args: %s", tool_name, arguments)
+
+        from mcp_cli.agents.tools import handle_agent_tool
+
+        caller_id = getattr(self.context, "agent_id", "default")
+        result_text = await handle_agent_tool(
+            tool_name, arguments, agent_manager, caller_agent_id=caller_id
+        )
+
         self._add_tool_result_to_history(llm_tool_name, call_id, result_text)
 
     async def _handle_vm_tool(
diff --git a/src/mcp_cli/chat/ui_manager.py b/src/mcp_cli/chat/ui_manager.py
index cb92e749..8b6615c1 100644
--- a/src/mcp_cli/chat/ui_manager.py
+++ b/src/mcp_cli/chat/ui_manager.py
@@ -230,9 +230,12 @@ def print_tool_call(self, tool_name: str, raw_arguments: Any) -> None:
         # The display manager shows tool name + arguments during execution
         pass
 
-    def do_confirm_tool_execution(self, tool_name: str, arguments: Any) -> bool:
+    async def do_confirm_tool_execution(self, tool_name: str, arguments: Any) -> bool:
         """Prompt user to confirm tool execution.
 
+        Routes to dashboard if browser clients are connected,
+        otherwise falls back to terminal prompt.
+
         Args:
             tool_name: Name of the tool
             arguments: Tool arguments
@@ -240,8 +243,6 @@ def do_confirm_tool_execution(self, tool_name: str, arguments: Any) -> bool:
         Returns:
             True if user confirms, False otherwise
         """
-        from chuk_term.ui import output
-
         # Parse arguments for display
         if isinstance(arguments, str):
             try:
@@ -251,13 +252,35 @@ def do_confirm_tool_execution(self, tool_name: str, arguments: Any) -> bool:
         else:
             args = arguments or {}
 
-        # Show tool and arguments
-        output.warning(f"⚠️  Tool confirmation required: {tool_name}")
+        # Route to dashboard if clients are connected
+        bridge = getattr(self.context, "dashboard_bridge", None)
+        if bridge is not None and bridge.has_clients:
+            try:
+                call_id = f"confirm-{id(arguments)}-{time.time_ns()}"
+                fut = await bridge.request_tool_approval(
+                    tool_name=tool_name,
+                    arguments=args,
+                    call_id=call_id,
+                )
+                # Wait for dashboard user to approve/deny (with timeout)
+                return await asyncio.wait_for(fut, timeout=300)
+            except asyncio.TimeoutError:
+                logger.warning("Tool approval timed out for %s", tool_name)
+                return False
+            except Exception as exc:
+                logger.warning("Dashboard tool approval error: %s", exc)
+                # Fall through to terminal prompt
+
+        # Terminal fallback
+        output.warning(f"Tool confirmation required: {tool_name}")
         args_str = json.dumps(args, indent=2) if isinstance(args, dict) else str(args)
         output.print(f"Parameters:\n{args_str}")
 
-        # Prompt for confirmation
-        response = input("\nExecute this tool? [Y/n]: ").strip().lower()
+        # Use asyncio-friendly prompt
+        loop = asyncio.get_running_loop()
+        response = await loop.run_in_executor(
+            None, lambda: input("\nExecute this tool? [Y/n]: ").strip().lower()
+        )
         return response in ("", "y", "yes")
 
     async def finish_tool_execution(
diff --git a/src/mcp_cli/commands/__init__.py b/src/mcp_cli/commands/__init__.py
index 4992a150..58049d23 100644
--- a/src/mcp_cli/commands/__init__.py
+++ b/src/mcp_cli/commands/__init__.py
@@ -105,10 +105,11 @@ def register_all_commands() -> None:
     from mcp_cli.commands.conversation import ConversationCommand
     from mcp_cli.commands.usage import UsageCommand
     from mcp_cli.commands.export import ExportCommand
-    from mcp_cli.commands.sessions import SessionsCommand
+    from mcp_cli.commands.sessions import SessionsCommand, NewSessionCommand
     from mcp_cli.commands.apps import AppsCommand
     from mcp_cli.commands.memory import MemoryCommand
     from mcp_cli.commands.plan import PlanCommand
+    from mcp_cli.commands.attach import AttachCommand
 
     # Register basic commands
     registry.register(HelpCommand())
@@ -146,6 +147,7 @@ def register_all_commands() -> None:
     registry.register(UsageCommand())
     registry.register(ExportCommand())
     registry.register(SessionsCommand())
+    registry.register(NewSessionCommand())
 
     # Register tool execution command for interactive mode
     registry.register(ExecuteToolCommand())
@@ -159,6 +161,9 @@ def register_all_commands() -> None:
     # Register plan command
     registry.register(PlanCommand())
 
+    # Register attach command (multi-modal file staging)
+    registry.register(AttachCommand())
+
     # All commands have been migrated!
     # - tools (with subcommands: list, call, confirm)
     # - provider (with subcommands: list, set, show)
diff --git a/src/mcp_cli/commands/attach/__init__.py b/src/mcp_cli/commands/attach/__init__.py
new file mode 100644
index 00000000..b671fbd8
--- /dev/null
+++ b/src/mcp_cli/commands/attach/__init__.py
@@ -0,0 +1,7 @@
+"""File attachment commands."""
+
+from mcp_cli.commands.attach.attach import AttachCommand
+
+__all__ = [
+    "AttachCommand",
+]
diff --git a/src/mcp_cli/commands/attach/attach.py b/src/mcp_cli/commands/attach/attach.py
new file mode 100644
index 00000000..79c12974
--- /dev/null
+++ b/src/mcp_cli/commands/attach/attach.py
@@ -0,0 +1,152 @@
+# mcp_cli/commands/attach/attach.py
+"""Slash command for staging file attachments.
+
+Usage:
+    /attach <path> [path2 ...]  — stage files for next message
+    /attach list                — show staged files
+    /attach clear               — clear staging area
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from chuk_term.ui import output
+
+from mcp_cli.commands.base import (
+    CommandMode,
+    CommandParameter,
+    CommandResult,
+    UnifiedCommand,
+)
+
+
+class AttachCommand(UnifiedCommand):
+    """Stage files for the next chat message."""
+
+    @property
+    def name(self) -> str:
+        return "attach"
+
+    @property
+    def aliases(self) -> list[str]:
+        return ["file", "image"]
+
+    @property
+    def description(self) -> str:
+        return "Attach files (images, text, audio) to the next message"
+
+    @property
+    def help_text(self) -> str:
+        return (
+            "/attach <path> [path2 ...]  — stage files for next message\n"
+            "/attach list               — show staged files\n"
+            "/attach clear              — clear staging area\n"
+            "\n"
+            "Aliases: /file, /image\n"
+            "\n"
+            "Supported types:\n"
+            "  Images: .png .jpg .jpeg .gif .webp\n"
+            "  Audio:  .mp3 .wav\n"
+            "  Text:   .py .js .ts .txt .md .csv .json .html .xml .yaml .yml\n"
+            "          .sh .bash .rs .go .java .c .cpp .h .hpp .rb .swift\n"
+            "          .kt .sql .toml .ini .cfg .env .log .jsx .tsx\n"
+        )
+
+    @property
+    def modes(self) -> CommandMode:
+        return CommandMode.CHAT
+
+    @property
+    def parameters(self) -> list[CommandParameter]:
+        return [
+            CommandParameter(
+                name="args",
+                type=str,
+                required=False,
+                help="File path(s) or subcommand (list, clear)",
+            ),
+        ]
+
+    async def execute(self, **kwargs: Any) -> CommandResult:
+        """Execute the /attach command."""
+        chat_context = kwargs.get("chat_context")
+        if not chat_context:
+            return CommandResult(
+                success=False,
+                error="Attach command requires chat context.",
+            )
+
+        # Parse arguments
+        args_val = kwargs.get("args", "")
+        if isinstance(args_val, list):
+            args_str = " ".join(str(a) for a in args_val)
+        else:
+            args_str = str(args_val).strip() if args_val else ""
+
+        if not args_str:
+            return self._show_usage()
+
+        parts = args_str.split()
+        action = parts[0].lower()
+
+        # Subcommands
+        if action == "list":
+            return self._list_staged(chat_context)
+        if action == "clear":
+            return self._clear_staged(chat_context)
+
+        # Treat all parts as file paths to stage
+        return self._stage_files(chat_context, parts)
+
+    # ── Subcommand handlers ──────────────────────────────────────────────
+
+    def _show_usage(self) -> CommandResult:
+        output.info("Usage: /attach <path> [path2 ...] | list | clear")
+        return CommandResult(success=True)
+
+    def _list_staged(self, ctx: Any) -> CommandResult:
+        staged = ctx.attachment_staging.peek()
+        if not staged:
+            output.info("No attachments staged.")
+            return CommandResult(success=True, output="No attachments staged.")
+
+        lines = []
+        for att in staged:
+            size_kb = att.size_bytes / 1024
+            lines.append(f"  {att.display_name}  ({att.mime_type}, {size_kb:.1f} KB)")
+        summary = f"{len(staged)} staged attachment(s):\n" + "\n".join(lines)
+        output.info(summary)
+        return CommandResult(success=True, output=summary)
+
+    def _clear_staged(self, ctx: Any) -> CommandResult:
+        count = ctx.attachment_staging.count
+        ctx.attachment_staging.clear()
+        msg = f"Cleared {count} attachment(s)." if count else "Nothing to clear."
+        output.info(msg)
+        return CommandResult(success=True, output=msg)
+
+    def _stage_files(self, ctx: Any, paths: list[str]) -> CommandResult:
+        from mcp_cli.chat.attachments import process_local_file
+
+        staged_names: list[str] = []
+        errors: list[str] = []
+
+        for path in paths:
+            try:
+                att = process_local_file(path)
+                ctx.attachment_staging.stage(att)
+                staged_names.append(att.display_name)
+                output.success(f"Staged: {att.display_name} ({att.mime_type})")
+            except (FileNotFoundError, ValueError) as exc:
+                errors.append(f"{path}: {exc}")
+                output.error(f"Cannot attach {path}: {exc}")
+
+        if errors and not staged_names:
+            return CommandResult(success=False, error="; ".join(errors))
+
+        total = ctx.attachment_staging.count
+        msg = f"Staged {len(staged_names)} file(s). Total pending: {total}"
+        if errors:
+            msg += f" ({len(errors)} failed)"
+        return CommandResult(success=True, output=msg)
diff --git a/src/mcp_cli/commands/sessions/__init__.py b/src/mcp_cli/commands/sessions/__init__.py
index cdf27d76..a87eca1e 100644
--- a/src/mcp_cli/commands/sessions/__init__.py
+++ b/src/mcp_cli/commands/sessions/__init__.py
@@ -1,5 +1,6 @@
-"""Sessions command."""
+"""Sessions commands."""
 
 from mcp_cli.commands.sessions.sessions import SessionsCommand
+from mcp_cli.commands.sessions.new import NewSessionCommand
 
-__all__ = ["SessionsCommand"]
+__all__ = ["SessionsCommand", "NewSessionCommand"]
diff --git a/src/mcp_cli/commands/sessions/new.py b/src/mcp_cli/commands/sessions/new.py
new file mode 100644
index 00000000..6dc254f0
--- /dev/null
+++ b/src/mcp_cli/commands/sessions/new.py
@@ -0,0 +1,112 @@
+# src/mcp_cli/commands/sessions/new.py
+"""New session command — start a fresh conversation."""
+
+from __future__ import annotations
+
+from mcp_cli.commands.base import (
+    UnifiedCommand,
+    CommandMode,
+    CommandParameter,
+    CommandResult,
+)
+from chuk_term.ui import output
+
+
+class NewSessionCommand(UnifiedCommand):
+    """Start a new chat session."""
+
+    @property
+    def name(self) -> str:
+        return "new"
+
+    @property
+    def aliases(self) -> list[str]:
+        return []
+
+    @property
+    def description(self) -> str:
+        return "Start a new chat session (saves current session first)"
+
+    @property
+    def help_text(self) -> str:
+        return """
+Start a new chat session.
+
+Usage:
+  /new              - Save current session and start fresh
+  /new <name>       - Save current session and start fresh with a description
+"""
+
+    @property
+    def modes(self) -> CommandMode:
+        return CommandMode.CHAT
+
+    @property
+    def parameters(self) -> list[CommandParameter]:
+        return [
+            CommandParameter(
+                name="description",
+                type=str,
+                required=False,
+                help="Optional description for the new session",
+            ),
+        ]
+
+    async def execute(self, **kwargs) -> CommandResult:
+        """Execute the new session command."""
+        chat_context = kwargs.get("chat_context")
+        if not chat_context:
+            return CommandResult(success=False, error="No chat context available.")
+
+        args = kwargs.get("args", "").strip()
+        description = args if args else ""
+
+        # Save current session first (if there's history)
+        if hasattr(chat_context, "save_session") and chat_context.conversation_history:
+            try:
+                path = chat_context.save_session()
+                if path:
+                    output.info(f"Previous session saved: {path}")
+            except Exception as e:
+                output.warning(f"Could not save previous session: {e}")
+
+        # Clear history and start fresh
+        await chat_context.clear_conversation_history(keep_system_prompt=True)
+
+        # Broadcast to dashboard if connected
+        bridge = getattr(chat_context, "dashboard_bridge", None)
+        if bridge is not None:
+            try:
+                from mcp_cli.dashboard.bridge import _envelope
+
+                _aid = bridge.agent_id
+                await bridge.broadcast(
+                    _envelope(
+                        "CONVERSATION_HISTORY",
+                        {"agent_id": _aid, "messages": []},
+                    )
+                )
+                config = bridge._build_config_state()
+                if config:
+                    await bridge.broadcast(_envelope("CONFIG_STATE", config))
+                await bridge.broadcast(
+                    _envelope(
+                        "SESSION_STATE",
+                        {
+                            "agent_id": _aid,
+                            "session_id": chat_context.session_id,
+                            "description": description,
+                        },
+                    )
+                )
+            except Exception:
+                pass
+
+        output.success(
+            f"New session started: {chat_context.session_id}"
+            + (f" ({description})" if description else "")
+        )
+        return CommandResult(
+            success=True,
+            output=f"New session: {chat_context.session_id}",
+        )
diff --git a/src/mcp_cli/commands/sessions/sessions.py b/src/mcp_cli/commands/sessions/sessions.py
index a1fbcc1d..0b25e708 100644
--- a/src/mcp_cli/commands/sessions/sessions.py
+++ b/src/mcp_cli/commands/sessions/sessions.py
@@ -73,7 +73,11 @@ async def execute(self, **kwargs) -> CommandResult:
         action = args[0] if args else SessionAction.LIST
         session_id = args[1] if len(args) > 1 else None
 
-        store = SessionStore()
+        store = SessionStore(
+            agent_id=getattr(chat_context, "agent_id", "default")
+            if chat_context
+            else "default"
+        )
 
         if action == SessionAction.LIST:
             sessions = store.list_sessions()
diff --git a/src/mcp_cli/config/cli_options.py b/src/mcp_cli/config/cli_options.py
index 35eda307..dfbdc31b 100644
--- a/src/mcp_cli/config/cli_options.py
+++ b/src/mcp_cli/config/cli_options.py
@@ -150,26 +150,25 @@ def process_options(
 
     pref_manager = get_preference_manager()
 
-    # Lazy import: chuk_term.ui is a UI dependency, only needed for user-facing warnings
-    from chuk_term.ui import output
-
     # Filter out disabled servers
     if user_specified:
         # If user explicitly requested servers, check if they're disabled
         enabled_from_requested = []
         for server in user_specified:
             if pref_manager.is_server_disabled(server):
-                output.warning(f"Server '{server}' is disabled and cannot be used")
-                output.hint(
-                    f"To enable it, use: mcp-cli chat then /servers {server} enable"
+                logger.warning(
+                    "Server '%s' is disabled. To enable: mcp-cli chat then /servers %s enable",
+                    server,
+                    server,
                 )
             else:
                 enabled_from_requested.append(server)
         servers_list = enabled_from_requested
 
         if not servers_list and user_specified:
-            output.warning("All requested servers are disabled")
-            output.hint("Use 'mcp-cli servers' to see server status")
+            logger.warning(
+                "All requested servers are disabled. Use 'mcp-cli servers' to see status."
+            )
     else:
         # No specific servers requested - filter out disabled ones from preferences
         enabled_servers = []
diff --git a/src/mcp_cli/config/defaults.py b/src/mcp_cli/config/defaults.py
index 0c8ca659..a6ed2e08 100644
--- a/src/mcp_cli/config/defaults.py
+++ b/src/mcp_cli/config/defaults.py
@@ -329,6 +329,14 @@
 """Seconds before showing 'initialization timed out' in host page."""
 
 
+# ================================================================
+# Agent Identity Defaults
+# ================================================================
+
+DEFAULT_AGENT_ID = "default"
+"""Default agent identifier for multi-agent support."""
+
+
 # ================================================================
 # Dashboard Defaults
 # ================================================================
@@ -404,3 +412,23 @@
 
 DEFAULT_LOG_BACKUP_COUNT = 3
 """Number of rotated log files to keep."""
+
+
+# ================================================================
+# Attachment Defaults
+# ================================================================
+
+DEFAULT_MAX_ATTACHMENT_SIZE_BYTES = 20_971_520
+"""Maximum attachment file size (20 MB). Base64 encoding adds ~33%."""
+
+DEFAULT_MAX_ATTACHMENTS_PER_MESSAGE = 10
+"""Maximum attachments per user message (staged + inline combined)."""
+
+DEFAULT_IMAGE_DETAIL_LEVEL = "auto"
+"""Default detail level for image_url content blocks (auto, low, high)."""
+
+DEFAULT_DASHBOARD_INLINE_IMAGE_THRESHOLD = 102_400
+"""Max base64 size (bytes) for inline image previews in dashboard (100 KB)."""
+
+DEFAULT_DASHBOARD_TEXT_PREVIEW_CHARS = 2000
+"""Max chars of text file content to send as preview in dashboard."""
diff --git a/src/mcp_cli/dashboard/MULTI_AGENT_SPEC.md b/src/mcp_cli/dashboard/MULTI_AGENT_SPEC.md
new file mode 100644
index 00000000..7955d8bb
--- /dev/null
+++ b/src/mcp_cli/dashboard/MULTI_AGENT_SPEC.md
@@ -0,0 +1,722 @@
+# Multi-Agent, Multi-Session Dashboard Spec
+
+**Status**: Design draft
+**Author**: auto-generated from architecture review
+**Date**: 2026-02-28
+
+---
+
+## 1. Goals
+
+Support a dashboard that can:
+
+1. Display **multiple agents running in parallel**, each with its own conversation, tool calls, and state.
+2. Allow the user to **switch between sessions** for any agent — viewing historical conversations alongside the live one.
+3. Present a **unified activity stream** that aggregates tool calls, state changes, and plans across all agents.
+4. Route **browser input** (messages, commands, tool approvals) to the correct agent.
+5. Remain **backward-compatible** — a single-agent setup works exactly as today with zero configuration.
+
+---
+
+## 2. Concepts
+
+### 2.1 Agent
+
+An **agent** is an autonomous LLM-driven entity with:
+
+- An **agent_id** (e.g. `"agent-main"`, `"agent-research"`, `"agent-coder"`)
+- Its own **ChatContext** (model, provider, system prompt, tools, conversation history)
+- Its own **ConversationProcessor** and **ToolProcessor**
+- Its own **input queue** for receiving browser / terminal input
+- A **role** or **description** (free text, displayed in the UI)
+- An optional **parent agent_id** (for supervisor → delegate relationships)
+
+An agent may be:
+
+| Lifecycle       | Description |
+|-----------------|-------------|
+| **active**      | Running its chat loop, can receive input |
+| **paused**      | Exists but chat loop is suspended (awaiting user or another agent) |
+| **completed**   | Finished its task, read-only history |
+| **failed**      | Errored out, read-only history |
+
+### 2.2 Session
+
+A **session** is a persisted conversation for an agent:
+
+- Each agent has a **current session** (live) and zero or more **saved sessions** (on disk).
+- Session files are namespaced: `~/.mcp-cli/sessions/{agent_id}/{session_id}.json`
+- `SessionMetadata` gains an `agent_id` field.
+- The session list endpoint can filter by agent.
+
+### 2.3 Agent Group
+
+An **agent group** is the top-level orchestration unit:
+
+- Contains one or more agents.
+- Has a **supervisor agent** (optional) that can spawn/stop other agents.
+- Has a shared **plan** (optional) that coordinates agent work.
+- Single-agent mode is just a group of one with no supervisor.
+
+---
+
+## 3. Data Model Changes
+
+### 3.1 SessionMetadata (session_store.py)
+
+```python
+class SessionMetadata(BaseModel):
+    session_id: str
+    agent_id: str = "default"        # NEW
+    agent_name: str = ""             # NEW — human-readable label
+    created_at: str
+    updated_at: str
+    provider: str
+    model: str
+    message_count: int = 0
+    description: str = ""
+    parent_session_id: str | None = None  # NEW — if spawned from another session
+    tags: list[str] = []             # NEW — user-defined tags for organisation
+```
+
+### 3.2 ChatContext additions
+
+```python
+class ChatContext:
+    agent_id: str = "default"        # NEW — propagated to bridge, sessions
+    agent_name: str = ""             # NEW — human label
+    agent_role: str = ""             # NEW — e.g. "researcher", "coder"
+    parent_agent_id: str | None      # NEW — supervisor link
+```
+
+### 3.3 AgentDescriptor (new)
+
+```python
+@dataclass
+class AgentDescriptor:
+    """Lightweight descriptor for an agent visible to the dashboard."""
+    agent_id: str
+    name: str
+    role: str
+    status: Literal["active", "paused", "completed", "failed"]
+    model: str
+    provider: str
+    session_id: str
+    parent_agent_id: str | None = None
+    tool_count: int = 0
+    message_count: int = 0
+    created_at: str = ""
+```
+
+---
+
+## 4. Bridge Architecture
+
+### 4.1 Current: 1 Bridge → 1 Server → 1 ChatContext
+
+```
+Terminal ─── input_queue ──► ChatContext ◄── DashboardBridge ──► DashboardServer ──► Browser
+```
+
+### 4.2 Future: AgentRouter → N Bridges → 1 Server
+
+```
+                                  ┌── DashboardBridge(agent-A) ◄──► ChatContext(A)
+Terminal ──► AgentRouter ─────────┤
+                │                 ├── DashboardBridge(agent-B) ◄──► ChatContext(B)
+                │                 │
+                │                 └── DashboardBridge(agent-C) ◄──► ChatContext(C)
+                │
+                └──► DashboardServer ──► Browser(s)
+```
+
+**Key principle**: One `DashboardServer` (one WebSocket endpoint, one HTTP port), but messages are **tagged with `agent_id`** and **routed** by an `AgentRouter`.
+
+### 4.3 AgentRouter (new module: `dashboard/router.py`)
+
+```python
+class AgentRouter:
+    """Routes messages between browser clients and multiple agent bridges."""
+
+    def __init__(self, server: DashboardServer) -> None:
+        self.server = server
+        self._bridges: dict[str, DashboardBridge] = {}
+        self._agent_descriptors: dict[str, AgentDescriptor] = {}
+
+        # Which agent each browser client is "focused" on
+        self._client_focus: dict[ServerConnection, str] = {}  # ws → agent_id
+
+        # Wire server callbacks
+        server.on_browser_message = self._on_browser_message
+        server.on_client_connected = self._on_client_connected
+        server.on_client_disconnected = self._on_client_disconnected
+
+    # ── Agent lifecycle ──────────────────────────────────────────
+    def register_agent(self, agent_id: str, bridge: DashboardBridge, descriptor: AgentDescriptor) -> None: ...
+    def unregister_agent(self, agent_id: str) -> None: ...
+    def update_agent_status(self, agent_id: str, status: str) -> None: ...
+
+    # ── Outbound (agent → browser) ──────────────────────────────
+    async def broadcast_from_agent(self, agent_id: str, message: dict) -> None:
+        """Inject agent_id into the envelope and broadcast."""
+        message["payload"]["agent_id"] = agent_id
+        await self.server.broadcast(message)
+
+    async def broadcast_global(self, message: dict) -> None:
+        """Broadcast a message not scoped to any agent (e.g. AGENT_LIST)."""
+        await self.server.broadcast(message)
+
+    # ── Inbound (browser → agent) ───────────────────────────────
+    async def _on_browser_message(self, msg: dict, ws: ServerConnection) -> None:
+        """Route browser message to the correct agent bridge."""
+        agent_id = msg.get("agent_id") or self._client_focus.get(ws) or "default"
+        bridge = self._bridges.get(agent_id)
+        if bridge:
+            await bridge._on_browser_message(msg)
+
+    # ── Focus management ─────────────────────────────────────────
+    async def _handle_focus_agent(self, msg: dict, ws: ServerConnection) -> None:
+        """Browser client changed which agent it's viewing."""
+        agent_id = msg.get("agent_id", "default")
+        self._client_focus[ws] = agent_id
+        # Send full state replay for the focused agent
+        bridge = self._bridges.get(agent_id)
+        if bridge:
+            await bridge._on_client_connected(ws)
+```
+
+### 4.4 DashboardBridge changes
+
+The existing `DashboardBridge` stays mostly the same but:
+
+1. **Receives its `agent_id`** in the constructor.
+2. **Does NOT own the server** — the `AgentRouter` owns it.
+3. Uses `router.broadcast_from_agent(self.agent_id, msg)` instead of `self.server.broadcast(msg)`.
+4. `_on_client_connected` becomes a method that the router calls when a client focuses this agent.
+5. Inbound messages already arrive pre-routed by the router.
+
+```python
+class DashboardBridge:
+    def __init__(self, agent_id: str, router: AgentRouter) -> None:
+        self.agent_id = agent_id
+        self.router = router
+        # ... rest same as today
+
+    async def _broadcast(self, envelope: dict) -> None:
+        """Broadcast via router (injects agent_id)."""
+        await self.router.broadcast_from_agent(self.agent_id, envelope)
+```
+
+**Backward compat**: When `AgentRouter` has only one bridge and it's `"default"`, behavior is identical to today.
+
+### 4.5 DashboardServer changes
+
+The server needs to pass the `ws` (client connection) to the message callback so the router can identify which client sent the message:
+
+```python
+# Current:
+on_browser_message: Callable[[dict], Awaitable] | None
+
+# New:
+on_browser_message: Callable[[dict, ServerConnection], Awaitable] | None
+```
+
+The server also gains:
+
+```python
+async def send_to_client(self, ws: ServerConnection, message: str) -> None:
+    """Send to a specific client (not broadcast)."""
+
+@property
+def clients(self) -> set[ServerConnection]:
+    """Expose client set for router focus tracking."""
+```
+
+---
+
+## 5. Message Protocol Changes
+
+### 5.1 Universal `agent_id` on all payloads
+
+Every outbound envelope gains `agent_id` in the payload:
+
+```json
+{
+  "protocol": "mcp-dashboard",
+  "version": 2,
+  "type": "TOOL_RESULT",
+  "payload": {
+    "agent_id": "agent-research",
+    "tool_name": "web_search",
+    ...
+  }
+}
+```
+
+**Version bump**: Protocol version goes from 1 → 2. Views check version and handle both.
+
+### 5.2 New message types
+
+| Type | Direction | Payload | Description |
+|------|-----------|---------|-------------|
+| `AGENT_LIST` | server → browser | `{ agents: AgentDescriptor[] }` | Full list of registered agents |
+| `AGENT_REGISTERED` | server → browser | `AgentDescriptor` | A new agent joined |
+| `AGENT_UNREGISTERED` | server → browser | `{ agent_id }` | An agent left |
+| `AGENT_STATUS` | server → browser | `{ agent_id, status, ... }` | Agent status update (active/paused/completed/failed) |
+| `FOCUS_AGENT` | browser → server | `{ agent_id }` | Client wants to focus a different agent |
+| `REQUEST_AGENT_LIST` | browser → server | `{}` | Client requests current agent list |
+
+### 5.3 Inbound messages gain `agent_id`
+
+All browser → server messages can optionally include `agent_id`:
+
+```json
+{ "type": "USER_MESSAGE", "agent_id": "agent-coder", "content": "Fix the bug" }
+```
+
+If omitted, the router uses the client's current focus agent.
+
+### 5.4 Session messages gain `agent_id` scoping
+
+| Type | Change |
+|------|--------|
+| `REQUEST_SESSIONS` | Response filtered by `agent_id` of focused agent |
+| `SESSION_LIST` | Includes `agent_id` per session entry |
+| `SWITCH_SESSION` | Can specify `agent_id` to switch a different agent's session |
+
+---
+
+## 6. Shell (UI) Changes
+
+### 6.1 Agent Selector
+
+The shell header gains an **agent tab bar**:
+
+```
+┌─────────────────────────────────────────────────────┐
+│ [Main ●] [Research ◐] [Coder ○]     ⚙ Settings     │
+├─────────────────────────────────────────────────────┤
+│                                                     │
+│  ┌─────────────────┐  ┌─────────────────────────┐  │
+│  │ Agent Terminal   │  │ Activity Stream          │  │
+│  │ (focused agent)  │  │ (all agents or filtered) │  │
+│  └─────────────────┘  └─────────────────────────┘  │
+│                                                     │
+└─────────────────────────────────────────────────────┘
+```
+
+- Each tab shows: agent name, status indicator (●=active, ◐=paused, ○=completed, ✗=failed)
+- Clicking a tab sends `FOCUS_AGENT` → router replays that agent's state
+- The currently focused agent receives keyboard/browser input
+
+### 6.2 Agent-scoped views
+
+When the focus changes:
+
+1. Shell sends `FOCUS_AGENT` to the server.
+2. Router responds with `CONVERSATION_HISTORY`, `ACTIVITY_HISTORY`, `CONFIG_STATE`, `TOOL_REGISTRY` for the focused agent.
+3. Views that are agent-scoped (agent-terminal, plan-viewer) update.
+4. Views that are global (activity-stream in "all agents" mode) continue showing everything.
+
+### 6.3 Activity stream modes
+
+The activity stream gains a filter dropdown:
+
+| Mode | Behavior |
+|------|----------|
+| **All Agents** | Shows events from every agent, color-coded by agent |
+| **Focused Agent** | Only shows events from the currently focused agent |
+| **Agent X** | Pin to a specific agent regardless of focus |
+
+Each event card gains an agent badge:
+
+```
+┌─ agent-research ──────────────────────────┐
+│ 🔧 web_search                    342ms    │
+│ ✓ 3 results                  14:23:01     │
+└───────────────────────────────────────────┘
+```
+
+### 6.4 Message routing changes in shell.html
+
+```javascript
+// Current: direct routing
+case 'TOOL_RESULT':
+  routeToViews('TOOL_RESULT', msg.payload);
+  break;
+
+// Future: agent-aware routing
+case 'TOOL_RESULT':
+  const agentId = msg.payload.agent_id;
+  // Always send to activity stream (it filters internally)
+  sendToActivityStream('TOOL_RESULT', msg.payload);
+  // Only send to agent-terminal if this is the focused agent
+  if (agentId === focusedAgentId) {
+    routeToFocusedViews('TOOL_RESULT', msg.payload);
+  }
+  break;
+```
+
+---
+
+## 7. View Changes
+
+### 7.1 Agent Terminal
+
+- Displays conversation for **one agent at a time** (the focused agent).
+- On `FOCUS_AGENT` change, clears and replays from `CONVERSATION_HISTORY`.
+- Input always routes to the focused agent.
+- Status bar shows: `agent-name · model · tokens · turn`
+
+### 7.2 Activity Stream
+
+- Each event card has an **agent badge** (colored dot + short name).
+- Agent colors are assigned from a palette based on registration order.
+- Filter bar gains agent dropdown alongside existing server/status filters.
+- `ACTIVITY_HISTORY` replays are tagged with the originating agent_id.
+
+### 7.3 Plan Viewer
+
+- Shows plans for the **focused agent** by default.
+- Can optionally show a "supervisor plan" that spans multiple agents.
+- Each plan step can indicate which agent is executing it.
+
+### 7.4 Config Panel
+
+- Shows config for the **focused agent** (model, provider, servers, system prompt).
+- Model/provider switching applies to the focused agent only.
+- Shows a read-only summary of other agents' configs.
+
+### 7.5 NEW: Agent Overview Panel (`builtin:agent-overview`)
+
+A new built-in view showing all agents at a glance:
+
+```
+┌─────────────────────────────────────────────────┐
+│                Agent Overview                    │
+├─────────────────────────────────────────────────┤
+│                                                  │
+│  ┌─ agent-main ──────────────────────┐          │
+│  │ ● Active  │  claude-sonnet  │  42 msgs      │
+│  │ Role: Supervisor                   │          │
+│  │ Current: Planning next steps...    │          │
+│  └────────────────────────────────────┘          │
+│                                                  │
+│  ┌─ agent-research ──────────────────┐          │
+│  │ ◐ Tool calling  │  gpt-4o  │  18 msgs       │
+│  │ Role: Research assistant           │          │
+│  │ Current: web_search("mcp spec")    │          │
+│  └────────────────────────────────────┘          │
+│                                                  │
+│  ┌─ agent-coder ─────────────────────┐          │
+│  │ ○ Completed  │  claude-opus  │  67 msgs      │
+│  │ Role: Code implementation          │          │
+│  │ Finished: All tests passing        │          │
+│  └────────────────────────────────────┘          │
+│                                                  │
+└─────────────────────────────────────────────────┘
+```
+
+---
+
+## 8. Session Management for Multi-Agent
+
+### 8.1 Storage layout
+
+```
+~/.mcp-cli/sessions/
+├── default/                    # single-agent (backward compat)
+│   ├── chat-a1b2c3d4e5f6.json
+│   └── chat-f6e5d4c3b2a1.json
+├── agent-research/
+│   ├── chat-111111111111.json
+│   └── chat-222222222222.json
+└── agent-coder/
+    └── chat-333333333333.json
+```
+
+### 8.2 Session list scoping
+
+`SessionStore.list_sessions(agent_id=None)`:
+
+- `agent_id=None` → list all sessions across all agents
+- `agent_id="agent-research"` → list only that agent's sessions
+
+### 8.3 Session switching per agent
+
+Each agent can independently switch sessions without affecting other agents:
+
+```json
+// Browser sends:
+{ "type": "SWITCH_SESSION", "agent_id": "agent-research", "session_id": "chat-222222222222" }
+
+// Router routes to agent-research's bridge
+// Bridge loads the session, broadcasts CONVERSATION_HISTORY + ACTIVITY_HISTORY
+// Only clients focused on agent-research see the update
+```
+
+### 8.4 Group save/restore
+
+Save/restore an entire agent group:
+
+```
+~/.mcp-cli/groups/
+└── my-project-2026-02-28/
+    ├── group.json              # agent descriptors, relationships, shared plan
+    ├── agent-main/session.json
+    ├── agent-research/session.json
+    └── agent-coder/session.json
+```
+
+`group.json`:
+```json
+{
+  "group_id": "grp-abc123",
+  "created_at": "2026-02-28T12:00:00Z",
+  "description": "Project X implementation",
+  "agents": [
+    {
+      "agent_id": "agent-main",
+      "name": "Main",
+      "role": "supervisor",
+      "model": "claude-sonnet",
+      "provider": "anthropic",
+      "session_id": "chat-aaa",
+      "parent_agent_id": null
+    },
+    {
+      "agent_id": "agent-research",
+      "name": "Research",
+      "role": "researcher",
+      "model": "gpt-4o",
+      "provider": "openai",
+      "session_id": "chat-bbb",
+      "parent_agent_id": "agent-main"
+    }
+  ],
+  "plan": { ... }
+}
+```
+
+---
+
+## 9. Inter-Agent Communication
+
+### 9.1 Message passing
+
+Agents can send messages to each other through the router:
+
+```python
+# New message type
+{ "type": "AGENT_MESSAGE", "from_agent": "agent-main", "to_agent": "agent-research", "content": "Search for MCP spec v2" }
+```
+
+The router delivers this to the target agent's input queue as a system-injected message.
+
+### 9.2 Shared context / artifacts
+
+Agents can publish artifacts (text, data, files) to a shared store:
+
+```python
+{ "type": "PUBLISH_ARTIFACT", "agent_id": "agent-research", "artifact_id": "search-results", "content": "..." }
+{ "type": "REQUEST_ARTIFACT", "agent_id": "agent-coder", "artifact_id": "search-results" }
+```
+
+The dashboard can visualize these as edges in the agent overview.
+
+### 9.3 Supervisor delegation
+
+A supervisor agent can:
+
+1. **Spawn** a new agent: `{ "type": "SPAWN_AGENT", "descriptor": {...}, "initial_prompt": "..." }`
+2. **Stop** an agent: `{ "type": "STOP_AGENT", "agent_id": "agent-research" }`
+3. **Query** agent status: `{ "type": "REQUEST_AGENT_STATUS", "agent_id": "agent-research" }`
+4. **Receive** completion notifications: `{ "type": "AGENT_COMPLETED", "agent_id": "agent-research", "summary": "..." }`
+
+These are implemented as internal tools available to the supervisor:
+
+```python
+# Planning/orchestration tools
+agent_spawn(name, role, model, provider, initial_prompt) -> agent_id
+agent_stop(agent_id) -> bool
+agent_status(agent_id) -> AgentDescriptor
+agent_message(agent_id, content) -> str
+agent_wait(agent_id) -> completion_summary
+```
+
+---
+
+## 10. Tool State Isolation
+
+### 10.1 Current problem
+
+`get_tool_state()` from `chuk_ai_session_manager.guards` returns a **module-level singleton**. Multiple agents sharing the same process would share tool limits, rate counters, and guard state.
+
+### 10.2 Solution
+
+```python
+# Per-agent tool state factory
+def get_tool_state(agent_id: str = "default") -> ToolState:
+    """Return a ToolState scoped to the given agent."""
+    ...
+
+# In ChatContext.__init__:
+self._tool_state = get_tool_state(self.agent_id)
+
+# In ConversationProcessor.__init__:
+self._tool_state = self.context._tool_state  # no more module-level call
+```
+
+### 10.3 Per-agent tool filtering
+
+Each agent can have a restricted tool set:
+
+```python
+class AgentConfig:
+    agent_id: str
+    allowed_tools: list[str] | None = None     # None = all tools
+    denied_tools: list[str] | None = None      # explicit blocklist
+    allowed_servers: list[str] | None = None    # None = all servers
+    tool_timeout_override: float | None = None
+    auto_approve_tools: list[str] | None = None  # skip confirmation for these
+```
+
+---
+
+## 11. WebSocket Protocol v2
+
+### 11.1 Envelope changes
+
+```json
+{
+  "protocol": "mcp-dashboard",
+  "version": 2,
+  "type": "TOOL_RESULT",
+  "agent_id": "agent-research",
+  "payload": { ... }
+}
+```
+
+`agent_id` moves to the **envelope level** (not buried in payload) for efficient routing without deserializing payload.
+
+### 11.2 Client subscription model
+
+Instead of "broadcast everything to everyone", clients subscribe:
+
+```json
+// Client sends on connect:
+{ "type": "SUBSCRIBE", "agents": ["agent-main", "agent-research"], "global": true }
+
+// Server only sends events for subscribed agents + global events
+// Client can update subscription:
+{ "type": "SUBSCRIBE", "agents": ["agent-coder"], "global": true }
+```
+
+Benefits:
+- Reduces bandwidth for multi-agent setups
+- Allows activity stream to subscribe to all, terminal to subscribe to one
+- Popout windows can subscribe independently
+
+### 11.3 Per-view subscriptions
+
+Views declare what they want in their READY message:
+
+```json
+{
+  "type": "READY",
+  "payload": {
+    "name": "Agent Terminal",
+    "accepts": ["CONVERSATION_MESSAGE", "CONVERSATION_TOKEN", ...],
+    "agent_scope": "focused",      // "focused" | "all" | specific agent_id
+    "version": 2
+  }
+}
+```
+
+The shell uses this to route efficiently.
+
+---
+
+## 12. Implementation Phases
+
+### Phase A: Foundation (agent_id plumbing)
+
+**No visible multi-agent yet — just add the wiring.**
+
+1. Add `agent_id` field to `ChatContext`, `SessionMetadata`, all bridge payloads
+2. Add `agent_id` to envelope level (protocol v2, backward compat with v1)
+3. Namespace session storage: `sessions/{agent_id}/`
+4. Pass `agent_id` through `ToolProcessor`, `ConversationProcessor`
+5. Shell ignores `agent_id` for now (treats everything as "default")
+
+**Tests**: Verify all payloads carry `agent_id`, session files go in right directory, backward compat with existing `sessions/` files (auto-migrate to `sessions/default/`).
+
+### Phase B: AgentRouter + Server changes
+
+1. Implement `AgentRouter` class
+2. Modify `DashboardServer` to pass `ws` to message callbacks
+3. Add `send_to_client()` method on server
+4. Bridge uses router instead of server directly
+5. Single-agent mode: router has one bridge, behaves identically to today
+
+**Tests**: Router with 1 bridge = same as direct bridge. Router with 2 bridges routes correctly. Focus switching replays correct state.
+
+### Phase C: Shell multi-agent UI
+
+1. Agent tab bar in shell header
+2. `FOCUS_AGENT` message type
+3. Agent-scoped view routing
+4. Activity stream agent filtering + badges
+5. Agent overview panel (new built-in view)
+6. `AGENT_LIST` / `AGENT_REGISTERED` / `AGENT_UNREGISTERED` handling
+
+**Tests**: UI tests with mock agents. Focus switching. Activity stream filtering.
+
+### Phase D: Agent orchestration
+
+1. `AgentConfig` model for per-agent tool/server restrictions
+2. Supervisor tools: `agent_spawn`, `agent_stop`, `agent_message`, `agent_wait`
+3. Inter-agent message passing via router
+4. Shared artifact store
+5. Group save/restore
+
+**Tests**: Spawn/stop lifecycle. Message delivery. Artifact publish/request. Group save/load.
+
+### Phase E: Client subscriptions + scale
+
+1. Subscription model on WebSocket
+2. Per-view agent_scope in READY
+3. Efficient routing (only send to subscribed clients)
+4. Tool state isolation per agent
+5. Performance testing with 5+ concurrent agents
+
+---
+
+## 13. Backward Compatibility
+
+| Concern | Strategy |
+|---------|----------|
+| Existing sessions in `~/.mcp-cli/sessions/` | Auto-migrate to `sessions/default/` on first access |
+| Protocol v1 clients | Router checks version, omits `agent_id` from envelope for v1 |
+| Single-agent mode | `AgentRouter` with one `"default"` bridge = transparent |
+| Bridge API | Keep `DashboardBridge` constructor accepting `server` (creates implicit router) |
+| No `--multi-agent` flag | Default behavior is single agent, no overhead |
+| `agent_id: "default"` in payloads | All existing views ignore unknown fields gracefully |
+
+---
+
+## 14. Open Questions
+
+1. **Agent model heterogeneity**: Can agents use different providers simultaneously? (Yes, each has its own ChatContext with its own provider/model — already supported.)
+
+2. **Shared tool state**: Should agents share rate limits or have fully independent budgets? (Recommend: independent by default, shared optionally via AgentConfig.)
+
+3. **Agent-to-agent tool access**: Can agent A call a tool that only agent B has? (Recommend: no, each agent has its own ToolManager. Delegation should go through message passing.)
+
+4. **Browser multi-tab**: Multiple browser tabs each focused on different agents — does this create separate WebSocket connections? (Yes, each tab connects independently, each has its own focus.)
+
+5. **Terminal input in multi-agent**: The terminal (stdin) can only feed one agent at a time. How? (Focus concept applies to terminal too — terminal input goes to the "active" agent. `/focus agent-research` switches terminal focus.)
+
+6. **Maximum agent count**: What's the practical limit? (Probably 5-10 concurrent agents due to LLM API concurrency, memory, and cognitive overload for the user.)
+
+7. **Cost tracking per agent**: Should token usage be tracked per agent? (Yes — TokenTracker is already per ChatContext, just needs surfacing in the dashboard.)
diff --git a/src/mcp_cli/dashboard/__init__.py b/src/mcp_cli/dashboard/__init__.py
index 8f8172bb..31813f12 100644
--- a/src/mcp_cli/dashboard/__init__.py
+++ b/src/mcp_cli/dashboard/__init__.py
@@ -10,6 +10,7 @@
 from __future__ import annotations
 
 from mcp_cli.dashboard.bridge import DashboardBridge
+from mcp_cli.dashboard.router import AgentDescriptor, AgentRouter
 from mcp_cli.dashboard.server import DashboardServer
 
-__all__ = ["DashboardBridge", "DashboardServer"]
+__all__ = ["AgentDescriptor", "AgentRouter", "DashboardBridge", "DashboardServer"]
diff --git a/src/mcp_cli/dashboard/bridge.py b/src/mcp_cli/dashboard/bridge.py
index 92afc0d5..1afab2b4 100644
--- a/src/mcp_cli/dashboard/bridge.py
+++ b/src/mcp_cli/dashboard/bridge.py
@@ -9,23 +9,29 @@
 Hook call sites:
   tool_processor._on_tool_result()    → bridge.on_tool_result()
   conversation.process_user_input()   → bridge.on_agent_state(), bridge.on_message()
-  streaming_handler._process_chunk()  → bridge.on_token()          (Phase 4)
+  streaming_handler._process_chunk()  → bridge.on_token()
 """
 
 from __future__ import annotations
 
 import asyncio
 import datetime
+import json as _json
 import logging
 from collections.abc import Awaitable, Callable
-from typing import Any, Literal
+from typing import TYPE_CHECKING, Any, Literal
 
+from mcp_cli.config.defaults import DEFAULT_AGENT_ID
 from mcp_cli.dashboard.server import DashboardServer
 
+if TYPE_CHECKING:
+    from mcp_cli.chat.chat_context import ChatContext
+    from mcp_cli.dashboard.router import AgentRouter
+
 logger = logging.getLogger(__name__)
 
 _PROTOCOL = "mcp-dashboard"
-_VERSION = 1
+_VERSION = 2
 
 
 def _envelope(msg_type: str, payload: dict[str, Any]) -> dict[str, Any]:
@@ -44,9 +50,14 @@ def _now() -> str:
 class DashboardBridge:
     """Routes chat-engine events to connected browser dashboard clients."""
 
-    def __init__(self, server: DashboardServer) -> None:
-        self.server = server
+    def __init__(
+        self, server: DashboardServer | AgentRouter, agent_id: str = DEFAULT_AGENT_ID
+    ) -> None:
+        from mcp_cli.dashboard.router import AgentRouter
+
+        self.agent_id = agent_id
         self._turn_number: int = 0
+        self._ctx: ChatContext | None = None
         # Set this to inject user messages from the browser back into the chat engine
         self._user_message_callback: Callable[[str], None] | None = None
         # Queue for injecting browser messages into the chat loop
@@ -58,9 +69,62 @@ def __init__(self, server: DashboardServer) -> None:
         # View registry discovered from _meta.ui fields in tool results
         self._view_registry: list[dict[str, Any]] = []
         self._seen_view_ids: set[str] = set()
-        # Wire server callbacks
-        server.on_browser_message = self._on_browser_message
-        server.on_client_connected = self._on_client_connected
+        # Pending tool approval futures keyed by call_id
+        self._pending_approvals: dict[str, asyncio.Future[bool]] = {}
+
+        # Dual-mode: router-managed vs direct-wiring
+        if isinstance(server, AgentRouter):
+            self._router: AgentRouter | None = server
+            self.server: DashboardServer = server.server
+            # Router owns the server callbacks — do NOT wire them here
+        else:
+            self._router = None
+            self.server = server
+            # Legacy direct-wiring path
+            server.on_browser_message = self._on_browser_message
+            server.on_client_connected = self._on_client_connected
+            server.on_client_disconnected = self.on_client_disconnected
+
+    def set_context(self, ctx: ChatContext) -> None:
+        """Store a back-reference to ChatContext for history/config queries."""
+        self._ctx = ctx
+
+    async def on_shutdown(self) -> None:
+        """Cancel all pending approval futures. Call before stopping server."""
+        for call_id, fut in list(self._pending_approvals.items()):
+            if not fut.done():
+                fut.set_result(False)
+        self._pending_approvals.clear()
+
+    @property
+    def has_clients(self) -> bool:
+        """Whether any browser clients are connected."""
+        if self._router is not None:
+            return self._router.has_clients
+        return self.server.has_clients
+
+    async def _broadcast(self, envelope: dict[str, Any]) -> None:
+        """Dispatch a broadcast through the router or directly to the server."""
+        if self._router is not None:
+            await self._router.broadcast_from_agent(self.agent_id, envelope)
+        else:
+            await self.server.broadcast(envelope)
+
+    async def broadcast(self, envelope: dict[str, Any]) -> None:
+        """Public broadcast method for external callers (e.g. commands)."""
+        await self._broadcast(envelope)
+
+    async def on_client_disconnected(self) -> None:
+        """Called when a browser client disconnects.
+
+        If no clients remain, cancel all pending approval futures so the
+        tool processor doesn't hang waiting for a response that will never come.
+        """
+        if not self.has_clients:
+            for call_id, fut in list(self._pending_approvals.items()):
+                if not fut.done():
+                    fut.set_result(False)
+            self._pending_approvals.clear()
 
     # ------------------------------------------------------------------ #
     #  Outbound hooks (chat engine → browser)                            #
@@ -76,25 +140,27 @@ async def on_tool_result(
         duration_ms: int | None = None,
         meta_ui: Any = None,
         call_id: str | None = None,
+        arguments: dict[str, Any] | None = None,
     ) -> None:
         """Called after every tool execution completes."""
         payload: dict[str, Any] = {
             "tool_name": tool_name,
             "server_name": server_name,
-            "agent_id": "default",
+            "agent_id": self.agent_id,
             "call_id": call_id or "",
             "timestamp": _now(),
             "duration_ms": duration_ms,
             "result": self._serialise(result),
             "error": error,
             "success": success,
+            "arguments": self._serialise(arguments) if arguments else None,
         }
         if meta_ui is not None:
             payload["meta_ui"] = self._serialise(meta_ui)
             # Discover new views declared in _meta.ui before broadcasting
             if isinstance(meta_ui, dict) and meta_ui.get("view"):
                 await self._discover_view(meta_ui, server_name)
-        await self.server.broadcast(_envelope("TOOL_RESULT", payload))
+        await self._broadcast(_envelope("TOOL_RESULT", payload))
 
     async def on_agent_state(
         self,
@@ -107,14 +173,14 @@ async def on_agent_state(
         if turn_number is not None:
             self._turn_number = turn_number
         payload: dict[str, Any] = {
-            "agent_id": "default",
+            "agent_id": self.agent_id,
             "status": status,
             "current_tool": current_tool,
             "turn_number": self._turn_number,
             "tokens_used": tokens_used,
             "budget_remaining": None,
         }
-        await self.server.broadcast(_envelope("AGENT_STATE", payload))
+        await self._broadcast(_envelope("AGENT_STATE", payload))
 
     async def on_message(
         self,
@@ -123,25 +189,34 @@ async def on_message(
         streaming: bool = False,
         reasoning: str | None = None,
         tool_calls: list[dict[str, Any]] | None = None,
+        attachments: list[dict[str, Any]] | None = None,
     ) -> None:
         """Called when a complete conversation message is emitted."""
         payload: dict[str, Any] = {
+            "agent_id": self.agent_id,
             "role": role,
             "content": content,
             "streaming": streaming,
             "tool_calls": tool_calls,
             "reasoning": reasoning,
+            "attachments": attachments,
         }
-        await self.server.broadcast(_envelope("CONVERSATION_MESSAGE", payload))
+        await self._broadcast(_envelope("CONVERSATION_MESSAGE", payload))
 
     async def on_token(self, token: str, done: bool = False) -> None:
         """Called for each streamed LLM token (high-volume — only used by agent terminal)."""
-        payload: dict[str, Any] = {"token": token, "done": done}
-        await self.server.broadcast(_envelope("CONVERSATION_TOKEN", payload))
+        payload: dict[str, Any] = {
+            "agent_id": self.agent_id,
+            "token": token,
+            "done": done,
+        }
+        await self._broadcast(_envelope("CONVERSATION_TOKEN", payload))
 
     async def on_view_registry_update(self, views: list[dict[str, Any]]) -> None:
         """Called when the set of available views changes (server connect/disconnect)."""
-        await self.server.broadcast({"type": "VIEW_REGISTRY", "views": views})
+        await self._broadcast(
+            _envelope("VIEW_REGISTRY", {"agent_id": self.agent_id, "views": views})
+        )
 
     async def _discover_view(self, meta_ui: dict[str, Any], server_name: str) -> None:
         """Register a new view from a _meta.ui block and broadcast VIEW_REGISTRY."""
@@ -164,17 +239,39 @@ async def _discover_view(self, meta_ui: dict[str, Any], server_name: str) -> Non
         await self.on_view_registry_update(self._view_registry)
 
     async def _on_client_connected(self, ws: Any) -> None:
-        """Send current VIEW_REGISTRY to a newly connected browser client."""
-        if not self._view_registry:
-            return
-        import json as _json
-
+        """Send current state to a newly connected browser client."""
         try:
-            await ws.send(
-                _json.dumps({"type": "VIEW_REGISTRY", "views": self._view_registry})
-            )
+            # VIEW_REGISTRY
+            if self._view_registry:
+                await ws.send(
+                    _json.dumps(
+                        _envelope("VIEW_REGISTRY", {"views": self._view_registry})
+                    )
+                )
+            # CONFIG_STATE (model, provider, servers, system prompt preview)
+            config = self._build_config_state()
+            if config:
+                await ws.send(_json.dumps(_envelope("CONFIG_STATE", config)))
+            # TOOL_REGISTRY
+            tools = await self._build_tool_registry()
+            if tools is not None:
+                await ws.send(_json.dumps(_envelope("TOOL_REGISTRY", {"tools": tools})))
+            # CONVERSATION_HISTORY replay (chat view)
+            history = self._build_conversation_history()
+            if history:
+                await ws.send(
+                    _json.dumps(
+                        _envelope("CONVERSATION_HISTORY", {"messages": history})
+                    )
+                )
+            # ACTIVITY_HISTORY replay (activity stream)
+            activity = self._build_activity_history()
+            if activity:
+                await ws.send(
+                    _json.dumps(_envelope("ACTIVITY_HISTORY", {"events": activity}))
+                )
         except Exception as exc:
-            logger.debug("Error sending VIEW_REGISTRY to new client: %s", exc)
+            logger.debug("Error sending initial state to new client: %s", exc)
 
     # ------------------------------------------------------------------ #
     #  Inbound messages (browser → chat engine)                          #
@@ -203,6 +300,25 @@ async def _on_browser_message(self, msg: dict[str, Any]) -> None:
         msg_type = msg.get("type")
         if msg_type in ("USER_MESSAGE", "USER_COMMAND"):
             content = msg.get("content") or msg.get("command", "")
+            files = msg.get("files")  # list of {name, data, mime_type}
+
+            # Stage browser-uploaded files on ChatContext
+            if files and self._ctx is not None:
+                from mcp_cli.chat.attachments import process_browser_file
+
+                for f in files:
+                    try:
+                        att = process_browser_file(f["name"], f["data"], f["mime_type"])
+                        self._ctx.attachment_staging.stage(att)
+                    except (ValueError, KeyError) as exc:
+                        logger.warning(
+                            "Bad browser file %s: %s", f.get("name", "?"), exc
+                        )
+
+            # If files attached but no text, queue a space so the chat loop iterates
+            if not content and files:
+                content = " "
+
             if content and self._input_queue is not None:
                 try:
                     await self._input_queue.put(content)
@@ -239,7 +355,6 @@ async def _on_browser_message(self, msg: dict[str, Any]) -> None:
         elif msg_type == "USER_ACTION":
             action = msg.get("action") or ""
             content = msg.get("content") or ""
-            # Prefer explicit content; fall back to slash-command form of action name
             text = content or (f"/{action}" if action else "")
             if text and self._input_queue is not None:
                 try:
@@ -248,31 +363,712 @@ async def _on_browser_message(self, msg: dict[str, Any]) -> None:
                     logger.warning("Error queuing USER_ACTION: %s", exc)
             else:
                 logger.debug("Dashboard USER_ACTION not routed: %s", msg)
+        elif msg_type == "REQUEST_CONFIG":
+            await self._handle_request_config()
+        elif msg_type == "REQUEST_TOOLS":
+            await self._handle_request_tools()
+        elif msg_type == "SWITCH_MODEL":
+            await self._handle_switch_model(msg)
+        elif msg_type == "UPDATE_SYSTEM_PROMPT":
+            await self._handle_update_system_prompt(msg)
+        elif msg_type == "TOOL_APPROVAL_RESPONSE":
+            await self._handle_tool_approval_response(msg)
+        elif msg_type == "CLEAR_HISTORY":
+            await self._handle_clear_history()
+        elif msg_type == "NEW_SESSION":
+            await self._handle_new_session(msg)
+        elif msg_type == "REQUEST_SESSIONS":
+            await self._handle_request_sessions()
+        elif msg_type == "SWITCH_SESSION":
+            await self._handle_switch_session(msg)
+        elif msg_type == "DELETE_SESSION":
+            await self._handle_delete_session(msg)
+        elif msg_type == "RENAME_SESSION":
+            await self._handle_rename_session(msg)
         else:
             logger.debug("Dashboard received unknown message type: %s", msg_type)
 
+    # ------------------------------------------------------------------ #
+    #  Config / Model / System-prompt handlers                            #
+    # ------------------------------------------------------------------ #
+
+    async def _handle_request_config(self) -> None:
+        """Browser requested current config — broadcast CONFIG_STATE."""
+        config = self._build_config_state()
+        if config:
+            await self._broadcast(_envelope("CONFIG_STATE", config))
+
+    async def _handle_switch_model(self, msg: dict[str, Any]) -> None:
+        """Browser requested a model switch."""
+        ctx = self._ctx
+        if not ctx:
+            logger.debug("SWITCH_MODEL: no context set")
+            return
+        provider = msg.get("provider") or ""
+        model = msg.get("model") or ""
+        if not provider or not model:
+            logger.debug("SWITCH_MODEL: missing provider or model")
+            return
+        try:
+            ctx.model_manager.switch_model(provider, model)
+            await ctx.refresh_after_model_change()
+            logger.info("Dashboard: switched to %s/%s", provider, model)
+        except Exception as exc:
+            logger.warning("Dashboard SWITCH_MODEL failed: %s", exc)
+        # Broadcast updated state
+        config = self._build_config_state()
+        if config:
+            await self._broadcast(_envelope("CONFIG_STATE", config))
+
+    async def _handle_update_system_prompt(self, msg: dict[str, Any]) -> None:
+        """Browser updated the system prompt."""
+        ctx = self._ctx
+        if not ctx:
+            logger.debug("UPDATE_SYSTEM_PROMPT: no context set")
+            return
+        new_prompt = msg.get("system_prompt")
+        if new_prompt is None:
+            return
+        try:
+            if new_prompt == "":
+                # Empty string → regenerate default prompt
+                await ctx.regenerate_system_prompt()
+            else:
+                ctx._system_prompt = new_prompt
+                await ctx.session.update_system_prompt(new_prompt)
+            logger.info(
+                "Dashboard: system prompt updated (%d chars)", len(ctx._system_prompt)
+            )
+        except Exception as exc:
+            logger.warning("Dashboard UPDATE_SYSTEM_PROMPT failed: %s", exc)
+        config = self._build_config_state()
+        if config:
+            await self._broadcast(_envelope("CONFIG_STATE", config))
+
+    # ------------------------------------------------------------------ #
+    #  Clear history handler                                              #
+    # ------------------------------------------------------------------ #
+
+    async def _handle_clear_history(self) -> None:
+        """Browser requested conversation history clear."""
+        ctx = self._ctx
+        if not ctx:
+            logger.debug("CLEAR_HISTORY: no context set")
+            return
+        try:
+            await ctx.clear_conversation_history(keep_system_prompt=True)
+            logger.info("Dashboard: conversation history cleared")
+        except Exception as exc:
+            logger.warning("Dashboard CLEAR_HISTORY failed: %s", exc)
+        # Broadcast empty history + clear activity stream
+        await self._broadcast(
+            _envelope(
+                "CONVERSATION_HISTORY", {"agent_id": self.agent_id, "messages": []}
+            )
+        )
+        await self._broadcast(
+            _envelope("ACTIVITY_HISTORY", {"agent_id": self.agent_id, "events": []})
+        )
+        config = self._build_config_state()
+        if config:
+            await self._broadcast(_envelope("CONFIG_STATE", config))
+
+    # ------------------------------------------------------------------ #
+    #  New session handler                                                #
+    # ------------------------------------------------------------------ #
+
+    async def _handle_new_session(self, msg: dict[str, Any]) -> None:
+        """Browser requested a new session (save current + start fresh)."""
+        ctx = self._ctx
+        if not ctx:
+            logger.debug("NEW_SESSION: no context set")
+            return
+        description = msg.get("description", "")
+
+        # Save current session first (if there's history)
+        if hasattr(ctx, "save_session") and ctx.conversation_history:
+            try:
+                path = ctx.save_session()
+                if path:
+                    logger.info("Dashboard: previous session saved: %s", path)
+            except Exception as exc:
+                logger.warning("Dashboard: could not save previous session: %s", exc)
+
+        # Clear history and start fresh
+        try:
+            await ctx.clear_conversation_history(keep_system_prompt=True)
+            logger.info("Dashboard: new session started: %s", ctx.session_id)
+        except Exception as exc:
+            logger.warning("Dashboard NEW_SESSION failed: %s", exc)
+            return
+
+        # Broadcast fresh state to all clients + clear activity stream
+        await self._broadcast(
+            _envelope(
+                "CONVERSATION_HISTORY", {"agent_id": self.agent_id, "messages": []}
+            )
+        )
+        await self._broadcast(
+            _envelope("ACTIVITY_HISTORY", {"agent_id": self.agent_id, "events": []})
+        )
+        config = self._build_config_state()
+        if config:
+            await self._broadcast(_envelope("CONFIG_STATE", config))
+        await self._broadcast(
+            _envelope(
+                "SESSION_STATE",
+                {
+                    "agent_id": self.agent_id,
+                    "session_id": ctx.session_id,
+                    "description": description,
+                },
+            )
+        )
+
+    # ------------------------------------------------------------------ #
+    #  Session management handlers                                         #
+    # ------------------------------------------------------------------ #
+
+    async def _handle_request_sessions(self) -> None:
+        """Browser requested list of saved sessions."""
+        ctx = self._ctx
+        if not ctx:
+            return
+        try:
+            store = getattr(ctx, "_session_store", None)
+            if not store:
+                return
+            sessions = store.list_sessions()
+            payload = {
+                "agent_id": self.agent_id,
+                "sessions": [
+                    {
+                        "session_id": s.session_id,
+                        "created_at": s.created_at,
+                        "updated_at": s.updated_at,
+                        "provider": s.provider,
+                        "model": s.model,
+                        "message_count": s.message_count,
+                        "description": s.description,
+                        "is_current": s.session_id == ctx.session_id,
+                    }
+                    for s in sessions
+                ],
+                "current_session_id": ctx.session_id,
+            }
+            await self._broadcast(_envelope("SESSION_LIST", payload))
+        except Exception as exc:
+            logger.warning("Error building session list: %s", exc)
+
+    async def _handle_switch_session(self, msg: dict[str, Any]) -> None:
+        """Browser requested to switch to a different session."""
+        ctx = self._ctx
+        if not ctx:
+            return
+        session_id = msg.get("session_id", "")
+        if not session_id:
+            return
+
+        # Save current session first
+        if ctx.conversation_history:
+            try:
+                ctx.save_session()
+            except Exception:
+                pass
+
+        # Clear and load the target session
+        try:
+            await ctx.clear_conversation_history(keep_system_prompt=True)
+            loaded = ctx.load_session(session_id)
+            if not loaded:
+                logger.warning("Failed to load session %s", session_id)
+                return
+            # Override session_id to match loaded session
+            ctx.session_id = session_id
+            logger.info("Dashboard: switched to session %s", session_id)
+        except Exception as exc:
+            logger.warning("Dashboard SWITCH_SESSION failed: %s", exc)
+            return
+
+        # Broadcast updated state
+        history = self._build_conversation_history()
+        await self._broadcast(
+            _envelope("CONVERSATION_HISTORY", {"messages": history or []})
+        )
+        # Activity stream replay for loaded session
+        activity = self._build_activity_history()
+        await self._broadcast(_envelope("ACTIVITY_HISTORY", {"events": activity or []}))
+        config = self._build_config_state()
+        if config:
+            await self._broadcast(_envelope("CONFIG_STATE", config))
+        await self._broadcast(
+            _envelope(
+                "SESSION_STATE",
+                {"agent_id": self.agent_id, "session_id": session_id},
+            )
+        )
+        # Refresh session list
+        await self._handle_request_sessions()
+
+    async def _handle_delete_session(self, msg: dict[str, Any]) -> None:
+        """Browser requested to delete a saved session."""
+        ctx = self._ctx
+        if not ctx:
+            return
+        session_id = msg.get("session_id", "")
+        if not session_id:
+            return
+        # Don't allow deleting the current session
+        if session_id == ctx.session_id:
+            logger.debug("Cannot delete the current active session")
+            return
+        try:
+            store = getattr(ctx, "_session_store", None)
+            if store:
+                store.delete(session_id)
+                logger.info("Dashboard: deleted session %s", session_id)
+        except Exception as exc:
+            logger.warning("Dashboard DELETE_SESSION failed: %s", exc)
+        # Refresh session list
+        await self._handle_request_sessions()
+
+    async def _handle_rename_session(self, msg: dict[str, Any]) -> None:
+        """Browser requested to rename/describe a session."""
+        ctx = self._ctx
+        if not ctx:
+            return
+        session_id = msg.get("session_id", "")
+        description = msg.get("description", "")
+        if not session_id:
+            return
+        try:
+            store = getattr(ctx, "_session_store", None)
+            if not store:
+                return
+            data = store.load(session_id)
+            if data:
+                data.metadata.description = description
+                store.save(data)
+                logger.info(
+                    "Dashboard: renamed session %s → %s", session_id, description
+                )
+        except Exception as exc:
+            logger.warning("Dashboard RENAME_SESSION failed: %s", exc)
+        # Refresh session list
+        await self._handle_request_sessions()
+
+    # ------------------------------------------------------------------ #
+    #  Tool registry handler                                              #
+    # ------------------------------------------------------------------ #
+
+    async def _handle_request_tools(self) -> None:
+        """Browser requested current tool list — broadcast TOOL_REGISTRY."""
+        tools = await self._build_tool_registry()
+        if tools is not None:
+            await self._broadcast(_envelope("TOOL_REGISTRY", {"tools": tools}))
+
+    async def _build_tool_registry(self) -> list[dict[str, Any]] | None:
+        """Build tool registry payload from ChatContext's tool_manager."""
+        ctx = self._ctx
+        if not ctx:
+            return None
+        try:
+            tm = getattr(ctx, "tool_manager", None)
+            if not tm:
+                return None
+            all_tools = await tm.get_all_tools()
+            return [
+                {
+                    "name": t.name,
+                    "namespace": t.namespace,
+                    "description": t.description,
+                    "parameters": t.parameters,
+                    "is_async": t.is_async,
+                    "tags": t.tags,
+                    "supports_streaming": t.supports_streaming,
+                }
+                for t in all_tools
+            ]
+        except Exception as exc:
+            logger.debug("Error building tool registry: %s", exc)
+            return None
+
+    # ------------------------------------------------------------------ #
+    #  Tool approval (dashboard ↔ tool_processor)                         #
+    # ------------------------------------------------------------------ #
+
+    async def request_tool_approval(
+        self,
+        tool_name: str,
+        arguments: Any,
+        call_id: str,
+    ) -> asyncio.Future[bool]:
+        """Send a tool approval request to the dashboard.
+
+        The browser will show an approve/deny dialog and respond with
+        TOOL_APPROVAL_RESPONSE.  Returns a Future that resolves to True/False.
+        """
+        payload: dict[str, Any] = {
+            "agent_id": self.agent_id,
+            "tool_name": tool_name,
+            "arguments": self._serialise(arguments),
+            "call_id": call_id,
+            "timestamp": _now(),
+        }
+        # Create a future that the tool processor can await
+        fut: asyncio.Future[bool] = asyncio.get_running_loop().create_future()
+        self._pending_approvals[call_id] = fut
+        await self._broadcast(_envelope("TOOL_APPROVAL_REQUEST", payload))
+        return fut
+
+    async def _handle_tool_approval_response(self, msg: dict[str, Any]) -> None:
+        """Handle approval/denial response from the dashboard."""
+        call_id = msg.get("call_id", "")
+        approved = msg.get("approved", False)
+        fut = self._pending_approvals.pop(call_id, None)
+        if fut and not fut.done():
+            fut.set_result(approved)
+
+    # ------------------------------------------------------------------ #
+    #  Plan updates (chat engine → browser)                               #
+    # ------------------------------------------------------------------ #
+
+    async def on_plan_update(
+        self,
+        plan_id: str,
+        title: str,
+        steps: list[dict[str, Any]],
+        status: str = "running",
+        current_step: int | None = None,
+        error: str | None = None,
+    ) -> None:
+        """Broadcast a plan update to the dashboard."""
+        payload: dict[str, Any] = {
+            "agent_id": self.agent_id,
+            "plan_id": plan_id,
+            "title": title,
+            "steps": steps,
+            "status": status,
+            "current_step": current_step,
+            "error": error,
+            "timestamp": _now(),
+        }
+        await self._broadcast(_envelope("PLAN_UPDATE", payload))
+
+    # ------------------------------------------------------------------ #
+    #  State builders                                                     #
+    # ------------------------------------------------------------------ #
+
+    def _build_config_state(self) -> dict[str, Any] | None:
+        """Build CONFIG_STATE payload from current ChatContext."""
+        ctx = self._ctx
+        if not ctx:
+            return None
+        try:
+            provider = ctx.provider
+            model = ctx.model
+            mm = ctx.model_manager
+
+            # Build provider → models map
+            available_providers: list[dict[str, Any]] = []
+            for pname in mm.get_available_providers():
+                try:
+                    models = mm.get_available_models(pname)
+                except Exception:
+                    models = []
+                available_providers.append({"name": pname, "models": models})
+
+            # Server info
+            servers: list[dict[str, Any]] = []
+            for si in getattr(ctx, "server_info", []) or []:
+                servers.append(
+                    {
+                        "id": si.id,
+                        "name": si.name,
+                        "namespace": si.namespace,
+                        "status": si.status,
+                        "tool_count": si.tool_count,
+                        "connected": si.connected,
+                        "transport": str(si.transport),
+                    }
+                )
+
+            # System prompt preview (first 500 chars)
+            sys_prompt = getattr(ctx, "_system_prompt", "") or ""
+
+            return {
+                "agent_id": self.agent_id,
+                "provider": provider,
+                "model": model,
+                "available_providers": available_providers,
+                "servers": servers,
+                "system_prompt": sys_prompt,
+            }
+        except Exception as exc:
+            logger.debug("Error building CONFIG_STATE: %s", exc)
+            return None
+
+    @staticmethod
+    def _content_block_to_descriptor(block: dict[str, Any]) -> dict[str, Any]:
+        """Convert a raw content block dict into a dashboard-safe descriptor.
+
+        Used during conversation history replay when we have raw content
+        blocks but not ``Attachment`` objects.
+        """
+        from mcp_cli.config.defaults import (
+            DEFAULT_DASHBOARD_INLINE_IMAGE_THRESHOLD,
+            DEFAULT_DASHBOARD_TEXT_PREVIEW_CHARS,
+        )
+
+        btype = block.get("type", "")
+        desc: dict[str, Any] = {"kind": "unknown", "display_name": "", "size_bytes": 0}
+
+        if btype == "image_url":
+            url = block.get("image_url", {}).get("url", "")
+            desc["kind"] = "image"
+            desc["mime_type"] = "image/unknown"
+            if url.startswith("http"):
+                desc["preview_url"] = url
+                desc["display_name"] = url.rsplit("/", 1)[-1][:60]
+            elif url.startswith("data:"):
+                # Estimate raw size from data URI length (base64 ≈ 4/3 of raw)
+                data_part = url.split(",", 1)[-1] if "," in url else ""
+                est_size = len(data_part) * 3 // 4
+                if est_size <= DEFAULT_DASHBOARD_INLINE_IMAGE_THRESHOLD:
+                    desc["preview_url"] = url
+                else:
+                    desc["preview_url"] = None
+                desc["size_bytes"] = est_size
+                desc["display_name"] = "image"
+            else:
+                desc["preview_url"] = None
+
+        elif btype == "text":
+            text = block.get("text", "")
+            desc["kind"] = "text"
+            desc["mime_type"] = "text/plain"
+            desc["text_preview"] = text[:DEFAULT_DASHBOARD_TEXT_PREVIEW_CHARS]
+            desc["text_truncated"] = len(text) > DEFAULT_DASHBOARD_TEXT_PREVIEW_CHARS
+            # Try to extract filename from "--- filename ---" wrapper
+            if text.startswith("--- ") and " ---\n" in text:
+                name = text[4 : text.index(" ---\n")]
+                desc["display_name"] = name
+
+        elif btype == "input_audio":
+            audio = block.get("input_audio", {})
+            fmt = audio.get("format", "mp3")
+            data = audio.get("data", "")
+            est_size = len(data) * 3 // 4
+            desc["kind"] = "audio"
+            desc["mime_type"] = "audio/mpeg" if fmt == "mp3" else f"audio/{fmt}"
+            desc["size_bytes"] = est_size
+            desc["display_name"] = f"audio.{fmt}"
+            if est_size <= DEFAULT_DASHBOARD_INLINE_IMAGE_THRESHOLD:
+                mime = desc["mime_type"]
+                desc["audio_data_uri"] = f"data:{mime};base64,{data}"
+            else:
+                desc["audio_data_uri"] = None
+
+        return desc
+
+    def _build_conversation_history(self) -> list[dict[str, Any]] | None:
+        """Build conversation history payload from ChatContext.
+
+        Returns only user/assistant messages — tool-role messages are excluded
+        from the chat view and instead served via ``_build_activity_history()``.
+        """
+        ctx = self._ctx
+        if not ctx:
+            return None
+        try:
+            messages: list[dict[str, Any]] = []
+            for msg in ctx.conversation_history:
+                d = msg.to_dict()
+                role = d.get("role", "")
+                # Skip system and tool messages — system isn't shown,
+                # tool results belong in the activity stream, not chat
+                if role in ("system", "tool"):
+                    continue
+
+                raw_content = d.get("content")
+                attachments = None
+
+                # Handle multimodal content blocks
+                if isinstance(raw_content, list):
+                    text_parts: list[str] = []
+                    att_descriptors: list[dict[str, Any]] = []
+                    for block in raw_content:
+                        if block.get("type") == "text":
+                            text_parts.append(block.get("text", ""))
+                        else:
+                            att_descriptors.append(
+                                self._content_block_to_descriptor(block)
+                            )
+                    content_str = "\n".join(text_parts)
+                    if att_descriptors:
+                        attachments = att_descriptors
+                else:
+                    content_str = raw_content or ""
+
+                messages.append(
+                    {
+                        "role": role,
+                        "content": content_str,
+                        "tool_calls": d.get("tool_calls"),
+                        "reasoning": d.get("reasoning_content"),
+                        "attachments": attachments,
+                    }
+                )
+            return messages if messages else None
+        except Exception as exc:
+            logger.debug("Error building conversation history: %s", exc)
+            return None
+
+    def _build_activity_history(self) -> list[dict[str, Any]] | None:
+        """Build activity stream events from conversation history.
+
+        Pairs assistant ``tool_calls`` with their corresponding ``tool``-role
+        result messages to synthesize TOOL_RESULT-like payloads for the
+        activity stream.  Also includes assistant messages that carry
+        reasoning or tool_calls (for the "Calling …" cards).
+        """
+        ctx = self._ctx
+        if not ctx:
+            return None
+        try:
+            raw = [m.to_dict() for m in ctx.conversation_history]
+
+            # Index tool-role results by tool_call_id for fast lookup
+            tool_results: dict[str, dict[str, Any]] = {}
+            for d in raw:
+                if d.get("role") == "tool" and d.get("tool_call_id"):
+                    tool_results[d["tool_call_id"]] = d
+
+            events: list[dict[str, Any]] = []
+            for d in raw:
+                role = d.get("role", "")
+
+                # User messages with attachments (multimodal content)
+                if role == "user":
+                    raw_content = d.get("content")
+                    if isinstance(raw_content, list):
+                        text_parts: list[str] = []
+                        att_descs: list[dict[str, Any]] = []
+                        for block in raw_content:
+                            if block.get("type") == "text":
+                                text_parts.append(block.get("text", ""))
+                            else:
+                                att_descs.append(
+                                    self._content_block_to_descriptor(block)
+                                )
+                        if att_descs:
+                            events.append(
+                                {
+                                    "type": "CONVERSATION_MESSAGE",
+                                    "payload": {
+                                        "role": "user",
+                                        "content": "\n".join(text_parts),
+                                        "attachments": att_descs,
+                                    },
+                                }
+                            )
+
+                if role == "assistant":
+                    tool_calls = d.get("tool_calls") or []
+                    reasoning = d.get("reasoning_content")
+
+                    # Emit a CONVERSATION_MESSAGE event for reasoning / tool_calls
+                    if reasoning or tool_calls:
+                        events.append(
+                            {
+                                "type": "CONVERSATION_MESSAGE",
+                                "payload": {
+                                    "role": "assistant",
+                                    "content": d.get("content") or "",
+                                    "tool_calls": tool_calls or None,
+                                    "reasoning": reasoning,
+                                },
+                            }
+                        )
+
+                    # For each tool_call, try to pair with its result
+                    for tc in tool_calls:
+                        call_id = tc.get("id", "")
+                        fn = tc.get("function") or {}
+                        tool_name = fn.get("name", "")
+                        args_str = fn.get("arguments", "")
+                        try:
+                            arguments = (
+                                _json.loads(args_str)
+                                if isinstance(args_str, str) and args_str
+                                else args_str
+                            )
+                        except _json.JSONDecodeError:
+                            arguments = args_str
+
+                        # Look up the matching tool result
+                        tr = tool_results.get(call_id)
+                        result_content = (tr.get("content") or "") if tr else None
+
+                        events.append(
+                            {
+                                "type": "TOOL_RESULT",
+                                "payload": {
+                                    "tool_name": tool_name,
+                                    "server_name": "",
+                                    "agent_id": self.agent_id,
+                                    "call_id": call_id,
+                                    "timestamp": None,
+                                    "duration_ms": None,
+                                    "result": result_content,
+                                    "error": None,
+                                    "success": True,
+                                    "arguments": self._serialise(arguments)
+                                    if arguments
+                                    else None,
+                                },
+                            }
+                        )
+
+            return events if events else None
+        except Exception as exc:
+            logger.debug("Error building activity history: %s", exc)
+            return None
+
     # ------------------------------------------------------------------ #
     #  Helpers                                                            #
     # ------------------------------------------------------------------ #
 
+    _SERIALISE_MAX_DEPTH = 20
+
     @staticmethod
-    def _serialise(value: Any) -> Any:
+    def _serialise(value: Any, _depth: int = 0) -> Any:
         """Convert a value to a JSON-safe representation."""
+        if _depth > DashboardBridge._SERIALISE_MAX_DEPTH:
+            return "<max depth exceeded>"
         if value is None or isinstance(value, (bool, int, float, str)):
             return value
         if isinstance(value, (list, tuple)):
-            return [DashboardBridge._serialise(v) for v in value]
+            return [DashboardBridge._serialise(v, _depth + 1) for v in value]
         if isinstance(value, dict):
-            return {k: DashboardBridge._serialise(v) for k, v in value.items()}
+            return {
+                k: DashboardBridge._serialise(v, _depth + 1) for k, v in value.items()
+            }
         # Objects with a to_dict / model_dump / __dict__
         if hasattr(value, "to_dict"):
             try:
-                return DashboardBridge._serialise(value.to_dict())
-            except Exception:
-                pass
+                return DashboardBridge._serialise(value.to_dict(), _depth + 1)
+            except Exception as exc:
+                logger.debug(
+                    "_serialise to_dict() failed for %s: %s", type(value).__name__, exc
+                )
         if hasattr(value, "model_dump"):
             try:
-                return DashboardBridge._serialise(value.model_dump())
-            except Exception:
-                pass
+                return DashboardBridge._serialise(value.model_dump(), _depth + 1)
+            except Exception as exc:
+                logger.debug(
+                    "_serialise model_dump() failed for %s: %s",
+                    type(value).__name__,
+                    exc,
+                )
         return str(value)
diff --git a/src/mcp_cli/dashboard/config.py b/src/mcp_cli/dashboard/config.py
index 74ac9b63..082b2dd0 100644
--- a/src/mcp_cli/dashboard/config.py
+++ b/src/mcp_cli/dashboard/config.py
@@ -89,6 +89,14 @@
         "type": "stream",
         "url": "/views/activity-stream.html",
     },
+    {
+        "id": "builtin:agent-overview",
+        "name": "Agent Overview",
+        "source": "builtin",
+        "icon": "agents",
+        "type": "agents",
+        "url": "/views/agent-overview.html",
+    },
 ]
 
 # ------------------------------------------------------------------ #
diff --git a/src/mcp_cli/dashboard/launcher.py b/src/mcp_cli/dashboard/launcher.py
index 3bf49fc6..35b16075 100644
--- a/src/mcp_cli/dashboard/launcher.py
+++ b/src/mcp_cli/dashboard/launcher.py
@@ -6,6 +6,7 @@
 import logging
 import webbrowser
 
+from mcp_cli.dashboard.router import AgentRouter
 from mcp_cli.dashboard.server import DashboardServer
 
 logger = logging.getLogger(__name__)
@@ -14,7 +15,7 @@
 async def launch_dashboard(
     port: int = 0,
     no_browser: bool = False,
-) -> tuple[DashboardServer, int]:
+) -> tuple[DashboardServer, AgentRouter, int]:
     """Start the dashboard server and (optionally) open the browser.
 
     Args:
@@ -22,10 +23,11 @@ async def launch_dashboard(
         no_browser: If True, do not open the browser (URL is logged at INFO level).
 
     Returns:
-        (server, bound_port) — the started server and its actual port.
+        (server, router, bound_port) — the started server, router, and actual port.
     """
     server = DashboardServer()
     bound_port = await server.start(port)
+    router = AgentRouter(server)
 
     url = f"http://localhost:{bound_port}"
     logger.info("Dashboard available at %s", url)
@@ -36,4 +38,4 @@ async def launch_dashboard(
         except Exception as exc:
             logger.warning("Could not open browser: %s", exc)
 
-    return server, bound_port
+    return server, router, bound_port
diff --git a/src/mcp_cli/dashboard/router.py b/src/mcp_cli/dashboard/router.py
new file mode 100644
index 00000000..df4e45a9
--- /dev/null
+++ b/src/mcp_cli/dashboard/router.py
@@ -0,0 +1,319 @@
+# mcp_cli/dashboard/router.py
+"""AgentRouter — routes messages between browser clients and DashboardBridge instances.
+
+In single-agent mode the router has exactly one bridge and behaves identically
+to the legacy direct-wiring path.  In multi-agent mode it tracks per-client
+focus, sends AGENT_LIST on connect, and handles FOCUS_AGENT switching.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+from dataclasses import asdict, dataclass
+from typing import TYPE_CHECKING, Any, Literal
+
+from mcp_cli.dashboard.server import DashboardServer
+
+if TYPE_CHECKING:
+    from mcp_cli.dashboard.bridge import DashboardBridge
+
+logger = logging.getLogger(__name__)
+
+# ------------------------------------------------------------------ #
+#  Protocol helpers (mirror bridge.py)                                 #
+# ------------------------------------------------------------------ #
+
+_PROTOCOL = "mcp-dashboard"
+_VERSION = 2
+
+
+def _envelope(msg_type: str, payload: dict[str, Any]) -> dict[str, Any]:
+    return {
+        "protocol": _PROTOCOL,
+        "version": _VERSION,
+        "type": msg_type,
+        "payload": payload,
+    }
+
+
+# ------------------------------------------------------------------ #
+#  AgentDescriptor                                                     #
+# ------------------------------------------------------------------ #
+
+
+@dataclass
+class AgentDescriptor:
+    """Lightweight descriptor for an agent visible to the dashboard."""
+
+    agent_id: str
+    name: str
+    role: str = ""
+    status: Literal["active", "paused", "completed", "failed"] = "active"
+    model: str = ""
+    provider: str = ""
+    session_id: str = ""
+    parent_agent_id: str | None = None
+    tool_count: int = 0
+    message_count: int = 0
+    created_at: str = ""
+
+
+# ------------------------------------------------------------------ #
+#  AgentRouter                                                         #
+# ------------------------------------------------------------------ #
+
+
+class AgentRouter:
+    """Routes dashboard messages between the server and one or more bridges."""
+
+    def __init__(self, server: DashboardServer) -> None:
+        self.server = server
+        self._bridges: dict[str, DashboardBridge] = {}
+        self._agent_descriptors: dict[str, AgentDescriptor] = {}
+        # Per-client focus: ws → agent_id
+        self._client_focus: dict[Any, str] = {}
+        # Per-client subscriptions: ws → set of agent_ids ("*" = all)
+        self._client_subscriptions: dict[Any, set[str]] = {}
+
+        # Own the three server callbacks
+        server.on_browser_message = self._on_browser_message
+        server.on_client_connected = self._on_client_connected
+        server.on_client_disconnected = self._on_client_disconnected
+
+    # ------------------------------------------------------------------ #
+    #  Properties                                                         #
+    # ------------------------------------------------------------------ #
+
+    @property
+    def has_clients(self) -> bool:
+        """Proxy to server.has_clients."""
+        return self.server.has_clients
+
+    @property
+    def _default_agent_id(self) -> str:
+        """First registered bridge id, fallback 'default'."""
+        if self._bridges:
+            return next(iter(self._bridges))
+        return "default"
+
+    # ------------------------------------------------------------------ #
+    #  Bridge registration                                                #
+    # ------------------------------------------------------------------ #
+
+    def register_agent(
+        self,
+        agent_id: str,
+        bridge: DashboardBridge,
+        descriptor: AgentDescriptor | None = None,
+    ) -> None:
+        """Register a bridge for the given agent_id."""
+        self._bridges[agent_id] = bridge
+        if descriptor is None:
+            descriptor = AgentDescriptor(agent_id=agent_id, name=agent_id)
+        self._agent_descriptors[agent_id] = descriptor
+        logger.debug("AgentRouter: registered agent %s", agent_id)
+        # Notify connected browsers
+        if self.server.has_clients:
+            try:
+                loop = asyncio.get_running_loop()
+                loop.create_task(self._broadcast_agent_registered(descriptor))
+            except RuntimeError:
+                pass  # no running loop yet
+
+    def unregister_agent(self, agent_id: str) -> None:
+        """Unregister a bridge for the given agent_id."""
+        self._bridges.pop(agent_id, None)
+        self._agent_descriptors.pop(agent_id, None)
+        # Re-focus clients that were focused on the removed agent
+        default_id = self._default_agent_id
+        for ws, focused_id in list(self._client_focus.items()):
+            if focused_id == agent_id:
+                self._client_focus[ws] = default_id
+        logger.debug("AgentRouter: unregistered agent %s", agent_id)
+        # Notify connected browsers
+        if self.server.has_clients:
+            try:
+                loop = asyncio.get_running_loop()
+                loop.create_task(self._broadcast_agent_unregistered(agent_id))
+            except RuntimeError:
+                pass
+
+    # ------------------------------------------------------------------ #
+    #  Agent status                                                       #
+    # ------------------------------------------------------------------ #
+
+    async def update_agent_status(self, agent_id: str, status: str) -> None:
+        """Update an agent's status and broadcast AGENT_STATUS."""
+        desc = self._agent_descriptors.get(agent_id)
+        if desc:
+            desc.status = status  # type: ignore[assignment]
+            await self.broadcast_global(
+                _envelope("AGENT_STATUS", {"agent_id": agent_id, "status": status})
+            )
+
+    # ------------------------------------------------------------------ #
+    #  Outbound (bridge → browser)                                        #
+    # ------------------------------------------------------------------ #
+
+    async def broadcast_from_agent(
+        self, agent_id: str, message: dict[str, Any]
+    ) -> None:
+        """Broadcast a message from a specific agent.
+
+        If no clients have subscriptions configured, broadcasts to all
+        (backward compat). Otherwise, only sends to clients subscribed
+        to this agent_id (or to ``"*"``).
+        """
+        if not self._client_subscriptions:
+            # No subscriptions configured — broadcast to all (default)
+            await self.server.broadcast(message)
+            return
+
+        for ws, subs in list(self._client_subscriptions.items()):
+            if "*" in subs or agent_id in subs:
+                try:
+                    await self.server.send_to_client(ws, message)
+                except Exception:
+                    pass  # client may have disconnected
+
+    async def broadcast_global(self, message: dict[str, Any]) -> None:
+        """Broadcast a message not scoped to any agent (e.g. AGENT_LIST)."""
+        await self.server.broadcast(message)
+
+    async def send_to_client(self, ws: Any, message: dict[str, Any]) -> None:
+        """Send a message to a specific WebSocket client."""
+        await self.server.send_to_client(ws, message)
+
+    # ------------------------------------------------------------------ #
+    #  Agent list helpers                                                  #
+    # ------------------------------------------------------------------ #
+
+    async def _send_agent_list(self, ws: Any) -> None:
+        """Send AGENT_LIST to a specific client."""
+        agents = [asdict(d) for d in self._agent_descriptors.values()]
+        await self.server.send_to_client(
+            ws, _envelope("AGENT_LIST", {"agents": agents})
+        )
+
+    async def _broadcast_agent_registered(self, desc: AgentDescriptor) -> None:
+        await self.broadcast_global(_envelope("AGENT_REGISTERED", asdict(desc)))
+
+    async def _broadcast_agent_unregistered(self, agent_id: str) -> None:
+        await self.broadcast_global(
+            _envelope("AGENT_UNREGISTERED", {"agent_id": agent_id})
+        )
+
+    # ------------------------------------------------------------------ #
+    #  Focus management                                                    #
+    # ------------------------------------------------------------------ #
+
+    async def _handle_focus_agent(self, msg: dict[str, Any], ws: Any) -> None:
+        """Browser client changed which agent it's viewing."""
+        agent_id = msg.get("agent_id") or self._default_agent_id
+        if ws is None:
+            return
+        self._client_focus[ws] = agent_id
+        logger.debug("AgentRouter: client focused on %s", agent_id)
+        # Replay focused agent's state to this client only
+        bridge = self._bridges.get(agent_id)
+        if bridge:
+            await bridge._on_client_connected(ws)
+
+    def _handle_subscribe(self, msg: dict[str, Any], ws: Any) -> None:
+        """Handle a SUBSCRIBE message from a browser client."""
+        if ws is None:
+            return
+        agents = msg.get("agents", [])
+        is_global = msg.get("global", False)
+        subs: set[str] = set(agents)
+        if is_global:
+            subs.add("*")
+        self._client_subscriptions[ws] = subs
+        logger.debug("AgentRouter: client subscribed to %s", subs)
+
+    async def _handle_agent_message(self, msg: dict[str, Any]) -> None:
+        """Route an AGENT_MESSAGE from browser to target agent's bridge."""
+        to_agent = msg.get("to_agent")
+        content = msg.get("content", "")
+        from_agent = msg.get("from_agent", "browser")
+        if not to_agent:
+            return
+        bridge = self._bridges.get(to_agent)
+        if bridge:
+            # Inject as a user message annotated with source
+            await bridge._on_browser_message(
+                {"type": "USER_MESSAGE", "content": f"[From {from_agent}]: {content}"}
+            )
+
+    # ------------------------------------------------------------------ #
+    #  Inbound callbacks (browser → bridge)                               #
+    # ------------------------------------------------------------------ #
+
+    async def _on_browser_message(self, msg: dict[str, Any], ws: Any = None) -> None:
+        """Route an inbound browser message to the appropriate bridge."""
+        msg_type = msg.get("type")
+
+        # Handle router-level message types
+        if msg_type == "FOCUS_AGENT":
+            await self._handle_focus_agent(msg, ws)
+            return
+        if msg_type == "REQUEST_AGENT_LIST":
+            if ws is not None:
+                await self._send_agent_list(ws)
+            return
+        if msg_type == "AGENT_MESSAGE":
+            await self._handle_agent_message(msg)
+            return
+        if msg_type == "SUBSCRIBE":
+            self._handle_subscribe(msg, ws)
+            return
+
+        # Route to bridge: explicit agent_id > client focus > sole bridge
+        target_id = msg.get("agent_id")
+        bridge: DashboardBridge | None = None
+
+        if target_id and target_id in self._bridges:
+            bridge = self._bridges[target_id]
+        elif ws is not None and ws in self._client_focus:
+            target_id = self._client_focus[ws]
+            bridge = self._bridges.get(target_id)
+        elif len(self._bridges) == 1:
+            bridge = next(iter(self._bridges.values()))
+        elif target_id:
+            logger.debug(
+                "AgentRouter: unknown agent_id %r in browser message", target_id
+            )
+            return
+        else:
+            logger.debug(
+                "AgentRouter: no agent_id in message and %d bridges registered",
+                len(self._bridges),
+            )
+            return
+
+        if bridge is not None:
+            await bridge._on_browser_message(msg)
+
+    async def _on_client_connected(self, ws: Any) -> None:
+        """Send agent list and replay focused agent state to a new client."""
+        # Send AGENT_LIST first
+        await self._send_agent_list(ws)
+        # Default focus: first registered agent
+        default_id = self._default_agent_id
+        self._client_focus[ws] = default_id
+        # Default subscription: all agents
+        self._client_subscriptions[ws] = {"*"}
+        # Replay only the focused agent's state
+        bridge = self._bridges.get(default_id)
+        if bridge:
+            await bridge._on_client_connected(ws)
+
+    async def _on_client_disconnected(self, ws: Any = None) -> None:
+        """Notify all registered bridges and clean up per-client state."""
+        for bridge in self._bridges.values():
+            await bridge.on_client_disconnected()
+        # Clean up per-client tracking for the disconnected ws
+        if ws is not None:
+            self._client_focus.pop(ws, None)
+            self._client_subscriptions.pop(ws, None)
diff --git a/src/mcp_cli/dashboard/server.py b/src/mcp_cli/dashboard/server.py
index 2be02f84..3746ad11 100644
--- a/src/mcp_cli/dashboard/server.py
+++ b/src/mcp_cli/dashboard/server.py
@@ -15,6 +15,7 @@
 
 import asyncio
 import http
+import inspect
 import json
 import logging
 import mimetypes
@@ -43,9 +44,20 @@ def __init__(self) -> None:
         self._clients: set[ServerConnection] = set()
         self._server: Any = None
         # Called when a browser user sends USER_MESSAGE / USER_ACTION / REQUEST_TOOL
-        self.on_browser_message: Callable[[dict[str, Any]], Any] | None = None
+        self.on_browser_message: Callable[..., Any] | None = None
         # Called when a new WebSocket client connects (before message loop starts)
         self.on_client_connected: Callable[[Any], Any] | None = None
+        # Called when a WebSocket client disconnects (receives ws)
+        self.on_client_disconnected: Callable[..., Any] | None = None
+        # Cached arity of on_browser_message callback (None = not yet checked)
+        self._browser_msg_arity: int | None = None
+        # Track callback identity for arity cache invalidation
+        self._browser_msg_cb_id: int | None = None
+
+    @property
+    def has_clients(self) -> bool:
+        """Return True if at least one browser client is connected."""
+        return bool(self._clients)
 
     # ------------------------------------------------------------------ #
     #  Public API                                                          #
@@ -60,6 +72,7 @@ async def start(self, port: int = 0) -> int:
             "localhost",
             bound_port,
             process_request=self._process_request,
+            max_size=25 * 1024 * 1024,  # 25 MB for file attachments
         )
         logger.info("Dashboard server started on port %d", bound_port)
         return bound_port
@@ -89,6 +102,16 @@ async def broadcast(self, msg: dict[str, Any]) -> None:
         for c in dead:
             self._clients.discard(c)
 
+    async def send_to_client(self, ws: ServerConnection, msg: dict[str, Any]) -> None:
+        """Send a JSON message to a specific WebSocket client.
+
+        Discards the client from the active set if the send fails.
+        """
+        try:
+            await ws.send(json.dumps(msg))
+        except Exception:
+            self._clients.discard(ws)
+
     # ------------------------------------------------------------------ #
     #  WebSocket handler                                                  #
     # ------------------------------------------------------------------ #
@@ -108,7 +131,7 @@ async def _ws_handler(self, ws: ServerConnection) -> None:
         try:
             async for raw in ws:
                 if isinstance(raw, str):
-                    await self._handle_browser_message(raw)
+                    await self._handle_browser_message(raw, ws)
         except websockets.ConnectionClosed:
             pass
         finally:
@@ -117,8 +140,17 @@ async def _ws_handler(self, ws: ServerConnection) -> None:
                 "Dashboard WebSocket client disconnected (%d remain)",
                 len(self._clients),
             )
+            if self.on_client_disconnected is not None:
+                try:
+                    result = self.on_client_disconnected(ws)
+                    if asyncio.iscoroutine(result):
+                        await result
+                except Exception as exc:
+                    logger.debug("Error in client disconnected callback: %s", exc)
 
-    async def _handle_browser_message(self, raw: str) -> None:
+    async def _handle_browser_message(
+        self, raw: str, ws: ServerConnection | None = None
+    ) -> None:
         try:
             msg = json.loads(raw)
         except json.JSONDecodeError:
@@ -126,7 +158,19 @@ async def _handle_browser_message(self, raw: str) -> None:
             return
         if self.on_browser_message:
             try:
-                result = self.on_browser_message(msg)
+                # Detect callback arity: 2-arg (msg, ws) vs 1-arg (msg)
+                cb_id = id(self.on_browser_message)
+                if self._browser_msg_arity is None or self._browser_msg_cb_id != cb_id:
+                    self._browser_msg_cb_id = cb_id
+                    try:
+                        sig = inspect.signature(self.on_browser_message)
+                        self._browser_msg_arity = len(sig.parameters)
+                    except (ValueError, TypeError):
+                        self._browser_msg_arity = 1
+                if self._browser_msg_arity >= 2 and ws is not None:
+                    result = self.on_browser_message(msg, ws)
+                else:
+                    result = self.on_browser_message(msg)
                 if asyncio.iscoroutine(result):
                     await result
             except Exception as exc:
diff --git a/src/mcp_cli/dashboard/static/shell.html b/src/mcp_cli/dashboard/static/shell.html
index 2065cf18..be278448 100644
--- a/src/mcp_cli/dashboard/static/shell.html
+++ b/src/mcp_cli/dashboard/static/shell.html
@@ -108,12 +108,40 @@
 .dropdown-item:hover { background: var(--dash-bg-hover); }
 .dropdown-item.active { color: var(--dash-accent); }
 
+/* Toolbar selects (model/provider) */
+.tb-select {
+  background: var(--dash-bg);
+  border: 1px solid var(--dash-border);
+  color: var(--dash-fg);
+  padding: 2px 6px;
+  border-radius: var(--dash-radius);
+  font-size: 11px;
+  font-family: var(--dash-font-ui);
+  cursor: pointer;
+  max-width: 140px;
+  outline: none;
+}
+.tb-select:hover { border-color: var(--dash-accent); }
+.tb-label {
+  font-size: 10px;
+  color: var(--dash-fg-muted);
+  text-transform: uppercase;
+  letter-spacing: .04em;
+}
+.tb-group {
+  display: flex;
+  align-items: center;
+  gap: 4px;
+}
+
 /* Settings panel */
 #settings-panel {
   display: none;
   position: fixed;
   top: 40px; right: 8px;
-  width: 260px;
+  width: 320px;
+  max-height: calc(100vh - 56px);
+  overflow-y: auto;
   background: var(--dash-bg-surface);
   border: 1px solid var(--dash-border);
   border-radius: var(--dash-radius);
@@ -125,14 +153,104 @@
 #settings-panel h3 { font-size: 12px; font-weight: 600; margin-bottom: 8px; color: var(--dash-fg-muted); text-transform: uppercase; letter-spacing: .05em; }
 #settings-panel label { font-size: 12px; display: block; margin-bottom: 4px; }
 #settings-panel select { width: 100%; padding: 4px 6px; background: var(--dash-bg); border: 1px solid var(--dash-border); border-radius: var(--dash-radius); color: var(--dash-fg); font-size: 12px; }
+#settings-panel .section { margin-bottom: 12px; padding-bottom: 12px; border-bottom: 1px solid var(--dash-border); }
+#settings-panel .section:last-child { border-bottom: none; margin-bottom: 0; padding-bottom: 0; }
+#settings-panel textarea {
+  width: 100%; padding: 6px 8px; background: var(--dash-bg); border: 1px solid var(--dash-border);
+  border-radius: var(--dash-radius); color: var(--dash-fg); font-family: var(--dash-font-mono);
+  font-size: 11px; line-height: 1.4; resize: vertical; min-height: 80px; max-height: 300px;
+}
+#settings-panel textarea:focus { border-color: var(--dash-accent); outline: none; }
+#settings-panel .btn-row { display: flex; gap: 6px; margin-top: 6px; }
+#settings-panel .btn-sm {
+  background: transparent; border: 1px solid var(--dash-border); color: var(--dash-fg);
+  padding: 3px 10px; border-radius: var(--dash-radius); cursor: pointer; font-size: 11px;
+  font-family: var(--dash-font-ui);
+}
+#settings-panel .btn-sm:hover { background: var(--dash-bg-hover); }
+#settings-panel .btn-sm.primary { background: var(--dash-accent); color: var(--dash-bg); border-color: var(--dash-accent); }
+#settings-panel .btn-sm.primary:hover { opacity: 0.9; }
+.server-list { list-style: none; padding: 0; margin: 4px 0 0 0; }
+.server-item {
+  display: flex; align-items: center; gap: 6px; padding: 4px 0;
+  font-size: 12px; border-bottom: 1px solid var(--dash-border);
+}
+.server-item:last-child { border-bottom: none; }
+.server-dot { width: 6px; height: 6px; border-radius: 50%; flex-shrink: 0; }
+.server-dot.on { background: var(--dash-success); }
+.server-dot.off { background: var(--dash-error); }
+.server-name { flex: 1; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+.server-tools { font-size: 10px; color: var(--dash-fg-muted); }
+
+/* ── Session drawer ────────────────────────────────────────────── */
+#session-drawer {
+  display: none;
+  position: fixed;
+  top: 40px; left: 8px;
+  width: 300px;
+  max-height: calc(100vh - 56px);
+  overflow-y: auto;
+  background: var(--dash-bg-surface);
+  border: 1px solid var(--dash-border);
+  border-radius: var(--dash-radius);
+  z-index: 200;
+  padding: 12px;
+  box-shadow: 0 4px 16px rgba(0,0,0,0.5);
+}
+#session-drawer.open { display: block; }
+#session-drawer h3 {
+  font-size: 12px; font-weight: 600; margin-bottom: 8px;
+  color: var(--dash-fg-muted); text-transform: uppercase; letter-spacing: .05em;
+  display: flex; align-items: center; justify-content: space-between;
+}
+.session-list { list-style: none; padding: 0; margin: 0; }
+.session-item {
+  display: flex; align-items: center; gap: 6px; padding: 8px 6px;
+  font-size: 12px; border-bottom: 1px solid var(--dash-border);
+  cursor: pointer; border-radius: var(--dash-radius); transition: background 0.15s;
+}
+.session-item:last-child { border-bottom: none; }
+.session-item:hover { background: var(--dash-bg-hover); }
+.session-item.active { background: var(--dash-bg-hover); border-left: 2px solid var(--dash-accent); }
+.session-info { flex: 1; min-width: 0; }
+.session-id { font-family: var(--dash-font-mono); font-size: 11px; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+.session-desc { font-size: 10px; color: var(--dash-fg-muted); overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+.session-meta { font-size: 10px; color: var(--dash-fg-muted); display: flex; gap: 8px; margin-top: 2px; }
+.session-actions { display: flex; gap: 4px; flex-shrink: 0; }
+.session-actions button {
+  background: transparent; border: none; color: var(--dash-fg-muted);
+  cursor: pointer; font-size: 11px; padding: 2px 4px; border-radius: 3px;
+}
+.session-actions button:hover { color: var(--dash-fg); background: var(--dash-bg-hover); }
+.session-actions button.delete:hover { color: var(--dash-error); }
+.session-empty { color: var(--dash-fg-muted); font-size: 12px; text-align: center; padding: 16px 0; }
 
 /* ── Grid layout ────────────────────────────────────────────────── */
-#grid-root {
+#grid-wrapper {
   flex: 1;
+  position: relative;
+  overflow: hidden;
+  min-height: 0;
+}
+#grid-root {
+  position: absolute;
+  top: 0; left: 0; right: 0; bottom: 0;
   display: flex;
   flex-direction: column;
   overflow: hidden;
-  position: relative;
+}
+#view-overlay {
+  position: absolute;
+  top: 0; left: 0; right: 0; bottom: 0;
+  pointer-events: none;
+  z-index: 5;
+  overflow: hidden;
+}
+#view-overlay iframe {
+  position: absolute;
+  pointer-events: auto;
+  border: none;
+  display: none;
 }
 .grid-row {
   display: flex;
@@ -207,18 +325,12 @@
 }
 .panel-btn:hover { background: var(--dash-bg-hover); color: var(--dash-fg); }
 
-/* Panel body */
+/* Panel body (empty slot — iframes are positioned over it from #view-overlay) */
 .panel-body {
   flex: 1;
   overflow: hidden;
   position: relative;
 }
-.panel-body iframe {
-  width: 100%;
-  height: 100%;
-  border: none;
-  display: block;
-}
 
 /* Panel placeholder */
 .panel-placeholder {
@@ -278,32 +390,149 @@
 .toast.error { border-left: 3px solid var(--dash-error); }
 @keyframes slideIn { from { opacity:0; transform:translateY(8px); } to { opacity:1; transform:translateY(0); } }
 
+/* Tool approval dialog */
+#approval-overlay {
+  display: none;
+  position: fixed;
+  top: 0; left: 0; right: 0; bottom: 0;
+  background: rgba(0,0,0,0.5);
+  z-index: 600;
+  align-items: center;
+  justify-content: center;
+}
+#approval-overlay.open { display: flex; }
+#approval-dialog {
+  background: var(--dash-bg-surface);
+  border: 1px solid var(--dash-border);
+  border-radius: var(--dash-radius);
+  padding: 16px;
+  max-width: 500px;
+  width: 90%;
+  box-shadow: 0 4px 24px rgba(0,0,0,0.5);
+}
+#approval-dialog h3 {
+  font-size: 14px;
+  color: var(--dash-warning);
+  margin-bottom: 8px;
+}
+#approval-dialog .approval-tool {
+  font-family: var(--dash-font-mono);
+  font-size: 13px;
+  color: var(--dash-accent);
+  margin-bottom: 8px;
+}
+#approval-dialog .approval-args {
+  background: var(--dash-bg);
+  border: 1px solid var(--dash-border);
+  border-radius: var(--dash-radius);
+  padding: 8px;
+  font-family: var(--dash-font-mono);
+  font-size: 11px;
+  color: var(--dash-fg-muted);
+  max-height: 200px;
+  overflow-y: auto;
+  white-space: pre-wrap;
+  word-break: break-all;
+  margin-bottom: 12px;
+}
+#approval-dialog .approval-btns {
+  display: flex;
+  gap: 8px;
+  justify-content: flex-end;
+}
+#approval-dialog .approval-btns button {
+  padding: 6px 16px;
+  border-radius: var(--dash-radius);
+  border: 1px solid var(--dash-border);
+  cursor: pointer;
+  font-size: 12px;
+  font-family: var(--dash-font-ui);
+}
+#approval-dialog .btn-approve {
+  background: var(--dash-success);
+  color: var(--dash-bg);
+  border-color: var(--dash-success);
+}
+#approval-dialog .btn-deny {
+  background: transparent;
+  color: var(--dash-error);
+  border-color: var(--dash-error);
+}
+#approval-dialog .btn-approve:hover { opacity: 0.9; }
+#approval-dialog .btn-deny:hover { background: var(--dash-bg-hover); }
+
 /* ── Responsive: stack panels vertically below 768px ─────────────── */
 @media (max-width: 768px) {
+  #toolbar { flex-wrap: wrap; height: auto; min-height: 36px; padding: 4px 8px; gap: 6px; }
+  #toolbar .spacer { display: none; }
+  #model-group { order: 10; width: 100%; justify-content: center; }
   .grid-row { flex-direction: column; }
   .panel { min-width: unset; min-height: 150px; }
   .panel + .panel { border-left: none; border-top: 1px solid var(--dash-border); }
   .resize-handle-col { display: none; }
+  #settings-panel { width: 100%; right: 0; left: 0; top: auto; bottom: 0; max-height: 60vh; border-radius: var(--dash-radius) var(--dash-radius) 0 0; }
+  #session-drawer { width: 100%; right: 0; left: 0; top: auto; bottom: 0; max-height: 60vh; border-radius: var(--dash-radius) var(--dash-radius) 0 0; }
+  #approval-dialog { max-width: 95%; }
+  .toast { max-width: 90vw; }
 }
 
-/* ── View stash: keeps iframes in document to preserve state ──────── */
-#view-stash {
-  position: fixed;
-  left: -10000px;
-  top: -10000px;
-  width: 1px;
-  height: 1px;
-  overflow: hidden;
-  opacity: 0;
-  pointer-events: none;
+@media (max-width: 480px) {
+  #toolbar .brand span:last-child { display: none; }
+  .tb-select { max-width: 100px; font-size: 10px; }
+  .tb-btn { font-size: 11px; padding: 2px 6px; }
 }
+
+/* ── Agent tab bar ─────────────────────────────────────────────── */
+#agent-tabs {
+  display: none;
+  align-items: center;
+  gap: 4px;
+  padding: 0 12px;
+  height: 28px;
+  min-height: 28px;
+  background: var(--dash-bg);
+  border-bottom: 1px solid var(--dash-border);
+  flex-shrink: 0;
+  user-select: none;
+  overflow-x: auto;
+}
+#agent-tabs.visible { display: flex; }
+.agent-tab {
+  display: inline-flex;
+  align-items: center;
+  gap: 5px;
+  padding: 3px 10px;
+  border: 1px solid transparent;
+  border-radius: var(--dash-radius);
+  background: transparent;
+  color: var(--dash-fg-muted);
+  font-size: 11px;
+  font-family: var(--dash-font-ui);
+  cursor: pointer;
+  white-space: nowrap;
+  transition: background 0.15s, color 0.15s, border-color 0.15s;
+}
+.agent-tab:hover { background: var(--dash-bg-hover); color: var(--dash-fg); }
+.agent-tab.focused {
+  background: var(--dash-bg-surface);
+  color: var(--dash-fg);
+  border-color: var(--dash-accent);
+}
+.agent-tab-indicator {
+  width: 6px; height: 6px;
+  border-radius: 50%;
+  flex-shrink: 0;
+}
+.agent-tab-indicator.active    { background: var(--dash-success); }
+.agent-tab-indicator.paused    { background: var(--dash-warning); }
+.agent-tab-indicator.completed { background: var(--dash-fg-muted); }
+.agent-tab-indicator.failed    { background: var(--dash-error); }
+
+/* (view-stash removed — iframes now live permanently in #view-overlay) */
 </style>
 </head>
 <body>
 
-<!-- ── View stash: iframes park here between layout changes ─────── -->
-<div id="view-stash" aria-hidden="true"></div>
-
 <!-- ── Toolbar ──────────────────────────────────────────────────── -->
 <div id="toolbar">
   <div class="brand">
@@ -311,6 +540,9 @@
     <span>mcp-cli dashboard</span>
   </div>
 
+  <button class="tb-btn" id="new-session-btn" title="New chat session">+</button>
+  <button class="tb-btn" id="sessions-btn" title="Session history">Sessions</button>
+
   <div class="dropdown" id="layout-dropdown">
     <button class="tb-btn" id="layout-btn">Layout ▾</button>
     <div class="dropdown-menu" id="layout-menu"></div>
@@ -323,20 +555,89 @@
 
   <div class="spacer"></div>
 
+  <div class="tb-group" id="model-group" style="display:none">
+    <span class="tb-label">Provider</span>
+    <select class="tb-select" id="provider-select"></select>
+    <span class="tb-label">Model</span>
+    <select class="tb-select" id="model-select"></select>
+  </div>
+
+  <div class="dropdown" id="export-dropdown">
+    <button class="tb-btn" id="export-btn">Export ▾</button>
+    <div class="dropdown-menu" id="export-menu">
+      <div class="dropdown-item" data-format="markdown">Export as Markdown</div>
+      <div class="dropdown-item" data-format="json">Export as JSON</div>
+    </div>
+  </div>
+
   <button class="tb-btn" id="settings-btn">⚙</button>
 </div>
 
+<!-- ── Agent tab bar (hidden when ≤1 agent) ─────────────────────── -->
+<div id="agent-tabs"></div>
+
 <!-- ── Settings panel ───────────────────────────────────────────── -->
 <div id="settings-panel">
-  <h3>Settings</h3>
-  <label for="theme-select">Theme</label>
-  <select id="theme-select"></select>
-  <br>
-  <button class="tb-btn" style="margin-top:8px;width:100%" id="save-layout-btn">Save Current Layout…</button>
+  <div class="section">
+    <h3>Theme</h3>
+    <select id="theme-select"></select>
+  </div>
+
+  <div class="section">
+    <h3>System Prompt</h3>
+    <textarea id="system-prompt-editor" placeholder="Loading..."></textarea>
+    <div class="btn-row">
+      <button class="btn-sm primary" id="apply-prompt-btn">Apply</button>
+      <button class="btn-sm" id="reset-prompt-btn">Reset to Default</button>
+    </div>
+  </div>
+
+  <div class="section">
+    <h3>MCP Servers</h3>
+    <ul class="server-list" id="server-list">
+      <li style="font-size:12px;color:var(--dash-fg-muted)">No servers connected</li>
+    </ul>
+  </div>
+
+  <div class="section">
+    <button class="btn-sm" style="width:100%" id="save-layout-btn">Save Current Layout</button>
+  </div>
+
+  <div class="section">
+    <h3>Conversation</h3>
+    <button class="btn-sm" style="width:100%;color:var(--dash-error);border-color:var(--dash-error)" id="clear-history-btn">Clear Chat History</button>
+  </div>
+</div>
+
+<!-- ── Session drawer ──────────────────────────────────────────── -->
+<div id="session-drawer">
+  <h3>
+    <span>Sessions</span>
+    <button class="btn-sm" id="refresh-sessions-btn" style="font-size:10px;padding:2px 6px">Refresh</button>
+  </h3>
+  <ul class="session-list" id="session-list">
+    <li class="session-empty">Loading sessions...</li>
+  </ul>
+</div>
+
+<!-- ── Grid wrapper: grid-root for panel layout, view-overlay for iframes ── -->
+<div id="grid-wrapper">
+  <div id="grid-root"></div>
+  <div id="view-overlay"></div>
 </div>
 
-<!-- ── Grid root ────────────────────────────────────────────────── -->
-<div id="grid-root"></div>
+<!-- ── Tool approval dialog ─────────────────────────────────────── -->
+<div id="approval-overlay">
+  <div id="approval-dialog">
+    <h3>Tool Confirmation Required</h3>
+    <div class="approval-tool" id="approval-tool-name"></div>
+    <div class="approval-args" id="approval-args"></div>
+    <div class="approval-btns">
+      <button class="btn-deny" id="approval-deny">Deny</button>
+      <button class="btn-approve" id="approval-approve">Approve</button>
+    </div>
+  </div>
+</div>
 
 <!-- ── Toast container ──────────────────────────────────────────── -->
 <div id="toast-container"></div>
@@ -366,21 +667,47 @@ <h3>Settings</h3>
 const viewPool      = new Map(); // viewId → { iframe, ready, accepts, _readyTimeout }
 const popoutWindows = new Map(); // viewId → { win, intervalId }
 
+// Multi-agent state
+let agentList       = [];        // array of agent descriptors from AGENT_LIST
+let focusedAgentId  = null;      // currently focused agent id
+const AGENT_COLORS  = ['#7aa2f7','#9ece6a','#e0af68','#f7768e','#7dcfff','#bb9af7','#ff9e64','#73daca'];
+const agentColorMap = new Map(); // agent_id → stable color
+
 // ================================================================
-//  WebSocket
+//  WebSocket (exponential backoff reconnect)
 // ================================================================
+let _wsBackoff = 1000;         // current backoff delay (ms)
+const _WS_BACKOFF_MAX = 30000; // cap at 30 s
+let _wsReconnectTimer = null;
+
 function connectWS() {
+  if (_wsReconnectTimer) { clearTimeout(_wsReconnectTimer); _wsReconnectTimer = null; }
+  // Close existing connection before creating a new one
+  if (ws) { try { ws.onclose = null; ws.close(); } catch(e) {} ws = null; }
   ws = new WebSocket(WS_URL);
 
   ws.onopen = () => {
     connected = true;
+    _wsBackoff = 1000; // reset on success
     document.getElementById('conn-dot').classList.add('connected');
+    showToast('success', 'Connected to dashboard server', 2000);
+    // Request agent list (router will send AGENT_LIST)
+    sendToBridge({ type: 'REQUEST_AGENT_LIST' });
+    // Request current config (model, servers, system prompt)
+    sendToBridge({ type: 'REQUEST_CONFIG' });
+    // Request tool registry
+    sendToBridge({ type: 'REQUEST_TOOLS' });
   };
 
   ws.onclose = () => {
+    const wasConnected = connected;
     connected = false;
     document.getElementById('conn-dot').classList.remove('connected');
-    setTimeout(connectWS, 5000);
+    if (wasConnected) showToast('warning', `Disconnected — reconnecting in ${Math.round(_wsBackoff/1000)}s…`, _wsBackoff);
+    _wsReconnectTimer = setTimeout(() => {
+      _wsBackoff = Math.min(_wsBackoff * 2, _WS_BACKOFF_MAX);
+      connectWS();
+    }, _wsBackoff);
   };
 
   ws.onerror = () => {
@@ -400,30 +727,173 @@ <h3>Settings</h3>
   }
 }
 
+// ================================================================
+//  Multi-agent helpers
+// ================================================================
+function agentColor(agentId) {
+  if (!agentColorMap.has(agentId)) {
+    agentColorMap.set(agentId, AGENT_COLORS[agentColorMap.size % AGENT_COLORS.length]);
+  }
+  return agentColorMap.get(agentId);
+}
+
+function renderAgentTabs() {
+  const bar = document.getElementById('agent-tabs');
+  bar.innerHTML = '';
+  if (agentList.length <= 1) { bar.classList.remove('visible'); return; }
+  bar.classList.add('visible');
+  for (const agent of agentList) {
+    const btn = document.createElement('button');
+    btn.className = 'agent-tab' + (agent.agent_id === focusedAgentId ? ' focused' : '');
+    const dot = document.createElement('span');
+    dot.className = 'agent-tab-indicator ' + (agent.status || 'active');
+    btn.appendChild(dot);
+    const label = document.createElement('span');
+    label.textContent = agent.name || agent.agent_id;
+    btn.appendChild(label);
+    btn.addEventListener('click', () => focusAgent(agent.agent_id));
+    bar.appendChild(btn);
+  }
+}
+
+function focusAgent(agentId) {
+  if (agentId === focusedAgentId) return;
+  focusedAgentId = agentId;
+  renderAgentTabs();
+  sendToBridge({ type: 'FOCUS_AGENT', agent_id: agentId });
+  // Update subscription to include focused agent + global
+  sendToBridge({ type: 'SUBSCRIBE', agents: [agentId], global: true });
+}
+
+function handleAgentList(payload) {
+  agentList = payload.agents || [];
+  if (!focusedAgentId && agentList.length > 0) {
+    focusedAgentId = agentList[0].agent_id;
+  }
+  renderAgentTabs();
+}
+
+function handleAgentRegistered(payload) {
+  const existing = agentList.find(a => a.agent_id === payload.agent_id);
+  if (!existing) agentList.push(payload);
+  if (!focusedAgentId && agentList.length > 0) {
+    focusedAgentId = agentList[0].agent_id;
+  }
+  renderAgentTabs();
+}
+
+function handleAgentUnregistered(payload) {
+  agentList = agentList.filter(a => a.agent_id !== payload.agent_id);
+  if (focusedAgentId === payload.agent_id) {
+    focusedAgentId = agentList.length > 0 ? agentList[0].agent_id : null;
+  }
+  renderAgentTabs();
+}
+
+function handleAgentStatus(payload) {
+  const agent = agentList.find(a => a.agent_id === payload.agent_id);
+  if (agent) agent.status = payload.status;
+  renderAgentTabs();
+}
+
+function isMultiAgent() { return agentList.length > 1; }
+function isFocusedAgent(msg) {
+  if (!isMultiAgent()) return true;
+  const aid = (msg.payload && msg.payload.agent_id) || msg.agent_id;
+  return !aid || aid === focusedAgentId;
+}
+
 // ================================================================
 //  Bridge message routing
 // ================================================================
+// Cached payloads for replaying to late-loading views
+let _cachedToolRegistry = null;
+let _cachedPlanUpdate = null;
+
 function handleBridgeMessage(msg) {
   switch (msg.type) {
     case 'VIEW_REGISTRY':
-      viewRegistry = msg.views || [];
+      // Merge dynamic views from bridge without clobbering builtins
+      // Envelope format: msg.payload.views; legacy format: msg.views
+      mergeViewRegistry((msg.payload && msg.payload.views) || msg.views || []);
       rebuildAddPanelMenu();
       break;
 
+    // ── Agent lifecycle messages ───────────────────────────────
+    case 'AGENT_LIST':
+      handleAgentList(msg.payload);
+      broadcastToViewType('agents', 'AGENT_LIST', msg.payload);
+      break;
+
+    case 'AGENT_REGISTERED':
+      handleAgentRegistered(msg.payload);
+      broadcastToViewType('agents', 'AGENT_REGISTERED', msg.payload);
+      break;
+
+    case 'AGENT_UNREGISTERED':
+      handleAgentUnregistered(msg.payload);
+      broadcastToViewType('agents', 'AGENT_UNREGISTERED', msg.payload);
+      break;
+
+    case 'AGENT_STATUS':
+      handleAgentStatus(msg.payload);
+      broadcastToViewType('agents', 'AGENT_STATUS', msg.payload);
+      break;
+
+    // ── Agent-scoped messages ────────────────────────────────
     case 'TOOL_RESULT':
-      routeToViews('TOOL_RESULT', msg.payload);
+      sendToActivityStream('TOOL_RESULT', msg.payload);
+      if (isFocusedAgent(msg)) routeToViews('TOOL_RESULT', msg.payload);
       break;
 
     case 'AGENT_STATE':
-      broadcastToViews('AGENT_STATE', msg.payload);
+      if (isFocusedAgent(msg)) broadcastToViews('AGENT_STATE', msg.payload);
+      broadcastToViewType('agents', 'AGENT_STATE', msg.payload);
       break;
 
     case 'CONVERSATION_MESSAGE':
-      broadcastToViewType('conversation', 'CONVERSATION_MESSAGE', msg.payload);
+      sendToActivityStream('CONVERSATION_MESSAGE', msg.payload);
+      if (isFocusedAgent(msg)) broadcastToViewType('conversation', 'CONVERSATION_MESSAGE', msg.payload);
       break;
 
     case 'CONVERSATION_TOKEN':
-      broadcastToViewType('conversation', 'CONVERSATION_TOKEN', msg.payload);
+      if (isFocusedAgent(msg)) broadcastToViewType('conversation', 'CONVERSATION_TOKEN', msg.payload);
+      break;
+
+    case 'CONVERSATION_HISTORY':
+      if (isFocusedAgent(msg)) broadcastToViewType('conversation', 'CONVERSATION_HISTORY', msg.payload);
+      break;
+
+    case 'ACTIVITY_HISTORY':
+      sendToActivityStream('ACTIVITY_HISTORY', msg.payload);
+      break;
+
+    case 'CONFIG_STATE':
+      handleConfigState(msg.payload);
+      broadcastToViews('CONFIG_STATE', msg.payload);
+      break;
+
+    case 'TOOL_REGISTRY':
+      _cachedToolRegistry = msg.payload;
+      broadcastToViewType('tools', 'TOOL_REGISTRY', msg.payload);
+      break;
+
+    case 'TOOL_APPROVAL_REQUEST':
+      handleToolApprovalRequest(msg.payload);
+      break;
+
+    case 'PLAN_UPDATE':
+      _cachedPlanUpdate = msg.payload;
+      broadcastToViewType('plan', 'PLAN_UPDATE', msg.payload);
+      sendToActivityStream('PLAN_UPDATE', msg.payload);
+      break;
+
+    case 'SESSION_STATE':
+      handleSessionState(msg.payload);
+      break;
+
+    case 'SESSION_LIST':
+      handleSessionList(msg.payload);
       break;
 
     case 'THEME':
@@ -438,11 +908,23 @@ <h3>Settings</h3>
 // ================================================================
 //  View Pool — iframes persist across layout changes
 // ================================================================
+function mergeViewRegistry(dynamicViews) {
+  // Keep builtins, add/update dynamic views
+  const builtinIds = new Set(viewRegistry.filter(v => v.source === 'builtin').map(v => v.id));
+  const merged = viewRegistry.filter(v => v.source === 'builtin');
+  for (const v of dynamicViews) {
+    if (!builtinIds.has(v.id)) merged.push(v);
+  }
+  viewRegistry = merged;
+}
+
 function srcForView(viewId) {
   const vInfo = viewRegistry.find(v => v.id === viewId);
   if (vInfo && vInfo.url) return vInfo.url;
   if (viewId === 'builtin:agent-terminal') return '/views/agent-terminal.html';
   if (viewId === 'builtin:activity-stream') return '/views/activity-stream.html';
+  if (viewId === 'builtin:tool-browser')    return '/views/tool-browser.html';
+  if (viewId === 'builtin:plan-viewer')     return '/views/plan-viewer.html';
   return '';
 }
 
@@ -452,22 +934,23 @@ <h3>Settings</h3>
   const iframe = document.createElement('iframe');
   iframe.sandbox = 'allow-scripts allow-same-origin allow-forms';
   iframe.allow = '';
-  iframe.style.cssText = 'width:100%;height:100%;border:none;display:block;';
   iframe.src = srcForView(viewId);
   iframe.dataset.viewId = viewId;
   view.iframe = iframe;
   viewPool.set(viewId, view);
-  // Park in stash immediately — iframe must stay in document to preserve browsing context
-  document.getElementById('view-stash').appendChild(iframe);
+  // Append to view-overlay — iframes NEVER move between parents (reparenting
+  // destroys browsing context in all modern browsers).  They stay here
+  // permanently and are positioned over panel body slots via syncViewPositions().
+  document.getElementById('view-overlay').appendChild(iframe);
   return view;
 }
 
-function attachViewToSlot(viewId, bodyEl) {
+function attachViewToSlot(viewId) {
   if (!viewId) return;
   const view = getOrCreateView(viewId);
-  // Detach from any current parent without destroying the iframe
-  if (view.iframe.parentNode) view.iframe.parentNode.removeChild(view.iframe);
-  bodyEl.appendChild(view.iframe);
+  // No reparenting — iframe stays in #view-overlay.
+  // syncViewPositions() will position it over the panel body.
+  requestAnimationFrame(() => syncViewPositions());
   // Start ready timeout only for first load
   if (!view.ready && !view._readyTimeout) {
     view._readyTimeout = setTimeout(() => {
@@ -505,7 +988,7 @@ <h3>Settings</h3>
   postToIframe(view.iframe, 'INIT', {
     view_id: viewId,
     panel_id: panel.panelId,
-    agent_id: null,
+    agent_id: focusedAgentId,
     theme: themeToCSS(themeObj),
     dimensions: dims,
   });
@@ -521,16 +1004,13 @@ <h3>Settings</h3>
 function switchPanelView(panelId, newViewId) {
   const panel = panels[panelId];
   if (!panel || panel.viewId === newViewId) return;
-  const body = panel.el.querySelector('.panel-body');
-  if (!body) return;
-  // Detach current view (keeps it alive in pool)
-  if (panel.viewId) {
-    const oldView = viewPool.get(panel.viewId);
-    if (oldView?.iframe.parentNode === body) body.removeChild(oldView.iframe);
-  }
+  // Just update the mapping — no iframe DOM manipulation needed.
+  // The old view's iframe hides automatically via syncViewPositions()
+  // (it will no longer be hosted by any panel).
   panel.viewId = newViewId;
-  attachViewToSlot(newViewId, body);
+  getOrCreateView(newViewId); // ensure iframe exists
   updatePanelHeader(panel);
+  requestAnimationFrame(() => syncViewPositions());
   // If already ready, send INIT with current dimensions
   const view = viewPool.get(newViewId);
   if (view?.ready) sendInitToView(newViewId, panel);
@@ -571,6 +1051,20 @@ <h3>Settings</h3>
   }
 }
 
+function sendToActivityStream(type, payload) {
+  // Send a message specifically to the activity stream view (embedded or popout)
+  for (const panel of Object.values(panels)) {
+    if (panel.viewId !== 'builtin:activity-stream') continue;
+    const view = viewPool.get(panel.viewId);
+    if (view?.ready && view.iframe) postToIframe(view.iframe, type, payload);
+  }
+  for (const [viewId, entry] of popoutWindows) {
+    if (viewId === 'builtin:activity-stream' && !entry.win.closed) {
+      postToPopout(entry.win, type, payload);
+    }
+  }
+}
+
 function broadcastToViewType(viewType, type, payload) {
   for (const panel of Object.values(panels)) {
     const view = viewPool.get(panel.viewId);
@@ -647,7 +1141,7 @@ <h3>Settings</h3>
       sendToBridge({ type: 'REQUEST_TOOL', view_id: viewId, ...msg.payload });
       break;
     case 'USER_MESSAGE':
-      sendToBridge({ type: 'USER_MESSAGE', content: msg.payload.content });
+      sendToBridge({ type: 'USER_MESSAGE', content: msg.payload.content, files: msg.payload.files || undefined });
       break;
     case 'USER_COMMAND':
       sendToBridge({ type: 'USER_COMMAND', command: msg.payload.command });
@@ -666,18 +1160,44 @@ <h3>Settings</h3>
   const wasReady = view.ready;
   view.ready = true;
   view.accepts = payload.accepts || [];
+  view.agent_scope = payload.agent_scope || null; // "focused" | "all" | specific agent_id
   if (view._readyTimeout) { clearTimeout(view._readyTimeout); view._readyTimeout = null; }
   const panel = findPanelHostingView(viewId);
   if (!panel) return;
   updatePanelHeader(panel);
   if (!wasReady) {
     sendInitToView(viewId, panel);
+    // Replay cached state to newly ready views
+    replayCachedState(viewId, view);
   } else {
     // View reattached to a slot — update its dimensions
     notifyResize(panel.panelId);
   }
 }
 
+function replayCachedState(viewId, view) {
+  const vInfo = viewRegistry.find(v => v.id === viewId);
+  const viewType = vInfo?.type;
+
+  // Replay TOOL_REGISTRY to tools-type views
+  if (viewType === 'tools' && _cachedToolRegistry) {
+    postToIframe(view.iframe, 'TOOL_REGISTRY', _cachedToolRegistry);
+  }
+  // Replay PLAN_UPDATE to plan-type views and activity stream
+  if (_cachedPlanUpdate && (viewType === 'plan' || viewId === 'builtin:activity-stream')) {
+    postToIframe(view.iframe, 'PLAN_UPDATE', _cachedPlanUpdate);
+  }
+  // Replay CONFIG_STATE to all views
+  if (_configState) {
+    postToIframe(view.iframe, 'CONFIG_STATE', _configState);
+  }
+  // Replay CONVERSATION_HISTORY to conversation-type views
+  if (viewType === 'conversation') {
+    // Request fresh history from bridge
+    sendToBridge({ type: 'REQUEST_CONFIG' });
+  }
+}
+
 // ================================================================
 //  Theme management
 // ================================================================
@@ -711,7 +1231,7 @@ <h3>Settings</h3>
 
   const root = document.documentElement;
   root.style.setProperty('--dash-bg',         t.bg || '');
-  root.style.setProperty('--dash-bg-surface',  t.bg_surface || t.bg_surface || '');
+  root.style.setProperty('--dash-bg-surface',  t.bg_surface || '');
   root.style.setProperty('--dash-bg-hover',    t.bg_hover || '');
   root.style.setProperty('--dash-fg',          t.fg || '');
   root.style.setProperty('--dash-fg-muted',    t.fg_muted || '');
@@ -735,6 +1255,7 @@ <h3>Settings</h3>
   broadcastToViews('THEME', themeToCSS(t));
 }
 
+let _themeChangeHandler = null;
 function buildThemeSelect() {
   const sel = document.getElementById('theme-select');
   sel.innerHTML = '';
@@ -745,9 +1266,10 @@ <h3>Settings</h3>
     sel.appendChild(opt);
   }
   sel.value = activeTheme;
-  sel.addEventListener('change', () => {
-    applyTheme(themes[sel.value] || {});
-  });
+  // Remove previous listener to avoid stacking
+  if (_themeChangeHandler) sel.removeEventListener('change', _themeChangeHandler);
+  _themeChangeHandler = () => { applyTheme(themes[sel.value] || {}); };
+  sel.addEventListener('change', _themeChangeHandler);
 }
 
 // ================================================================
@@ -768,15 +1290,9 @@ <h3>Settings</h3>
 }
 
 function renderLayout(layout) {
-  const root  = document.getElementById('grid-root');
-  const stash = document.getElementById('view-stash');
-  // Move all pool iframes to the stash — they stay in the document so their
-  // browsing context (and all JS state) is preserved across layout changes.
-  for (const [, view] of viewPool) {
-    if (view.iframe && view.iframe.parentNode !== stash) {
-      stash.appendChild(view.iframe);
-    }
-  }
+  const root = document.getElementById('grid-root');
+  // Iframes stay in #view-overlay — we only rebuild the panel grid.
+  // No iframe reparenting occurs, so browsing context is preserved.
   root.innerHTML = '';
   panels = {};
 
@@ -794,6 +1310,9 @@ <h3>Settings</h3>
       rowEl.appendChild(panelEl);
     });
   });
+
+  // Position iframes over their panel body slots after browser layout
+  requestAnimationFrame(() => syncViewPositions());
 }
 
 function parseFlex(pct) {
@@ -831,7 +1350,7 @@ <h3>Settings</h3>
   panels[panelId] = panel;
 
   if (resolvedViewId) {
-    attachViewToSlot(resolvedViewId, body);
+    attachViewToSlot(resolvedViewId);
   } else {
     const ph = document.createElement('div');
     ph.className = 'panel-placeholder';
@@ -845,7 +1364,7 @@ <h3>Settings</h3>
     if (btn) {
       e.stopPropagation();
       const action = btn.dataset.action;
-      if (action === 'minimize') panelEl.classList.toggle('minimized');
+      if (action === 'minimize') { panelEl.classList.toggle('minimized'); requestAnimationFrame(() => syncViewPositions()); }
       else if (action === 'close') closePanel(panelId);
       else if (action === 'popout') popoutPanel(panel);
       return;
@@ -884,6 +1403,9 @@ <h3>Settings</h3>
   if (!viewId) return '□';
   if (viewId === 'builtin:agent-terminal') return '⌨';
   if (viewId === 'builtin:activity-stream') return '◈';
+  if (viewId === 'builtin:tool-browser')    return '🔧';
+  if (viewId === 'builtin:plan-viewer')     return '📋';
+  if (viewId === 'builtin:agent-overview')  return '👥';
   const v = viewRegistry.find(v => v.id === viewId);
   return v?.icon || '◻';
 }
@@ -892,6 +1414,9 @@ <h3>Settings</h3>
   if (!viewId) return 'Empty';
   if (viewId === 'builtin:agent-terminal') return 'Agent Terminal';
   if (viewId === 'builtin:activity-stream') return 'Activity Stream';
+  if (viewId === 'builtin:tool-browser')    return 'Tool Browser';
+  if (viewId === 'builtin:plan-viewer')     return 'Plan Viewer';
+  if (viewId === 'builtin:agent-overview')  return 'Agent Overview';
   const v = viewRegistry.find(v => v.id === viewId);
   return v ? v.name : viewId;
 }
@@ -902,16 +1427,14 @@ <h3>Settings</h3>
 function closePanel(panelId) {
   const panel = panels[panelId];
   if (!panel) return;
-  // Detach view without destroying — keeps it alive in pool
-  if (panel.viewId) {
-    const view = viewPool.get(panel.viewId);
-    if (view?.iframe.parentNode) view.iframe.parentNode.removeChild(view.iframe);
-  }
+  // Don't touch the iframe — it stays alive in #view-overlay.
+  // syncViewPositions() will hide it since no panel hosts it.
   const rowEl = panel.rowEl;
   panel.el.remove();
   delete panels[panelId];
   if (rowEl && rowEl.querySelectorAll('.panel').length === 0) rowEl.remove();
   rebuildAddPanelMenu();
+  requestAnimationFrame(() => syncViewPositions());
 }
 
 function popoutPanel(panel) {
@@ -941,7 +1464,7 @@ <h3>Settings</h3>
     win.postMessage({
       protocol: PROTOCOL, version: VERSION, type: 'INIT',
       payload: {
-        view_id: viewId, panel_id: null, agent_id: null,
+        view_id: viewId, panel_id: null, agent_id: focusedAgentId,
         theme: themeToCSS(themeObj),
         dimensions: { width: win.innerWidth || 900, height: win.innerHeight || 600 },
       },
@@ -956,22 +1479,14 @@ <h3>Settings</h3>
 function swapPanels(aId, bId) {
   const a = panels[aId], b = panels[bId];
   if (!a || !b || a.viewId === b.viewId) return;
-  const aBody = a.el.querySelector('.panel-body');
-  const bBody = b.el.querySelector('.panel-body');
-  const aViewId = a.viewId, bViewId = b.viewId;
-  // Detach both views first
-  for (const vId of [aViewId, bViewId]) {
-    if (!vId) continue;
-    const v = viewPool.get(vId);
-    if (v?.iframe.parentNode) v.iframe.parentNode.removeChild(v.iframe);
-  }
-  // Cross-attach
-  a.viewId = bViewId;
-  b.viewId = aViewId;
-  if (bViewId && aBody) attachViewToSlot(bViewId, aBody);
-  if (aViewId && bBody) attachViewToSlot(aViewId, bBody);
+  // Just swap the viewId mappings — no iframe DOM manipulation.
+  // syncViewPositions() repositions iframes over the correct panel bodies.
+  const tmp = a.viewId;
+  a.viewId = b.viewId;
+  b.viewId = tmp;
   updatePanelHeader(a);
   updatePanelHeader(b);
+  requestAnimationFrame(() => syncViewPositions());
 }
 
 function showPanelError(bodyEl, msg) {
@@ -979,9 +1494,8 @@ <h3>Settings</h3>
   ph.className = 'panel-placeholder';
   ph.style.color = 'var(--dash-error)';
   ph.textContent = msg;
-  const existing = bodyEl.querySelector('iframe');
-  if (existing) existing.replaceWith(ph);
-  else bodyEl.appendChild(ph);
+  bodyEl.innerHTML = '';
+  bodyEl.appendChild(ph);
 }
 
 // ================================================================
@@ -1005,7 +1519,7 @@ <h3>Settings</h3>
     const panelsBefore = Array.from(rowEl.children).slice(0, handleIdx).filter(c => c.classList.contains('panel'));
     const panelsAfter  = Array.from(rowEl.children).slice(handleIdx + 1).filter(c => c.classList.contains('panel'));
 
-    panels_before = panelsBefore.at(-1);
+    panels_before = panelsBefore[panelsBefore.length - 1];
     panels_after  = panelsAfter[0];
     if (!panels_before || !panels_after) return;
 
@@ -1018,6 +1532,7 @@ <h3>Settings</h3>
       const na = Math.max(200, startAfter  - dx);
       panels_before.style.flex = `0 0 ${nb}px`;
       panels_after.style.flex  = `0 0 ${na}px`;
+      syncViewPositions();
       notifyResize(panels_before.dataset.panelId);
       notifyResize(panels_after.dataset.panelId);
     }
@@ -1037,6 +1552,7 @@ <h3>Settings</h3>
     Array.from(rowEl.children).filter(c => c.classList.contains('panel')).forEach(p => {
       p.style.flex = '';
     });
+    requestAnimationFrame(() => syncViewPositions());
   });
 
   return handle;
@@ -1058,7 +1574,7 @@ <h3>Settings</h3>
     const rowsBefore = Array.from(root.children).slice(0, handleIdx).filter(c => c.classList.contains('grid-row'));
     const rowsAfter  = Array.from(root.children).slice(handleIdx + 1).filter(c => c.classList.contains('grid-row'));
 
-    rowBefore = rowsBefore.at(-1);
+    rowBefore = rowsBefore[rowsBefore.length - 1];
     rowAfter  = rowsAfter[0];
     if (!rowBefore || !rowAfter) return;
 
@@ -1071,6 +1587,7 @@ <h3>Settings</h3>
       const na = Math.max(150, startAfter  - dy);
       rowBefore.style.flex = `0 0 ${nb}px`;
       rowAfter.style.flex  = `0 0 ${na}px`;
+      syncViewPositions();
     }
 
     function onUp() {
@@ -1087,6 +1604,7 @@ <h3>Settings</h3>
     Array.from(root.children).filter(c => c.classList.contains('grid-row')).forEach(r => {
       r.style.flex = '';
     });
+    requestAnimationFrame(() => syncViewPositions());
   });
 
   return handle;
@@ -1102,6 +1620,45 @@ <h3>Settings</h3>
   postToIframe(view.iframe, 'RESIZE', { width: body.clientWidth, height: body.clientHeight });
 }
 
+// ================================================================
+//  View overlay positioning — positions iframes over panel body slots
+// ================================================================
+function syncViewPositions() {
+  const overlay = document.getElementById('view-overlay');
+  if (!overlay) return;
+  const overlayRect = overlay.getBoundingClientRect();
+
+  // Build set of viewIds currently hosted by a visible panel
+  const hostedViews = new Set();
+  for (const panel of Object.values(panels)) {
+    if (panel.viewId) hostedViews.add(panel.viewId);
+  }
+
+  for (const [viewId, view] of viewPool) {
+    if (!view.iframe) continue;
+    const panel = findPanelHostingView(viewId);
+    if (panel && !panel.el.classList.contains('minimized')) {
+      const body = panel.el.querySelector('.panel-body');
+      if (body) {
+        const rect = body.getBoundingClientRect();
+        if (rect.width > 0 && rect.height > 0) {
+          view.iframe.style.display = 'block';
+          view.iframe.style.left   = (rect.left   - overlayRect.left) + 'px';
+          view.iframe.style.top    = (rect.top    - overlayRect.top)  + 'px';
+          view.iframe.style.width  = rect.width  + 'px';
+          view.iframe.style.height = rect.height + 'px';
+          continue;
+        }
+      }
+    }
+    // Not placed, minimized, or zero-size — hide
+    view.iframe.style.display = 'none';
+  }
+}
+
+// Re-sync on window resize
+window.addEventListener('resize', () => requestAnimationFrame(() => syncViewPositions()));
+
 // ================================================================
 //  Layout dropdown
 // ================================================================
@@ -1127,7 +1684,7 @@ <h3>Settings</h3>
   const presets = {
     'Minimal': { rows: [{ height: '100%', columns: [{ width: '100%', view: 'builtin:agent-terminal' }] }] },
     'Standard': { rows: [{ height: '100%', columns: [{ width: '70%', view: 'builtin:agent-terminal' }, { width: '30%', view: 'builtin:activity-stream' }] }] },
-    'Full': { rows: [{ height: '60%', columns: [{ width: '65%', view: 'builtin:agent-terminal' }, { width: '35%', view: 'builtin:activity-stream' }] }, { height: '40%', columns: [{ width: '100%', view: 'auto' }] }] },
+    'Full': { rows: [{ height: '60%', columns: [{ width: '65%', view: 'builtin:agent-terminal' }, { width: '35%', view: 'builtin:activity-stream' }] }, { height: '40%', columns: [{ width: '50%', view: 'builtin:tool-browser' }, { width: '50%', view: 'builtin:plan-viewer' }] }] },
   };
   const layout = presets[name];
   if (layout) { layoutConfig = layout; renderLayout(layout); }
@@ -1175,6 +1732,7 @@ <h3>Settings</h3>
   panelEl.style.flex = '1';
   lastRow.appendChild(panelEl);
   rebuildAddPanelMenu();
+  requestAnimationFrame(() => syncViewPositions());
 }
 
 // ================================================================
@@ -1189,6 +1747,45 @@ <h3>Settings</h3>
   setTimeout(() => toast.remove(), duration || 5000);
 }
 
+// ================================================================
+//  Tool approval dialog
+// ================================================================
+let _pendingApprovalCallId = null;
+let _approvalQueue = [];
+
+function handleToolApprovalRequest(payload) {
+  // If another approval is already showing, deny it first (auto-deny stale)
+  if (_pendingApprovalCallId) {
+    sendToBridge({ type: 'TOOL_APPROVAL_RESPONSE', call_id: _pendingApprovalCallId, approved: false });
+  }
+  _pendingApprovalCallId = payload.call_id || '';
+  document.getElementById('approval-tool-name').textContent = payload.tool_name || 'unknown';
+  try {
+    document.getElementById('approval-args').textContent =
+      JSON.stringify(payload.arguments, null, 2);
+  } catch {
+    document.getElementById('approval-args').textContent = String(payload.arguments || '{}');
+  }
+  document.getElementById('approval-overlay').classList.add('open');
+  showToast('warning', `Approval needed: ${payload.tool_name}`);
+}
+
+document.getElementById('approval-approve').addEventListener('click', () => {
+  if (_pendingApprovalCallId) {
+    sendToBridge({ type: 'TOOL_APPROVAL_RESPONSE', call_id: _pendingApprovalCallId, approved: true });
+  }
+  document.getElementById('approval-overlay').classList.remove('open');
+  _pendingApprovalCallId = null;
+});
+
+document.getElementById('approval-deny').addEventListener('click', () => {
+  if (_pendingApprovalCallId) {
+    sendToBridge({ type: 'TOOL_APPROVAL_RESPONSE', call_id: _pendingApprovalCallId, approved: false });
+  }
+  document.getElementById('approval-overlay').classList.remove('open');
+  _pendingApprovalCallId = null;
+});
+
 // ================================================================
 //  Toolbar event wiring
 // ================================================================
@@ -1224,12 +1821,350 @@ <h3>Settings</h3>
   }
 });
 
-// Close all dropdowns/menus on outside click
-document.addEventListener('click', () => {
+document.getElementById('clear-history-btn').addEventListener('click', () => {
+  if (!confirm('Clear all chat history and start a new session?')) return;
+  sendToBridge({ type: 'CLEAR_HISTORY' });
+  showToast('info', 'Chat history cleared');
+});
+
+document.getElementById('new-session-btn').addEventListener('click', () => {
+  if (!confirm('Save current session and start a new one?')) return;
+  sendToBridge({ type: 'NEW_SESSION' });
+  showToast('success', 'New session started');
+  // Close session drawer if open
+  document.getElementById('session-drawer').classList.remove('open');
+});
+
+document.getElementById('sessions-btn').addEventListener('click', (e) => {
+  e.stopPropagation();
+  const drawer = document.getElementById('session-drawer');
+  drawer.classList.toggle('open');
+  if (drawer.classList.contains('open')) {
+    sendToBridge({ type: 'REQUEST_SESSIONS' });
+  }
+});
+
+document.getElementById('refresh-sessions-btn').addEventListener('click', (e) => {
+  e.stopPropagation();
+  sendToBridge({ type: 'REQUEST_SESSIONS' });
+});
+
+// ================================================================
+//  Session list management
+// ================================================================
+let _sessionList = [];
+
+function handleSessionList(payload) {
+  _sessionList = payload.sessions || [];
+  const currentId = payload.current_session_id || _currentSessionId;
+  renderSessionList(_sessionList, currentId);
+}
+
+function renderSessionList(sessions, currentId) {
+  const ul = document.getElementById('session-list');
+  if (!sessions.length) {
+    ul.innerHTML = '<li class="session-empty">No saved sessions</li>';
+    return;
+  }
+  ul.innerHTML = '';
+  for (const s of sessions) {
+    const li = document.createElement('li');
+    li.className = 'session-item' + (s.session_id === currentId ? ' active' : '');
+
+    const info = document.createElement('div');
+    info.className = 'session-info';
+
+    const idEl = document.createElement('div');
+    idEl.className = 'session-id';
+    idEl.textContent = s.description || s.session_id.slice(0, 12);
+    info.appendChild(idEl);
+
+    const meta = document.createElement('div');
+    meta.className = 'session-meta';
+    const msgs = document.createElement('span');
+    msgs.textContent = s.message_count + ' msgs';
+    meta.appendChild(msgs);
+    if (s.model) {
+      const model = document.createElement('span');
+      model.textContent = s.model;
+      meta.appendChild(model);
+    }
+    const time = document.createElement('span');
+    time.textContent = formatSessionTime(s.updated_at);
+    meta.appendChild(time);
+    info.appendChild(meta);
+
+    li.appendChild(info);
+
+    const actions = document.createElement('div');
+    actions.className = 'session-actions';
+
+    if (s.session_id !== currentId) {
+      const loadBtn = document.createElement('button');
+      loadBtn.textContent = 'Load';
+      loadBtn.title = 'Switch to this session';
+      loadBtn.addEventListener('click', (e) => {
+        e.stopPropagation();
+        sendToBridge({ type: 'SWITCH_SESSION', session_id: s.session_id });
+        showToast('info', 'Switching session...');
+      });
+      actions.appendChild(loadBtn);
+
+      const delBtn = document.createElement('button');
+      delBtn.textContent = 'Del';
+      delBtn.className = 'delete';
+      delBtn.title = 'Delete this session';
+      delBtn.addEventListener('click', (e) => {
+        e.stopPropagation();
+        if (confirm('Delete this session permanently?')) {
+          sendToBridge({ type: 'DELETE_SESSION', session_id: s.session_id });
+        }
+      });
+      actions.appendChild(delBtn);
+    } else {
+      const cur = document.createElement('span');
+      cur.textContent = 'current';
+      cur.style.cssText = 'font-size:10px;color:var(--dash-accent)';
+      actions.appendChild(cur);
+    }
+
+    li.appendChild(actions);
+    ul.appendChild(li);
+  }
+}
+
+function formatSessionTime(iso) {
+  if (!iso) return '';
+  try {
+    const d = new Date(iso);
+    const now = new Date();
+    const diff = now - d;
+    if (diff < 60000) return 'just now';
+    if (diff < 3600000) return Math.floor(diff / 60000) + 'm ago';
+    if (diff < 86400000) return Math.floor(diff / 3600000) + 'h ago';
+    return d.toLocaleDateString();
+  } catch { return ''; }
+}
+
+// ================================================================
+//  Config state (model, provider, servers, system prompt)
+// ================================================================
+let _configState = null; // cached CONFIG_STATE payload
+let _availableProviders = []; // [{name, models: [...]}]
+
+function handleConfigState(payload) {
+  _configState = payload;
+  _availableProviders = payload.available_providers || [];
+  updateProviderSelect(payload.provider);
+  updateModelSelect(payload.provider, payload.model);
+  updateServerList(payload.servers || []);
+  updateSystemPromptEditor(payload.system_prompt || '');
+  // Show model group once we have config
+  document.getElementById('model-group').style.display = 'flex';
+}
+
+// ── Session state ─────────────────────────────────────────────────
+let _currentSessionId = null;
+
+function handleSessionState(payload) {
+  _currentSessionId = payload.session_id || null;
+  // Could update a session indicator in toolbar later
+}
+
+// ── Provider / Model selectors ────────────────────────────────────
+function updateProviderSelect(activeProvider) {
+  const sel = document.getElementById('provider-select');
+  const prev = sel.value;
+  sel.innerHTML = '';
+  for (const p of _availableProviders) {
+    const opt = document.createElement('option');
+    opt.value = p.name;
+    opt.textContent = p.name;
+    sel.appendChild(opt);
+  }
+  sel.value = activeProvider || prev;
+}
+
+function updateModelSelect(provider, activeModel) {
+  const sel = document.getElementById('model-select');
+  sel.innerHTML = '';
+  const pInfo = _availableProviders.find(p => p.name === provider);
+  const models = pInfo ? pInfo.models : [];
+  if (models.length === 0) {
+    const opt = document.createElement('option');
+    opt.value = activeModel || '';
+    opt.textContent = activeModel || '(unknown)';
+    sel.appendChild(opt);
+  } else {
+    for (const m of models) {
+      const opt = document.createElement('option');
+      opt.value = m;
+      opt.textContent = m;
+      sel.appendChild(opt);
+    }
+  }
+  sel.value = activeModel || '';
+  // If active model not in list, add it
+  if (sel.value !== activeModel && activeModel) {
+    const opt = document.createElement('option');
+    opt.value = activeModel;
+    opt.textContent = activeModel;
+    sel.insertBefore(opt, sel.firstChild);
+    sel.value = activeModel;
+  }
+}
+
+document.getElementById('provider-select').addEventListener('change', (e) => {
+  const provider = e.target.value;
+  const pInfo = _availableProviders.find(p => p.name === provider);
+  const models = pInfo ? pInfo.models : [];
+  const model = models[0] || '';
+  updateModelSelect(provider, model);
+  if (model) sendToBridge({ type: 'SWITCH_MODEL', provider, model });
+});
+
+document.getElementById('model-select').addEventListener('change', (e) => {
+  const model = e.target.value;
+  const provider = document.getElementById('provider-select').value;
+  if (provider && model) sendToBridge({ type: 'SWITCH_MODEL', provider, model });
+});
+
+// ── Server list ───────────────────────────────────────────────────
+function updateServerList(servers) {
+  const list = document.getElementById('server-list');
+  list.innerHTML = '';
+  if (!servers.length) {
+    list.innerHTML = '<li style="font-size:12px;color:var(--dash-fg-muted)">No servers connected</li>';
+    return;
+  }
+  for (const s of servers) {
+    const li = document.createElement('li');
+    li.className = 'server-item';
+    li.innerHTML = `
+      <span class="server-dot ${s.connected ? 'on' : 'off'}"></span>
+      <span class="server-name" title="${esc(s.namespace || s.name)}">${esc(s.name)}</span>
+      <span class="server-tools">${esc(String(s.tool_count))} tools</span>
+    `;
+    list.appendChild(li);
+  }
+}
+
+function esc(s) {
+  return String(s).replace(/&/g,'&amp;').replace(/</g,'&lt;').replace(/>/g,'&gt;').replace(/"/g,'&quot;');
+}
+
+// ── System prompt editor ──────────────────────────────────────────
+function updateSystemPromptEditor(prompt) {
+  const editor = document.getElementById('system-prompt-editor');
+  // Only update if not focused (avoid overwriting user edits)
+  if (document.activeElement !== editor) {
+    editor.value = prompt;
+  }
+}
+
+document.getElementById('apply-prompt-btn').addEventListener('click', () => {
+  const text = document.getElementById('system-prompt-editor').value;
+  sendToBridge({ type: 'UPDATE_SYSTEM_PROMPT', system_prompt: text });
+  showToast('info', 'System prompt updated');
+});
+
+document.getElementById('reset-prompt-btn').addEventListener('click', () => {
+  sendToBridge({ type: 'UPDATE_SYSTEM_PROMPT', system_prompt: '' });
+  showToast('info', 'System prompt reset to default');
+});
+
+// ================================================================
+//  Export conversation
+// ================================================================
+document.getElementById('export-btn').addEventListener('click', (e) => {
+  e.stopPropagation();
+  document.getElementById('export-menu').classList.toggle('open');
+});
+
+document.getElementById('export-menu').addEventListener('click', (e) => {
+  const item = e.target.closest('[data-format]');
+  if (!item) return;
+  e.stopPropagation();
+  document.getElementById('export-menu').classList.remove('open');
+  exportConversation(item.dataset.format);
+});
+
+function exportConversation(format) {
+  // Collect messages from the agent-terminal iframe
+  const msgs = collectConversationMessages();
+  if (!msgs.length) { showToast('warning', 'No messages to export'); return; }
+
+  let content, ext, mime;
+  if (format === 'json') {
+    content = JSON.stringify({ exported: new Date().toISOString(), messages: msgs }, null, 2);
+    ext = 'json'; mime = 'application/json';
+  } else {
+    const lines = [`# Conversation Export\n_${new Date().toISOString()}_\n`];
+    for (const m of msgs) {
+      const label = m.role === 'user' ? '**You**' : m.role === 'assistant' ? '**Agent**' : `**${m.role}**`;
+      lines.push(`### ${label}\n${m.content}\n`);
+    }
+    content = lines.join('\n');
+    ext = 'md'; mime = 'text/markdown';
+  }
+
+  const blob = new Blob([content], { type: mime });
+  const url = URL.createObjectURL(blob);
+  const a = document.createElement('a');
+  a.href = url;
+  a.download = `conversation-${Date.now()}.${ext}`;
+  a.click();
+  URL.revokeObjectURL(url);
+  showToast('success', `Exported as ${ext.toUpperCase()}`);
+}
+
+function collectConversationMessages() {
+  // Find the agent-terminal iframe and read its messages
+  for (const [viewId, view] of viewPool) {
+    if (viewId !== 'builtin:agent-terminal' || !view.iframe) continue;
+    try {
+      const doc = view.iframe.contentDocument || view.iframe.contentWindow.document;
+      const msgEls = doc.querySelectorAll('.msg');
+      const messages = [];
+      for (const el of msgEls) {
+        const role = el.classList.contains('user') ? 'user' :
+                     el.classList.contains('tool-call') ? 'tool' : 'assistant';
+        const contentEl = el.querySelector('.msg-content');
+        const toolNameEl = el.querySelector('.tool-name');
+        let content = '';
+        if (contentEl) content = contentEl.textContent || '';
+        else if (toolNameEl) content = `[Tool: ${toolNameEl.textContent}]`;
+        if (content) messages.push({ role, content });
+      }
+      return messages;
+    } catch (e) {
+      // Cross-origin — fall back to asking the bridge
+      sendToBridge({ type: 'REQUEST_EXPORT' });
+      showToast('info', 'Export requested from server');
+      return [];
+    }
+  }
+  return [];
+}
+
+// Close dropdowns/menus on outside click (but NOT settings panel when clicking inside it)
+document.addEventListener('click', (e) => {
   document.getElementById('layout-menu').classList.remove('open');
   document.getElementById('add-panel-menu').classList.remove('open');
-  document.getElementById('settings-panel').classList.remove('open');
+  document.getElementById('export-menu').classList.remove('open');
   document.querySelectorAll('.panel-view-menu.open').forEach(m => m.classList.remove('open'));
+  // Only close settings panel if click was outside both the panel and the settings button
+  const settingsPanel = document.getElementById('settings-panel');
+  const settingsBtn   = document.getElementById('settings-btn');
+  if (!settingsPanel.contains(e.target) && e.target !== settingsBtn) {
+    settingsPanel.classList.remove('open');
+  }
+  // Only close session drawer if click was outside both the drawer and the sessions button
+  const sessionDrawer = document.getElementById('session-drawer');
+  const sessionsBtn   = document.getElementById('sessions-btn');
+  if (!sessionDrawer.contains(e.target) && e.target !== sessionsBtn) {
+    sessionDrawer.classList.remove('open');
+  }
 });
 
 // ================================================================
@@ -1243,6 +2178,9 @@ <h3>Settings</h3>
   viewRegistry = [
     { id: 'builtin:agent-terminal', name: 'Agent Terminal', source: 'builtin', icon: '⌨', type: 'conversation', url: '/views/agent-terminal.html' },
     { id: 'builtin:activity-stream', name: 'Activity Stream', source: 'builtin', icon: '◈', type: 'stream', url: '/views/activity-stream.html' },
+    { id: 'builtin:tool-browser',    name: 'Tool Browser',    source: 'builtin', icon: '🔧', type: 'tools',        url: '/views/tool-browser.html' },
+    { id: 'builtin:plan-viewer',     name: 'Plan Viewer',     source: 'builtin', icon: '📋', type: 'plan',         url: '/views/plan-viewer.html' },
+    { id: 'builtin:agent-overview',  name: 'Agent Overview',  source: 'builtin', icon: '👥', type: 'agents',       url: '/views/agent-overview.html' },
   ];
   rebuildAddPanelMenu();
 
diff --git a/src/mcp_cli/dashboard/static/views/activity-stream.html b/src/mcp_cli/dashboard/static/views/activity-stream.html
index df108384..769b59bc 100644
--- a/src/mcp_cli/dashboard/static/views/activity-stream.html
+++ b/src/mcp_cli/dashboard/static/views/activity-stream.html
@@ -71,10 +71,15 @@
   border-left-width: 3px;
 }
 .event-card:hover { background: var(--dash-bg-hover); }
-.event-card.tool-ok   { border-left-color: var(--dash-accent); }
-.event-card.tool-err  { border-left-color: var(--dash-error); }
-.event-card.state-chg { border-left-color: var(--dash-fg-muted); }
-.event-card.user-act  { border-left-color: var(--dash-success); }
+.event-card.tool-ok    { border-left-color: var(--dash-accent); }
+.event-card.tool-err   { border-left-color: var(--dash-error); }
+.event-card.state-chg  { border-left-color: var(--dash-fg-muted); }
+.event-card.user-act   { border-left-color: var(--dash-success); }
+.event-card.thinking   { border-left-color: var(--dash-warning); }
+.event-card.plan-run   { border-left-color: var(--dash-info); }
+.event-card.plan-done  { border-left-color: var(--dash-success); }
+.event-card.plan-fail  { border-left-color: var(--dash-error); }
+.event-card.msg-assist { border-left-color: var(--dash-accent); }
 
 .event-header {
   display: flex;
@@ -90,22 +95,76 @@
 .event-status.ok  { color: var(--dash-success); }
 .event-status.err { color: var(--dash-error); }
 
+/* Expandable detail section */
 .event-detail {
   display: none;
   margin-top: 6px;
-  font-family: var(--dash-font-mono);
   font-size: 11px;
   color: var(--dash-fg-muted);
-  white-space: pre-wrap;
-  word-break: break-all;
-  max-height: 200px;
+  max-height: 300px;
   overflow-y: auto;
   background: var(--dash-bg);
   border-radius: var(--dash-radius);
-  padding: 6px;
+  padding: 8px;
 }
 .event-card.expanded .event-detail { display: block; }
 
+/* Detail subsections */
+.detail-section { margin-bottom: 8px; }
+.detail-section:last-child { margin-bottom: 0; }
+.detail-label {
+  font-size: 10px;
+  font-weight: 600;
+  text-transform: uppercase;
+  color: var(--dash-fg-muted);
+  margin-bottom: 3px;
+  letter-spacing: 0.5px;
+}
+.detail-content {
+  font-family: var(--dash-font-mono);
+  font-size: 11px;
+  white-space: pre-wrap;
+  word-break: break-all;
+  color: var(--dash-fg);
+  line-height: 1.4;
+}
+.detail-content.reasoning {
+  color: var(--dash-warning);
+  font-family: var(--dash-font-ui);
+  font-style: italic;
+  word-break: break-word;
+}
+
+/* Plan steps in detail */
+.detail-step {
+  display: flex;
+  gap: 8px;
+  padding: 3px 0;
+  border-bottom: 1px solid var(--dash-border);
+  align-items: baseline;
+}
+.detail-step:last-child { border-bottom: none; }
+.detail-step-icon { width: 14px; text-align: center; flex-shrink: 0; }
+.detail-step-title { flex: 1; font-size: 11px; }
+.detail-step-tool {
+  font-family: var(--dash-font-mono);
+  font-size: 10px;
+  color: var(--dash-accent);
+}
+.detail-step-status { font-size: 10px; }
+.detail-step-status.ok  { color: var(--dash-success); }
+.detail-step-status.err { color: var(--dash-error); }
+.detail-step-status.run { color: var(--dash-info); }
+
+/* Expand indicator */
+.expand-hint {
+  font-size: 10px;
+  color: var(--dash-fg-muted);
+  margin-top: 2px;
+  opacity: 0.6;
+}
+.event-card.expanded .expand-hint { display: none; }
+
 /* Scroll-to-bottom button + badge */
 #scroll-btn {
   display: none;
@@ -121,6 +180,25 @@
   cursor: pointer;
   z-index: 10;
 }
+/* Agent badge */
+.event-agent-badge {
+  display: inline-flex;
+  align-items: center;
+  gap: 3px;
+  padding: 0 5px;
+  border-radius: 8px;
+  font-size: 10px;
+  background: var(--dash-bg);
+  border: 1px solid var(--dash-border);
+  white-space: nowrap;
+  flex-shrink: 0;
+}
+.event-agent-dot {
+  width: 6px; height: 6px;
+  border-radius: 50%;
+  flex-shrink: 0;
+}
+
 #events-wrapper { flex: 1; position: relative; overflow: hidden; display: flex; flex-direction: column; }
 </style>
 </head>
@@ -134,6 +212,7 @@
     <option value="ok">Success</option>
     <option value="err">Error</option>
   </select>
+  <select id="agent-filter" style="display:none"><option value="">All agents</option></select>
 </div>
 
 <div id="events-wrapper">
@@ -150,9 +229,14 @@
 let filterText  = '';
 let filterServer = '';
 let filterStatus = '';
+let filterAgent  = '';
 let autoScroll  = true;
 let newCount    = 0;
 let servers     = new Set();
+let agents      = new Set();
+let _multiAgent = false;
+const AGENT_COLORS  = ['#7aa2f7','#9ece6a','#e0af68','#f7768e','#7dcfff','#bb9af7','#ff9e64','#73daca'];
+const agentColorMap = new Map();
 
 // Virtual scroll threshold
 const VIRT_THRESHOLD = 500;
@@ -162,6 +246,20 @@
 const searchInput = document.getElementById('search-input');
 const serverSel   = document.getElementById('server-filter');
 const statusSel   = document.getElementById('status-filter');
+const agentSel    = document.getElementById('agent-filter');
+
+function agentColor(agentId) {
+  if (!agentColorMap.has(agentId)) {
+    agentColorMap.set(agentId, AGENT_COLORS[agentColorMap.size % AGENT_COLORS.length]);
+  }
+  return agentColorMap.get(agentId);
+}
+
+function agentBadgeHtml(agentId) {
+  if (!_multiAgent || !agentId) return '';
+  const color = agentColor(agentId);
+  return `<span class="event-agent-badge"><span class="event-agent-dot" style="background:${color}"></span>${esc(agentId)}</span>`;
+}
 
 // ── postMessage handler ─────────────────────────────────────────
 window.addEventListener('message', (evt) => {
@@ -182,6 +280,15 @@
     case 'AGENT_STATE':
       addEvent('state', msg.payload);
       break;
+    case 'PLAN_UPDATE':
+      addEvent('plan', msg.payload);
+      break;
+    case 'CONVERSATION_MESSAGE':
+      addEvent('message', msg.payload);
+      break;
+    case 'ACTIVITY_HISTORY':
+      handleActivityHistory(msg.payload);
+      break;
   }
 });
 
@@ -198,7 +305,7 @@
   shell.postMessage({
     protocol: PROTOCOL, version: VERSION,
     type: 'READY',
-    payload: { name: 'Activity Stream', icon: 'activity', accepts: ['TOOL_RESULT', 'AGENT_STATE'], version: 1 }
+    payload: { name: 'Activity Stream', icon: 'activity', accepts: ['TOOL_RESULT', 'AGENT_STATE', 'PLAN_UPDATE', 'CONVERSATION_MESSAGE', 'ACTIVITY_HISTORY'], version: 1 }
   }, '*');
 }
 
@@ -219,6 +326,26 @@
 // ── Events ──────────────────────────────────────────────────────
 function addEvent(kind, payload) {
   const ev = { kind, payload, ts: Date.now(), id: allEvents.length };
+
+  // For plan updates, replace existing entry for the same plan_id (running→complete)
+  if (kind === 'plan' && payload.plan_id) {
+    const existIdx = allEvents.findIndex(e => e.kind === 'plan' && e.payload.plan_id === payload.plan_id);
+    if (existIdx !== -1) {
+      allEvents[existIdx] = ev;
+      ev.id = existIdx;
+      rerender();
+      return;
+    }
+  }
+
+  // Skip state events where status is the same as the previous state event
+  if (kind === 'state') {
+    const lastState = allEvents.filter(e => e.kind === 'state').pop();
+    if (lastState && lastState.payload.status === payload.status && lastState.payload.current_tool === payload.current_tool) {
+      return; // Deduplicate identical state transitions
+    }
+  }
+
   allEvents.push(ev);
 
   if (kind === 'tool' && payload.server_name) {
@@ -231,6 +358,21 @@
     }
   }
 
+  // Track agents for filter + badge
+  const aid = payload.agent_id;
+  if (aid && !agents.has(aid)) {
+    agents.add(aid);
+    const opt = document.createElement('option');
+    opt.value = aid;
+    opt.textContent = aid;
+    agentSel.appendChild(opt);
+    if (agents.size > 1 && !_multiAgent) {
+      _multiAgent = true;
+      agentSel.style.display = '';
+      rerender(); // re-render to add badges to existing cards
+    }
+  }
+
   if (matchesFilter(ev)) {
     renderEvent(ev);
   }
@@ -239,8 +381,9 @@
 function matchesFilter(ev) {
   const p = ev.payload;
   if (filterStatus === 'ok'  && p.success === false) return false;
-  if (filterStatus === 'err' && p.success !== false)  return false;
+  if (filterStatus === 'err' && p.success !== false && ev.kind === 'tool')  return false;
   if (filterServer && p.server_name !== filterServer) return false;
+  if (filterAgent && p.agent_id !== filterAgent) return false;
   if (filterText) {
     const haystack = JSON.stringify(p).toLowerCase();
     if (!haystack.includes(filterText)) return false;
@@ -260,43 +403,289 @@
   }
 }
 
+// ── Card builders by event kind ─────────────────────────────────
 function buildCard(ev) {
-  const p   = ev.payload;
+  switch (ev.kind) {
+    case 'tool':    return buildToolCard(ev);
+    case 'state':   return buildStateCard(ev);
+    case 'plan':    return buildPlanCard(ev);
+    case 'message': return buildMessageCard(ev);
+    default:        return buildGenericCard(ev);
+  }
+}
+
+function buildToolCard(ev) {
+  const p    = ev.payload;
   const card = document.createElement('div');
   const ok   = p.success !== false;
 
-  let cls = 'event-card ';
-  if (ev.kind === 'tool')  cls += ok ? 'tool-ok' : 'tool-err';
-  if (ev.kind === 'state') cls += 'state-chg';
-  card.className = cls;
+  card.className = `event-card ${ok ? 'tool-ok' : 'tool-err'}`;
   card.dataset.evId = ev.id;
 
-  const tsStr = new Date(ev.ts).toLocaleTimeString();
+  const tsStr  = new Date(ev.ts).toLocaleTimeString();
   const durStr = p.duration_ms != null ? `${p.duration_ms}ms` : '';
+  const summary = summariseResult(p.result);
+
+  // Build structured detail
+  let detailHtml = '';
+
+  // Arguments section
+  if (p.arguments && Object.keys(p.arguments).length > 0) {
+    detailHtml += `<div class="detail-section">
+      <div class="detail-label">Arguments</div>
+      <div class="detail-content">${esc(JSON.stringify(p.arguments, null, 2))}</div>
+    </div>`;
+  }
+
+  // Result section
+  if (p.result != null) {
+    const resultStr = typeof p.result === 'string' ? p.result : JSON.stringify(p.result, null, 2);
+    detailHtml += `<div class="detail-section">
+      <div class="detail-label">Result</div>
+      <div class="detail-content">${esc(resultStr)}</div>
+    </div>`;
+  }
+
+  // Error section
+  if (p.error) {
+    detailHtml += `<div class="detail-section">
+      <div class="detail-label">Error</div>
+      <div class="detail-content" style="color:var(--dash-error)">${esc(p.error)}</div>
+    </div>`;
+  }
+
+  const hasDetail = detailHtml.length > 0;
+
+  card.innerHTML = `
+    <div class="event-header">
+      ${agentBadgeHtml(p.agent_id)}
+      <span class="event-tool">${esc(p.tool_name || '')}</span>
+      <span class="event-server">${esc(p.server_name || '')}</span>
+      <span class="event-dur">${esc(durStr)}</span>
+    </div>
+    <div class="event-header" style="margin-top:2px">
+      <span class="event-status ${ok ? 'ok' : 'err'}">${ok ? '&#10003;' : '&#10007;'} ${ok ? summary : esc(p.error || 'error')}</span>
+      <span class="event-ts" style="margin-left:auto" title="${new Date(ev.ts).toISOString()}">${tsStr}</span>
+    </div>
+    ${hasDetail ? '<div class="expand-hint">click to expand</div>' : ''}
+    <div class="event-detail">${detailHtml}</div>`;
+
+  if (hasDetail) card.addEventListener('click', () => card.classList.toggle('expanded'));
+  return card;
+}
+
+function buildStateCard(ev) {
+  const p    = ev.payload;
+  const card = document.createElement('div');
+  const tsStr = new Date(ev.ts).toLocaleTimeString();
+
+  const status = p.status || 'unknown';
+  const isThinking = status === 'thinking';
+
+  card.className = `event-card ${isThinking ? 'thinking' : 'state-chg'}`;
+  card.dataset.evId = ev.id;
+
+  const icon = isThinking ? '&#128161;' : (status === 'tool_calling' ? '&#9881;' : '&#9678;');
+  const tool = p.current_tool ? ` &rarr; ${esc(p.current_tool)}` : '';
+  const tokens = p.tokens_used ? ` (${p.tokens_used} tokens)` : '';
+
+  card.innerHTML = `
+    <div class="event-header">
+      ${agentBadgeHtml(p.agent_id)}
+      <span class="event-tool" style="color:${isThinking ? 'var(--dash-warning)' : 'var(--dash-fg-muted)'}">${icon} ${esc(status)}${tool}</span>
+      <span class="event-ts" style="margin-left:auto">${tsStr}${tokens}</span>
+    </div>`;
+
+  return card;
+}
+
+function buildPlanCard(ev) {
+  const p    = ev.payload;
+  const card = document.createElement('div');
+  const tsStr = new Date(ev.ts).toLocaleTimeString();
+
+  const planStatus = p.status || 'running';
+  const isRunning = planStatus === 'running';
+  const isComplete = planStatus === 'complete';
+  const isFailed = planStatus === 'failed';
+
+  card.className = `event-card ${isFailed ? 'plan-fail' : (isComplete ? 'plan-done' : 'plan-run')}`;
+  card.dataset.evId = ev.id;
+
+  const steps = p.steps || [];
+  const completed = steps.filter(s => s.status === 'complete' || s.status === 'skipped').length;
+  const failed = steps.filter(s => s.status === 'failed').length;
+  const total = steps.length;
+
+  const icon = isRunning ? '&#9881;' : (isComplete ? '&#10003;' : '&#10007;');
+  const statusColor = isFailed ? 'var(--dash-error)' : (isComplete ? 'var(--dash-success)' : 'var(--dash-info)');
+  const progress = total > 0 ? ` ${completed}/${total} steps` : '';
+
+  // Build steps detail
+  let detailHtml = '';
+  if (steps.length > 0) {
+    let stepsHtml = '';
+    for (const s of steps) {
+      const st = s.status || 'pending';
+      let sIcon = '&#9675;'; // ○
+      let sCls = '';
+      if (st === 'running')  { sIcon = '&#9678;'; sCls = 'run'; }
+      if (st === 'complete') { sIcon = '&#10003;'; sCls = 'ok'; }
+      if (st === 'failed')   { sIcon = '&#10007;'; sCls = 'err'; }
+      if (st === 'skipped')  { sIcon = '&#8722;'; sCls = ''; }
+
+      stepsHtml += `<div class="detail-step">
+        <span class="detail-step-icon">${sIcon}</span>
+        <span class="detail-step-title">${esc(s.title || 'Step ' + (s.index || ''))}</span>
+        ${s.tool ? `<span class="detail-step-tool">${esc(s.tool)}</span>` : ''}
+        <span class="detail-step-status ${sCls}">${esc(st)}</span>
+      </div>`;
+    }
+    detailHtml += `<div class="detail-section">
+      <div class="detail-label">Steps</div>
+      ${stepsHtml}
+    </div>`;
+  }
+
+  if (p.error) {
+    detailHtml += `<div class="detail-section">
+      <div class="detail-label">Error</div>
+      <div class="detail-content" style="color:var(--dash-error)">${esc(p.error)}</div>
+    </div>`;
+  }
+
+  const hasDetail = detailHtml.length > 0;
+
+  card.innerHTML = `
+    <div class="event-header">
+      ${agentBadgeHtml(p.agent_id)}
+      <span class="event-tool" style="color:${statusColor}">${icon} Plan: ${esc(p.title || 'Untitled')}</span>
+      <span class="event-dur">${progress}</span>
+    </div>
+    <div class="event-header" style="margin-top:2px">
+      <span class="event-status" style="color:${statusColor}">${esc(planStatus)}</span>
+      <span class="event-ts" style="margin-left:auto">${tsStr}</span>
+    </div>
+    ${hasDetail ? '<div class="expand-hint">click to expand</div>' : ''}
+    <div class="event-detail">${detailHtml}</div>`;
+
+  if (hasDetail) card.addEventListener('click', () => card.classList.toggle('expanded'));
+  return card;
+}
+
+function buildMessageCard(ev) {
+  const p    = ev.payload;
+  const card = document.createElement('div');
+  const tsStr = new Date(ev.ts).toLocaleTimeString();
+
+  const role = p.role || 'unknown';
+  const hasReasoning = !!(p.reasoning);
+  const hasToolCalls = !!(p.tool_calls && p.tool_calls.length > 0);
+
+  // Only show thinking/reasoning cards — assistant text goes to terminal
+  if (role === 'assistant' && hasReasoning) {
+    card.className = 'event-card thinking';
+    card.dataset.evId = ev.id;
+
+    const preview = p.reasoning.slice(0, 80) + (p.reasoning.length > 80 ? '…' : '');
+
+    let detailHtml = `<div class="detail-section">
+      <div class="detail-label">Reasoning</div>
+      <div class="detail-content reasoning">${esc(p.reasoning)}</div>
+    </div>`;
+
+    if (p.content) {
+      const contentPreview = typeof p.content === 'string' ? p.content.slice(0, 200) : JSON.stringify(p.content).slice(0, 200);
+      detailHtml += `<div class="detail-section">
+        <div class="detail-label">Response</div>
+        <div class="detail-content">${esc(contentPreview)}${p.content.length > 200 ? '…' : ''}</div>
+      </div>`;
+    }
 
-  if (ev.kind === 'tool') {
-    const summary = summariseResult(p.result);
     card.innerHTML = `
       <div class="event-header">
-        <span class="event-tool">🔧 ${esc(p.tool_name || '')}</span>
-        <span class="event-server">${esc(p.server_name || '')}</span>
-        <span class="event-dur">${esc(durStr)}</span>
+        ${agentBadgeHtml(p.agent_id)}
+        <span class="event-tool" style="color:var(--dash-warning)">&#128161; Thinking</span>
+        <span class="event-ts" style="margin-left:auto">${tsStr}</span>
       </div>
       <div class="event-header" style="margin-top:2px">
-        <span class="event-status ${ok ? 'ok' : 'err'}">${ok ? '✓' : '✗'} ${ok ? summary : esc(p.error || 'error')}</span>
-        <span class="event-ts" style="margin-left:auto" title="${new Date(ev.ts).toISOString()}">${tsStr}</span>
+        <span style="font-size:11px;color:var(--dash-fg-muted)">${esc(preview)}</span>
       </div>
-      <div class="event-detail">${esc(JSON.stringify(p, null, 2))}</div>`;
-  } else {
-    const status = p.status || 'unknown';
-    const tool   = p.current_tool ? ` → ${p.current_tool}` : '';
+      <div class="expand-hint">click to expand</div>
+      <div class="event-detail">${detailHtml}</div>`;
+
+    card.addEventListener('click', () => card.classList.toggle('expanded'));
+    return card;
+  }
+
+  // For non-reasoning messages, only show if they have tool_calls info
+  if (role === 'assistant' && hasToolCalls) {
+    card.className = 'event-card msg-assist';
+    card.dataset.evId = ev.id;
+
+    const toolNames = p.tool_calls.map(tc => tc.function?.name || tc.name || '?').join(', ');
+
+    let detailHtml = '';
+    for (const tc of p.tool_calls) {
+      const name = tc.function?.name || tc.name || '?';
+      const args = tc.function?.arguments || tc.arguments || {};
+      const argsStr = typeof args === 'string' ? args : JSON.stringify(args, null, 2);
+      detailHtml += `<div class="detail-section">
+        <div class="detail-label">${esc(name)}</div>
+        <div class="detail-content">${esc(argsStr)}</div>
+      </div>`;
+    }
+
     card.innerHTML = `
       <div class="event-header">
-        <span class="event-tool" style="color:var(--dash-fg-muted)">◎ Agent: ${esc(status)}${esc(tool)}</span>
+        ${agentBadgeHtml(p.agent_id)}
+        <span class="event-tool">&#9881; Calling: ${esc(toolNames)}</span>
         <span class="event-ts" style="margin-left:auto">${tsStr}</span>
+      </div>
+      <div class="expand-hint">click to expand</div>
+      <div class="event-detail">${detailHtml}</div>`;
+
+    card.addEventListener('click', () => card.classList.toggle('expanded'));
+    return card;
+  }
+
+  // User messages with attachments
+  if (role === 'user' && p.attachments && p.attachments.length > 0) {
+    card.className = 'event-card user-att';
+    card.dataset.evId = ev.id;
+    const attNames = p.attachments.map(a => a.display_name || '?').join(', ');
+    const totalSize = p.attachments.reduce((s, a) => s + (a.size_bytes || 0), 0);
+    const contentPreview = (p.content || '').slice(0, 80);
+    card.innerHTML = `
+      <div class="event-header">
+        ${agentBadgeHtml(p.agent_id)}
+        <span class="event-tool" style="color:var(--dash-success)">&#128206; Attachments: ${esc(attNames)}</span>
+        <span class="event-dur">${_formatBytes(totalSize)}</span>
+        <span class="event-ts" style="margin-left:auto">${tsStr}</span>
+      </div>
+      <div class="event-header" style="margin-top:2px">
+        <span style="font-size:11px;color:var(--dash-fg-muted)">${esc(contentPreview)}</span>
       </div>`;
+    return card;
   }
 
+  // Skip other message types (user input, plain assistant text without reasoning)
+  // Return an empty non-rendered card
+  card.style.display = 'none';
+  return card;
+}
+
+function buildGenericCard(ev) {
+  const card = document.createElement('div');
+  card.className = 'event-card state-chg';
+  card.dataset.evId = ev.id;
+  const tsStr = new Date(ev.ts).toLocaleTimeString();
+  card.innerHTML = `
+    <div class="event-header">
+      <span class="event-tool" style="color:var(--dash-fg-muted)">&#9678; ${esc(ev.kind)}</span>
+      <span class="event-ts" style="margin-left:auto">${tsStr}</span>
+    </div>
+    <div class="event-detail"><div class="detail-content">${esc(JSON.stringify(ev.payload, null, 2))}</div></div>`;
   card.addEventListener('click', () => card.classList.toggle('expanded'));
   return card;
 }
@@ -317,6 +706,13 @@
   return String(s).replace(/&/g,'&amp;').replace(/</g,'&lt;').replace(/>/g,'&gt;');
 }
 
+function _formatBytes(bytes) {
+  if (!bytes || bytes === 0) return '';
+  if (bytes < 1024) return bytes + 'B';
+  if (bytes < 1048576) return (bytes / 1024).toFixed(1) + 'KB';
+  return (bytes / 1048576).toFixed(1) + 'MB';
+}
+
 function trimDom() {
   // Keep at most VIRT_THRESHOLD cards in the DOM
   const cards = eventsEl.querySelectorAll('.event-card');
@@ -368,6 +764,10 @@
   filterStatus = statusSel.value;
   rerender();
 });
+agentSel.addEventListener('change', () => {
+  filterAgent = agentSel.value;
+  rerender();
+});
 
 function rerender() {
   eventsEl.innerHTML = '';
@@ -376,6 +776,38 @@
   }
 }
 
+// ── Activity history replay (session load) ───────────────────
+function handleActivityHistory(payload) {
+  const events = payload.events || [];
+  // Clear current state and replay
+  allEvents = [];
+  servers = new Set();
+  agents = new Set();
+  _multiAgent = false;
+  eventsEl.innerHTML = '';
+  autoScroll = true;
+  newCount = 0;
+
+  // Rebuild filter options
+  serverSel.innerHTML = '<option value="">All servers</option>';
+  agentSel.innerHTML = '<option value="">All agents</option>';
+  agentSel.style.display = 'none';
+
+  for (const ev of events) {
+    // Each event has { type: 'TOOL_RESULT'|'CONVERSATION_MESSAGE', payload: {...} }
+    const kind = ev.type === 'TOOL_RESULT' ? 'tool'
+               : ev.type === 'CONVERSATION_MESSAGE' ? 'message'
+               : ev.type === 'PLAN_UPDATE' ? 'plan'
+               : ev.type === 'AGENT_STATE' ? 'state'
+               : 'unknown';
+    if (kind === 'unknown') continue;
+    addEvent(kind, ev.payload);
+  }
+
+  // Scroll to bottom after replay
+  wrapper.scrollTop = wrapper.scrollHeight;
+}
+
 // Send READY immediately (shell will send INIT back)
 sendReady();
 </script>
diff --git a/src/mcp_cli/dashboard/static/views/agent-overview.html b/src/mcp_cli/dashboard/static/views/agent-overview.html
new file mode 100644
index 00000000..bb1089b1
--- /dev/null
+++ b/src/mcp_cli/dashboard/static/views/agent-overview.html
@@ -0,0 +1,284 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0">
+<title>Agent Overview</title>
+<style>
+*, *::before, *::after { box-sizing: border-box; margin: 0; padding: 0; }
+html, body { height: 100%; overflow: hidden; }
+:root {
+  --dash-bg: #1e1e2e; --dash-bg-surface: #262637; --dash-bg-hover: #2e2e42;
+  --dash-fg: #e0e0e0; --dash-fg-muted: #888899;
+  --dash-accent: #7aa2f7; --dash-success: #9ece6a; --dash-warning: #e0af68;
+  --dash-error: #f7768e; --dash-info: #7dcfff; --dash-border: #3b3b52;
+  --dash-font-mono: 'JetBrains Mono','Fira Code',monospace;
+  --dash-font-ui: 'Inter',-apple-system,sans-serif;
+  --dash-font-size: 13px; --dash-radius: 6px; --dash-spacing: 8px;
+}
+body {
+  background: var(--dash-bg);
+  color: var(--dash-fg);
+  font-family: var(--dash-font-ui);
+  font-size: var(--dash-font-size);
+  display: flex;
+  flex-direction: column;
+  height: 100vh;
+}
+
+#agent-grid {
+  flex: 1;
+  overflow-y: auto;
+  padding: 12px;
+  display: grid;
+  grid-template-columns: repeat(auto-fill, minmax(240px, 1fr));
+  gap: 10px;
+  align-content: start;
+}
+#agent-grid::-webkit-scrollbar { width: 6px; }
+#agent-grid::-webkit-scrollbar-track { background: transparent; }
+#agent-grid::-webkit-scrollbar-thumb { background: var(--dash-border); border-radius: 3px; }
+
+.agent-card {
+  background: var(--dash-bg-surface);
+  border: 1px solid var(--dash-border);
+  border-radius: var(--dash-radius);
+  padding: 12px;
+  cursor: pointer;
+  transition: background 0.15s, border-color 0.15s;
+}
+.agent-card:hover { background: var(--dash-bg-hover); border-color: var(--dash-accent); }
+.agent-card.focused { border-color: var(--dash-accent); }
+
+.agent-card-header {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  margin-bottom: 8px;
+}
+.agent-status-dot {
+  width: 8px; height: 8px;
+  border-radius: 50%;
+  flex-shrink: 0;
+}
+.agent-status-dot.active    { background: var(--dash-success); }
+.agent-status-dot.paused    { background: var(--dash-warning); }
+.agent-status-dot.completed { background: var(--dash-fg-muted); }
+.agent-status-dot.failed    { background: var(--dash-error); }
+
+.agent-card-name {
+  font-weight: 600;
+  font-size: 13px;
+  flex: 1;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+.agent-card-role {
+  font-size: 11px;
+  color: var(--dash-fg-muted);
+}
+
+.agent-card-meta {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 6px;
+  font-size: 10px;
+  color: var(--dash-fg-muted);
+}
+.agent-card-meta span {
+  background: var(--dash-bg);
+  padding: 2px 6px;
+  border-radius: 4px;
+  border: 1px solid var(--dash-border);
+}
+
+.agent-card-action {
+  font-size: 11px;
+  color: var(--dash-info);
+  margin-top: 6px;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+#empty-state {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  height: 100%;
+  color: var(--dash-fg-muted);
+  font-size: 12px;
+  text-align: center;
+  padding: 20px;
+}
+</style>
+</head>
+<body>
+
+<div id="agent-grid">
+  <div id="empty-state">Waiting for agents...</div>
+</div>
+
+<script>
+'use strict';
+const PROTOCOL = 'mcp-dashboard';
+const VERSION  = 1;
+
+let agentList = [];
+let focusedAgentId = null;
+let agentStates = {}; // agent_id → last AGENT_STATE payload
+
+const gridEl = document.getElementById('agent-grid');
+const emptyEl = document.getElementById('empty-state');
+
+window.addEventListener('message', (evt) => {
+  const msg = evt.data;
+  if (!msg || msg.protocol !== PROTOCOL) return;
+
+  switch (msg.type) {
+    case 'INIT':
+      applyTheme(msg.payload.theme || {});
+      focusedAgentId = msg.payload.agent_id || null;
+      sendReady();
+      break;
+    case 'THEME':
+      applyTheme(msg.payload);
+      break;
+    case 'AGENT_LIST':
+      agentList = (msg.payload && msg.payload.agents) || [];
+      render();
+      break;
+    case 'AGENT_REGISTERED': {
+      const exists = agentList.find(a => a.agent_id === msg.payload.agent_id);
+      if (!exists) agentList.push(msg.payload);
+      render();
+      break;
+    }
+    case 'AGENT_UNREGISTERED':
+      agentList = agentList.filter(a => a.agent_id !== msg.payload.agent_id);
+      delete agentStates[msg.payload.agent_id];
+      render();
+      break;
+    case 'AGENT_STATUS': {
+      const agent = agentList.find(a => a.agent_id === msg.payload.agent_id);
+      if (agent) agent.status = msg.payload.status;
+      render();
+      break;
+    }
+    case 'AGENT_STATE':
+      if (msg.payload.agent_id) {
+        agentStates[msg.payload.agent_id] = msg.payload;
+      }
+      render();
+      break;
+  }
+});
+
+function getShell() {
+  if (window.parent !== window) return window.parent;
+  if (window.opener) return window.opener;
+  return null;
+}
+
+function sendReady() {
+  const shell = getShell();
+  if (!shell) return;
+  shell.postMessage({
+    protocol: PROTOCOL, version: VERSION,
+    type: 'READY',
+    payload: { name: 'Agent Overview', icon: 'agents', accepts: ['AGENT_LIST', 'AGENT_REGISTERED', 'AGENT_UNREGISTERED', 'AGENT_STATUS', 'AGENT_STATE'], version: 1 }
+  }, '*');
+}
+
+function applyTheme(t) {
+  const r = document.documentElement;
+  const set = (k, v) => v && r.style.setProperty(k, v);
+  set('--dash-bg', t.bg); set('--dash-bg-surface', t.bg_surface);
+  set('--dash-bg-hover', t.bg_hover); set('--dash-fg', t.fg);
+  set('--dash-fg-muted', t.fg_muted); set('--dash-accent', t.accent);
+  set('--dash-success', t.success); set('--dash-warning', t.warning);
+  set('--dash-error', t.error); set('--dash-info', t.info);
+  set('--dash-border', t.border); set('--dash-font-mono', t.font_mono);
+  set('--dash-font-ui', t.font_ui); set('--dash-font-size', t.font_size);
+  set('--dash-radius', t.radius); set('--dash-spacing', t.spacing);
+}
+
+function esc(s) {
+  return String(s).replace(/&/g,'&amp;').replace(/</g,'&lt;').replace(/>/g,'&gt;');
+}
+
+function render() {
+  gridEl.innerHTML = '';
+
+  if (agentList.length === 0) {
+    gridEl.appendChild(emptyEl);
+    emptyEl.textContent = 'Waiting for agents...';
+    return;
+  }
+
+  if (agentList.length === 1) {
+    const single = document.createElement('div');
+    single.id = 'empty-state';
+    single.textContent = 'Single agent mode';
+    gridEl.appendChild(single);
+  }
+
+  for (const agent of agentList) {
+    const card = document.createElement('div');
+    card.className = 'agent-card' + (agent.agent_id === focusedAgentId ? ' focused' : '');
+
+    const status = agent.status || 'active';
+    const state = agentStates[agent.agent_id];
+
+    // Header
+    let headerHtml = `
+      <div class="agent-card-header">
+        <span class="agent-status-dot ${esc(status)}"></span>
+        <span class="agent-card-name">${esc(agent.name || agent.agent_id)}</span>
+      </div>`;
+
+    if (agent.role) {
+      headerHtml += `<div class="agent-card-role">${esc(agent.role)}</div>`;
+    }
+
+    // Meta pills
+    let metaHtml = '<div class="agent-card-meta">';
+    if (agent.model)    metaHtml += `<span>${esc(agent.model)}</span>`;
+    if (agent.provider) metaHtml += `<span>${esc(agent.provider)}</span>`;
+    if (agent.message_count) metaHtml += `<span>${agent.message_count} msgs</span>`;
+    if (agent.tool_count)    metaHtml += `<span>${agent.tool_count} tools</span>`;
+    metaHtml += `<span>${esc(status)}</span>`;
+    metaHtml += '</div>';
+
+    // Current action from AGENT_STATE
+    let actionHtml = '';
+    if (state) {
+      const s = state.status || 'idle';
+      const tool = state.current_tool ? ` → ${esc(state.current_tool)}` : '';
+      actionHtml = `<div class="agent-card-action">${esc(s)}${tool}</div>`;
+    }
+
+    card.innerHTML = headerHtml + metaHtml + actionHtml;
+
+    card.addEventListener('click', () => {
+      focusedAgentId = agent.agent_id;
+      const shell = getShell();
+      if (shell) {
+        shell.postMessage({
+          protocol: PROTOCOL, version: VERSION,
+          type: 'USER_ACTION',
+          payload: { action: 'focus_agent', agent_id: agent.agent_id }
+        }, '*');
+      }
+      render();
+    });
+
+    gridEl.appendChild(card);
+  }
+}
+
+sendReady();
+</script>
+</body>
+</html>
diff --git a/src/mcp_cli/dashboard/static/views/agent-terminal.html b/src/mcp_cli/dashboard/static/views/agent-terminal.html
index 893890ce..e1b431b2 100644
--- a/src/mcp_cli/dashboard/static/views/agent-terminal.html
+++ b/src/mcp_cli/dashboard/static/views/agent-terminal.html
@@ -153,6 +153,48 @@
 }
 .reasoning-block.expanded .reasoning-content { display: block; }
 
+/* Search bar */
+#search-bar {
+  display: none;
+  position: absolute;
+  top: 4px;
+  right: 12px;
+  z-index: 20;
+  background: var(--dash-bg-surface);
+  border: 1px solid var(--dash-border);
+  border-radius: var(--dash-radius);
+  padding: 4px 8px;
+  gap: 6px;
+  align-items: center;
+  box-shadow: 0 2px 8px rgba(0,0,0,0.3);
+}
+#search-bar.open { display: flex; }
+#search-bar input {
+  background: var(--dash-bg);
+  border: 1px solid var(--dash-border);
+  border-radius: 3px;
+  color: var(--dash-fg);
+  font-size: 12px;
+  padding: 2px 6px;
+  width: 180px;
+  outline: none;
+  font-family: var(--dash-font-ui);
+}
+#search-bar input:focus { border-color: var(--dash-accent); }
+#search-bar .search-count { font-size: 11px; color: var(--dash-fg-muted); min-width: 40px; text-align: center; }
+#search-bar button {
+  background: transparent;
+  border: 1px solid var(--dash-border);
+  border-radius: 3px;
+  color: var(--dash-fg-muted);
+  cursor: pointer;
+  padding: 1px 6px;
+  font-size: 12px;
+}
+#search-bar button:hover { background: var(--dash-bg-hover); color: var(--dash-fg); }
+.search-highlight { background: rgba(255, 200, 50, 0.3); border-radius: 2px; }
+.search-highlight.current { background: rgba(255, 200, 50, 0.6); }
+
 /* Scroll-to-bottom */
 #scroll-btn {
   display: none;
@@ -226,6 +268,69 @@
 }
 #send-btn:hover { opacity: 0.9; }
 
+/* ── Attach button & staging ─────────────────────────────────── */
+#attach-btn {
+  background: none;
+  border: 1px solid var(--dash-border);
+  border-radius: 50%;
+  width: 32px;
+  height: 32px;
+  font-size: 18px;
+  cursor: pointer;
+  color: var(--dash-fg);
+  flex-shrink: 0;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  line-height: 1;
+}
+#attach-btn:hover { background: var(--dash-bg-hover); }
+
+#staging-strip {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 6px;
+  padding: 0 12px;
+}
+#staging-strip:empty { display: none; }
+.staged-file {
+  display: inline-flex;
+  align-items: center;
+  gap: 4px;
+  background: var(--dash-bg-hover);
+  border-radius: 12px;
+  padding: 4px 10px;
+  font-size: 12px;
+  color: var(--dash-fg);
+}
+.staged-file .remove-staged {
+  cursor: pointer;
+  opacity: 0.6;
+  margin-left: 2px;
+}
+.staged-file .remove-staged:hover { opacity: 1; }
+.staged-thumb {
+  width: 32px;
+  height: 32px;
+  object-fit: cover;
+  border-radius: 4px;
+}
+
+#drop-overlay {
+  display: none;
+  position: absolute;
+  inset: 0;
+  z-index: 100;
+  background: rgba(0, 0, 0, 0.6);
+  color: #fff;
+  font-size: 24px;
+  align-items: center;
+  justify-content: center;
+  border-radius: 8px;
+  border: 3px dashed var(--dash-accent);
+  pointer-events: none;
+}
+
 /* Scroll container — must be flex to constrain #messages height */
 #messages-wrapper {
   flex: 1;
@@ -235,11 +340,48 @@
   flex-direction: column;
   overflow: hidden;
 }
+
+/* ── Attachment UI ─────────────────────────────────────────────── */
+.attachment-strip { display: flex; flex-wrap: wrap; gap: 6px; margin-top: 6px; }
+.att-badge {
+  display: inline-flex; align-items: center; gap: 4px;
+  background: var(--dash-bg); border: 1px solid var(--dash-border);
+  border-radius: 4px; padding: 3px 8px; font-size: 11px;
+  color: var(--dash-fg-muted); cursor: default;
+}
+.att-badge .att-icon { font-size: 13px; }
+.att-badge .att-name { max-width: 160px; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+.att-badge .att-size { font-size: 10px; opacity: 0.7; }
+.att-image-preview {
+  max-width: 200px; max-height: 150px; border-radius: var(--dash-radius);
+  border: 1px solid var(--dash-border); margin-top: 4px; cursor: pointer;
+}
+.att-image-preview:hover { opacity: 0.85; }
+.att-text-preview {
+  background: var(--dash-bg); border: 1px solid var(--dash-border);
+  border-radius: var(--dash-radius); padding: 6px 8px; margin-top: 4px;
+  font-family: var(--dash-font-mono); font-size: 11px; white-space: pre-wrap;
+  max-height: 80px; overflow: hidden; cursor: pointer; position: relative;
+}
+.att-text-preview.expanded { max-height: none; }
+.att-text-preview .att-text-fade {
+  position: absolute; bottom: 0; left: 0; right: 0; height: 30px;
+  background: linear-gradient(transparent, var(--dash-bg)); pointer-events: none;
+}
+.att-text-preview.expanded .att-text-fade { display: none; }
+.att-audio-player { margin-top: 4px; width: 100%; max-width: 280px; height: 32px; }
 </style>
 </head>
 <body>
 
 <div id="messages-wrapper">
+  <div id="search-bar">
+    <input type="text" id="search-input" placeholder="Search messages…">
+    <span class="search-count" id="search-count"></span>
+    <button id="search-prev" title="Previous">↑</button>
+    <button id="search-next" title="Next">↓</button>
+    <button id="search-close" title="Close">×</button>
+  </div>
   <div id="messages"></div>
   <button id="scroll-btn">↓</button>
 </div>
@@ -249,10 +391,14 @@
   <span id="token-count"></span>
 </div>
 
+<div id="staging-strip"></div>
 <div id="input-area">
+  <button id="attach-btn" title="Attach file (+)">+</button>
+  <input type="file" id="file-input" multiple accept="image/*,.heic,audio/*,.txt,.md,.csv,.json,.py,.js,.ts,.html,.xml,.yaml,.yml,.sh,.rs,.go,.java,.c,.cpp,.h,.rb,.swift,.sql,.toml,.ini,.cfg,.log" hidden>
   <textarea id="chat-input" placeholder="Type a message… (Enter to send, Shift+Enter for newline)" rows="1"></textarea>
   <button id="send-btn">Send</button>
 </div>
+<div id="drop-overlay">Drop files here</div>
 
 <script>
 'use strict';
@@ -268,10 +414,17 @@
 const scrollBtn   = document.getElementById('scroll-btn');
 const wrapper     = document.getElementById('messages-wrapper');
 
+const attachBtn   = document.getElementById('attach-btn');
+const fileInput   = document.getElementById('file-input');
+const stagingStrip = document.getElementById('staging-strip');
+const dropOverlay = document.getElementById('drop-overlay');
+
 let autoScroll      = true;
 let streamingBubble = null; // current streaming message bubble
+let stagedFiles     = [];   // [{name, data (base64), mime_type, thumb?}]
 let streamingContent = '';
 let _hadStreamingTokens = false; // true when CONVERSATION_TOKEN events built current response
+let _agentName      = '';   // agent_id from INIT (shown in status bar when not "default")
 
 // Configure marked
 if (typeof marked !== 'undefined') {
@@ -286,6 +439,9 @@
   switch (msg.type) {
     case 'INIT':
       applyTheme(msg.payload.theme || {});
+      if (msg.payload.agent_id && msg.payload.agent_id !== 'default') {
+        _agentName = msg.payload.agent_id;
+      }
       sendReady();
       break;
     case 'THEME':
@@ -297,9 +453,15 @@
     case 'CONVERSATION_TOKEN':
       handleToken(msg.payload);
       break;
+    case 'CONVERSATION_HISTORY':
+      handleConversationHistory(msg.payload);
+      break;
     case 'AGENT_STATE':
       updateStatus(msg.payload);
       break;
+    case 'CONFIG_STATE':
+      handleConfigState(msg.payload);
+      break;
     case 'TOOL_RESULT':
       // Tool results are shown inline as tool cards
       // (the assistant message with tool_calls is sent separately)
@@ -320,7 +482,7 @@
   shell.postMessage({
     protocol: PROTOCOL, version: VERSION,
     type: 'READY',
-    payload: { name: 'Agent Terminal', icon: 'terminal', accepts: ['CONVERSATION_MESSAGE', 'CONVERSATION_TOKEN', 'AGENT_STATE'], version: 1 }
+    payload: { name: 'Agent Terminal', icon: 'terminal', accepts: ['CONVERSATION_MESSAGE', 'CONVERSATION_TOKEN', 'CONVERSATION_HISTORY', 'AGENT_STATE', 'CONFIG_STATE'], version: 1 }
   }, '*');
 }
 
@@ -344,6 +506,10 @@
   if (streamingBubble) finaliseStreaming();
 
   const { role, content, streaming, tool_calls, reasoning } = payload;
+
+  // Tool-role messages are raw results — they belong in the activity stream, not chat
+  if (role === 'tool') return;
+
   const wasTokenStreamed = _hadStreamingTokens;
   _hadStreamingTokens = false;
 
@@ -362,9 +528,15 @@
     return; // tool_calls shown as cards; content usually empty
   }
 
-  if (!content) return;
+  if (!content && !(payload.attachments && payload.attachments.length)) return;
+
+  const bubble = addMessageBubble(role, content || '', streaming);
+
+  // Render attachment badges / previews if present
+  if (payload.attachments && payload.attachments.length > 0) {
+    renderAttachments(bubble, payload.attachments);
+  }
 
-  const bubble = addMessageBubble(role, content, streaming);
   if (streaming) {
     streamingBubble = bubble;
     streamingContent = content || '';
@@ -430,7 +602,16 @@
   const contentEl = bubble.querySelector('.msg-content');
   if (!contentEl) return;
   if (typeof marked !== 'undefined' && !streaming) {
-    try { contentEl.innerHTML = marked.parse(text); return; } catch (e) {
+    try {
+      const html = marked.parse(text);
+      // Sanitize: strip <script>, event handlers, and dangerous URIs
+      const sanitized = html
+        .replace(/<script[\s\S]*?<\/script>/gi, '')
+        .replace(/\son\w+\s*=/gi, ' data-removed=')
+        .replace(/href\s*=\s*["']javascript:/gi, 'href="');
+      contentEl.innerHTML = sanitized;
+      return;
+    } catch (e) {
       console.error('Markdown parse error:', e);
     }
   }
@@ -487,15 +668,57 @@
 }
 
 // ── Status ──────────────────────────────────────────────────────
+let _currentModel = '';
+let _totalTokens = 0;
+
 function updateStatus(payload) {
   const { status, current_tool, tokens_used, turn_number } = payload;
   let text = status || 'idle';
   if (status === 'tool_calling' && current_tool) text = `calling ${current_tool}…`;
   else if (status === 'thinking') text = 'thinking…';
   else if (status === 'idle') text = 'idle';
+  if (_agentName) text = `[${_agentName}] ${text}`;
   statusText.textContent = text;
-  if (tokens_used) tokenCount.textContent = `${tokens_used.toLocaleString()} tokens`;
-  if (turn_number) tokenCount.textContent += ` · turn ${turn_number}`;
+
+  if (tokens_used) _totalTokens += tokens_used;
+
+  let countParts = [];
+  if (_currentModel) countParts.push(_currentModel);
+  if (_totalTokens) countParts.push(`${_totalTokens.toLocaleString()} tokens`);
+  if (turn_number) countParts.push(`turn ${turn_number}`);
+  tokenCount.textContent = countParts.join(' · ');
+}
+
+// ── Config state (model display) ─────────────────────────────────
+function handleConfigState(payload) {
+  _currentModel = payload.model || '';
+  // Update status bar with model name
+  const parts = [];
+  if (_currentModel) parts.push(_currentModel);
+  const existing = tokenCount.textContent;
+  // Preserve token/turn info if present
+  if (existing) {
+    const segments = existing.split(' · ').filter(s => !s.match(/^[a-z]/i) || s.includes('token') || s.includes('turn'));
+    parts.push(...segments);
+  }
+  tokenCount.textContent = parts.join(' · ');
+}
+
+// ── Conversation history replay ──────────────────────────────────
+function handleConversationHistory(payload) {
+  const messages = payload.messages || [];
+  // Clear current messages and replay history (empty array = clear all)
+  messagesEl.innerHTML = '';
+  streamingBubble = null;
+  streamingContent = '';
+  _hadStreamingTokens = false;
+
+  for (const msg of messages) {
+    handleConversationMessage(msg);
+  }
+  // Scroll to bottom after replay
+  wrapper.scrollTop = wrapper.scrollHeight;
+  autoScroll = true;
 }
 
 // ── Scroll ──────────────────────────────────────────────────────
@@ -514,21 +737,110 @@
   if (autoScroll) wrapper.scrollTop = wrapper.scrollHeight;
 }
 
+// ── File staging ─────────────────────────────────────────────────
+function stageFile(file) {
+  if (file.size > 20 * 1024 * 1024) {
+    showNotification('File too large: ' + file.name + ' (max 20 MB)', 'error');
+    return;
+  }
+  if (stagedFiles.length >= 10) {
+    showNotification('Max 10 attachments per message', 'error');
+    return;
+  }
+  const reader = new FileReader();
+  reader.onload = () => {
+    const b64 = reader.result.split(',')[1];
+    const entry = { name: file.name, data: b64, mime_type: file.type || 'application/octet-stream' };
+    if (file.type.startsWith('image/')) entry.thumb = reader.result;
+    stagedFiles.push(entry);
+    renderStagingStrip();
+  };
+  reader.readAsDataURL(file);
+}
+
+function renderStagingStrip() {
+  stagingStrip.innerHTML = '';
+  stagedFiles.forEach((f, i) => {
+    const badge = document.createElement('span');
+    badge.className = 'staged-file';
+    if (f.thumb) {
+      const img = document.createElement('img');
+      img.src = f.thumb;
+      img.className = 'staged-thumb';
+      badge.appendChild(img);
+    }
+    badge.appendChild(document.createTextNode(f.name));
+    const rm = document.createElement('span');
+    rm.className = 'remove-staged';
+    rm.textContent = '\u2715';
+    rm.onclick = () => { stagedFiles.splice(i, 1); renderStagingStrip(); };
+    badge.appendChild(rm);
+    stagingStrip.appendChild(badge);
+  });
+}
+
+function showNotification(message, level) {
+  const shell = getShell();
+  if (shell) {
+    shell.postMessage({ protocol: PROTOCOL, version: VERSION, type: 'NOTIFY', payload: { message, level: level || 'info', duration_ms: 4000 } }, '*');
+  }
+}
+
+attachBtn.addEventListener('click', () => fileInput.click());
+
+fileInput.addEventListener('change', (e) => {
+  for (const file of e.target.files) stageFile(file);
+  e.target.value = '';
+});
+
+// ── Drag and drop ───────────────────────────────────────────────
+document.documentElement.addEventListener('dragover', (e) => {
+  e.preventDefault();
+  dropOverlay.style.display = 'flex';
+});
+document.documentElement.addEventListener('dragleave', (e) => {
+  if (!e.relatedTarget) dropOverlay.style.display = 'none';
+});
+document.documentElement.addEventListener('drop', (e) => {
+  e.preventDefault();
+  dropOverlay.style.display = 'none';
+  for (const file of e.dataTransfer.files) stageFile(file);
+});
+
+// ── Clipboard paste (images) ────────────────────────────────────
+inputEl.addEventListener('paste', (e) => {
+  const items = e.clipboardData && e.clipboardData.items;
+  if (!items) return;
+  for (const item of items) {
+    if (item.kind === 'file') {
+      e.preventDefault();
+      stageFile(item.getAsFile());
+    }
+  }
+});
+
 // ── Input ────────────────────────────────────────────────────────
 function sendMessage() {
   const text = inputEl.value.trim();
-  if (!text) return;
+  if (!text && stagedFiles.length === 0) return;
   inputEl.value = '';
   inputEl.style.height = '';
 
   const shell = getShell();
   if (!shell) return;
+
+  const files = stagedFiles.length > 0 ? stagedFiles.map(f => ({
+    name: f.name, data: f.data, mime_type: f.mime_type
+  })) : undefined;
+
   if (text.startsWith('/')) {
     shell.postMessage({ protocol: PROTOCOL, version: VERSION, type: 'USER_COMMAND', payload: { command: text } }, '*');
   } else {
-    // Don't echo locally — the bridge echoes back via CONVERSATION_MESSAGE(role=user)
-    shell.postMessage({ protocol: PROTOCOL, version: VERSION, type: 'USER_MESSAGE', payload: { content: text } }, '*');
+    shell.postMessage({ protocol: PROTOCOL, version: VERSION, type: 'USER_MESSAGE', payload: { content: text || '', files: files } }, '*');
   }
+
+  stagedFiles = [];
+  renderStagingStrip();
 }
 
 inputEl.addEventListener('keydown', (e) => {
@@ -545,6 +857,161 @@
 
 sendBtn.addEventListener('click', sendMessage);
 
+// ── Search in chat ───────────────────────────────────────────────
+const searchBar   = document.getElementById('search-bar');
+const searchInput = document.getElementById('search-input');
+const searchCount = document.getElementById('search-count');
+let _searchMatches = [];
+let _searchIdx = -1;
+
+document.addEventListener('keydown', (e) => {
+  if ((e.ctrlKey || e.metaKey) && e.key === 'f') {
+    e.preventDefault();
+    searchBar.classList.add('open');
+    searchInput.focus();
+    searchInput.select();
+  }
+  if (e.key === 'Escape' && searchBar.classList.contains('open')) {
+    closeSearch();
+  }
+});
+
+searchInput.addEventListener('input', () => performSearch(searchInput.value));
+document.getElementById('search-prev').addEventListener('click', () => navigateSearch(-1));
+document.getElementById('search-next').addEventListener('click', () => navigateSearch(1));
+document.getElementById('search-close').addEventListener('click', closeSearch);
+searchInput.addEventListener('keydown', (e) => {
+  if (e.key === 'Enter') { e.preventDefault(); navigateSearch(e.shiftKey ? -1 : 1); }
+});
+
+function performSearch(query) {
+  clearHighlights();
+  _searchMatches = [];
+  _searchIdx = -1;
+  if (!query.trim()) { searchCount.textContent = ''; return; }
+
+  const q = query.toLowerCase();
+  const contentEls = messagesEl.querySelectorAll('.msg-content');
+  for (const el of contentEls) {
+    const text = el.textContent || '';
+    if (text.toLowerCase().includes(q)) {
+      // Highlight matches in this element
+      highlightInElement(el, q);
+    }
+  }
+  _searchMatches = Array.from(messagesEl.querySelectorAll('.search-highlight'));
+  searchCount.textContent = _searchMatches.length ? `${_searchMatches.length} found` : 'none';
+  if (_searchMatches.length) navigateSearch(1);
+}
+
+function highlightInElement(el, query) {
+  const walker = document.createTreeWalker(el, NodeFilter.SHOW_TEXT, null);
+  const textNodes = [];
+  while (walker.nextNode()) textNodes.push(walker.currentNode);
+  for (const node of textNodes) {
+    const text = node.textContent;
+    const lower = text.toLowerCase();
+    const idx = lower.indexOf(query);
+    if (idx === -1) continue;
+    const before = text.slice(0, idx);
+    const match  = text.slice(idx, idx + query.length);
+    const after  = text.slice(idx + query.length);
+    const span = document.createElement('span');
+    span.className = 'search-highlight';
+    span.textContent = match;
+    const parent = node.parentNode;
+    if (before) parent.insertBefore(document.createTextNode(before), node);
+    parent.insertBefore(span, node);
+    if (after) parent.insertBefore(document.createTextNode(after), node);
+    parent.removeChild(node);
+  }
+}
+
+function navigateSearch(dir) {
+  if (!_searchMatches.length) return;
+  if (_searchIdx >= 0 && _searchIdx < _searchMatches.length) {
+    _searchMatches[_searchIdx].classList.remove('current');
+  }
+  _searchIdx = (_searchIdx + dir + _searchMatches.length) % _searchMatches.length;
+  const el = _searchMatches[_searchIdx];
+  el.classList.add('current');
+  el.scrollIntoView({ block: 'center', behavior: 'smooth' });
+  searchCount.textContent = `${_searchIdx + 1}/${_searchMatches.length}`;
+}
+
+function clearHighlights() {
+  for (const span of messagesEl.querySelectorAll('.search-highlight')) {
+    const parent = span.parentNode;
+    parent.replaceChild(document.createTextNode(span.textContent), span);
+    parent.normalize();
+  }
+  _searchMatches = [];
+  _searchIdx = -1;
+}
+
+function closeSearch() {
+  searchBar.classList.remove('open');
+  clearHighlights();
+  searchCount.textContent = '';
+  searchInput.value = '';
+}
+
+// ── Attachment rendering ──────────────────────────────────────────────
+function formatBytes(bytes) {
+  if (!bytes || bytes === 0) return '';
+  if (bytes < 1024) return bytes + 'B';
+  if (bytes < 1048576) return (bytes / 1024).toFixed(1) + 'KB';
+  return (bytes / 1048576).toFixed(1) + 'MB';
+}
+
+function renderAttachments(bubble, attachments) {
+  const strip = document.createElement('div');
+  strip.className = 'attachment-strip';
+  for (const att of attachments) {
+    const kind = att.kind || 'unknown';
+    const icon = kind === 'image' ? '\uD83D\uDDBC\uFE0F' :
+                 kind === 'audio' ? '\uD83C\uDFB5' :
+                 kind === 'text'  ? '\uD83D\uDCC4' : '\uD83D\uDCCE';
+    const badge = document.createElement('div');
+    badge.className = 'att-badge';
+    badge.innerHTML = '<span class="att-icon">' + icon + '</span>' +
+      '<span class="att-name" title="' + esc(att.display_name || '') + '">' + esc(att.display_name || '') + '</span>' +
+      '<span class="att-size">' + formatBytes(att.size_bytes) + '</span>';
+    strip.appendChild(badge);
+
+    if (kind === 'image' && att.preview_url) {
+      const img = document.createElement('img');
+      img.className = 'att-image-preview';
+      img.src = att.preview_url;
+      img.alt = att.display_name || 'image';
+      img.loading = 'lazy';
+      img.addEventListener('click', function() { window.open(att.preview_url, '_blank'); });
+      strip.appendChild(img);
+    }
+    if (kind === 'text' && att.text_preview) {
+      const pre = document.createElement('div');
+      pre.className = 'att-text-preview';
+      pre.textContent = att.text_preview;
+      if (att.text_truncated) {
+        const fade = document.createElement('div');
+        fade.className = 'att-text-fade';
+        pre.appendChild(fade);
+      }
+      pre.addEventListener('click', function() { pre.classList.toggle('expanded'); });
+      strip.appendChild(pre);
+    }
+    if (kind === 'audio' && att.audio_data_uri) {
+      const audio = document.createElement('audio');
+      audio.className = 'att-audio-player';
+      audio.controls = true;
+      audio.src = att.audio_data_uri;
+      strip.appendChild(audio);
+    }
+  }
+  const contentEl = bubble.querySelector('.msg-content');
+  if (contentEl) { contentEl.after(strip); } else { bubble.appendChild(strip); }
+}
+
 // Register hljs languages if available
 if (typeof hljs !== 'undefined') {
   hljs.registerLanguage && void 0; // already done via script tags
diff --git a/src/mcp_cli/dashboard/static/views/plan-viewer.html b/src/mcp_cli/dashboard/static/views/plan-viewer.html
new file mode 100644
index 00000000..4d632809
--- /dev/null
+++ b/src/mcp_cli/dashboard/static/views/plan-viewer.html
@@ -0,0 +1,295 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0">
+<title>Plan Viewer</title>
+<style>
+*, *::before, *::after { box-sizing: border-box; margin: 0; padding: 0; }
+html, body { height: 100%; overflow: hidden; }
+:root {
+  --dash-bg: #1e1e2e; --dash-bg-surface: #262637; --dash-bg-hover: #2e2e42;
+  --dash-fg: #e0e0e0; --dash-fg-muted: #888899;
+  --dash-accent: #7aa2f7; --dash-success: #9ece6a; --dash-warning: #e0af68;
+  --dash-error: #f7768e; --dash-info: #7dcfff; --dash-border: #3b3b52;
+  --dash-font-mono: 'JetBrains Mono','Fira Code',monospace;
+  --dash-font-ui: 'Inter',-apple-system,sans-serif;
+  --dash-font-size: 13px; --dash-radius: 6px; --dash-spacing: 8px;
+}
+body {
+  background: var(--dash-bg);
+  color: var(--dash-fg);
+  font-family: var(--dash-font-ui);
+  font-size: var(--dash-font-size);
+  display: flex;
+  flex-direction: column;
+  height: 100vh;
+}
+
+/* Plan header */
+#plan-header {
+  padding: 8px 12px;
+  background: var(--dash-bg-surface);
+  border-bottom: 1px solid var(--dash-border);
+  flex-shrink: 0;
+}
+#plan-title {
+  font-size: 14px;
+  font-weight: 600;
+}
+#plan-status {
+  font-size: 11px;
+  color: var(--dash-fg-muted);
+  margin-top: 2px;
+}
+.plan-status-badge {
+  display: inline-block;
+  padding: 1px 6px;
+  border-radius: 3px;
+  font-size: 10px;
+  font-weight: 600;
+  text-transform: uppercase;
+}
+.plan-status-badge.running { background: var(--dash-accent); color: var(--dash-bg); }
+.plan-status-badge.complete { background: var(--dash-success); color: var(--dash-bg); }
+.plan-status-badge.failed { background: var(--dash-error); color: var(--dash-bg); }
+.plan-status-badge.pending { background: var(--dash-fg-muted); color: var(--dash-bg); }
+
+/* Steps list */
+#steps {
+  flex: 1;
+  overflow-y: auto;
+  padding: 8px;
+  display: flex;
+  flex-direction: column;
+  gap: 4px;
+}
+#steps::-webkit-scrollbar { width: 6px; }
+#steps::-webkit-scrollbar-track { background: transparent; }
+#steps::-webkit-scrollbar-thumb { background: var(--dash-border); border-radius: 3px; }
+
+/* Step card */
+.step-card {
+  background: var(--dash-bg-surface);
+  border: 1px solid var(--dash-border);
+  border-radius: var(--dash-radius);
+  padding: 8px 10px;
+  display: flex;
+  gap: 10px;
+  align-items: flex-start;
+}
+.step-card.running {
+  border-left: 3px solid var(--dash-accent);
+  background: var(--dash-bg-hover);
+}
+.step-card.complete { border-left: 3px solid var(--dash-success); }
+.step-card.failed   { border-left: 3px solid var(--dash-error); }
+.step-card.pending   { border-left: 3px solid var(--dash-border); }
+.step-card.skipped   { border-left: 3px solid var(--dash-fg-muted); opacity: 0.6; }
+
+.step-icon {
+  font-size: 14px;
+  width: 20px;
+  text-align: center;
+  flex-shrink: 0;
+  line-height: 1.4;
+}
+.step-body { flex: 1; min-width: 0; }
+.step-title {
+  font-size: 12px;
+  font-weight: 500;
+  margin-bottom: 2px;
+}
+.step-meta {
+  font-size: 11px;
+  color: var(--dash-fg-muted);
+  display: flex;
+  gap: 8px;
+}
+.step-tool {
+  font-family: var(--dash-font-mono);
+  color: var(--dash-accent);
+}
+.step-duration { color: var(--dash-fg-muted); }
+.step-error {
+  font-size: 11px;
+  color: var(--dash-error);
+  margin-top: 4px;
+}
+
+/* Progress bar */
+#progress-bar {
+  height: 3px;
+  background: var(--dash-border);
+  flex-shrink: 0;
+}
+#progress-fill {
+  height: 100%;
+  background: var(--dash-accent);
+  transition: width 0.3s ease;
+  width: 0%;
+}
+
+/* Empty state */
+.empty-state {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  flex: 1;
+  color: var(--dash-fg-muted);
+  font-size: 12px;
+  text-align: center;
+  padding: 24px;
+}
+
+/* Spinner animation for running step */
+@keyframes spin { to { transform: rotate(360deg); } }
+.step-card.running .step-icon { animation: spin 1s linear infinite; }
+</style>
+</head>
+<body>
+
+<div id="plan-header" style="display:none">
+  <div id="plan-title">Plan</div>
+  <div id="plan-status"></div>
+</div>
+<div id="progress-bar" style="display:none"><div id="progress-fill"></div></div>
+
+<div id="steps">
+  <div class="empty-state">No plan running. Use --plan-tools to enable planning.</div>
+</div>
+
+<script>
+'use strict';
+
+const PROTOCOL = 'mcp-dashboard';
+const VERSION  = 1;
+
+const stepsEl      = document.getElementById('steps');
+const headerEl     = document.getElementById('plan-header');
+const titleEl      = document.getElementById('plan-title');
+const statusEl     = document.getElementById('plan-status');
+const progressBar  = document.getElementById('progress-bar');
+const progressFill = document.getElementById('progress-fill');
+
+let currentPlan = null;
+
+// ── postMessage handler ─────────────────────────────────────────
+window.addEventListener('message', (evt) => {
+  const msg = evt.data;
+  if (!msg || msg.protocol !== PROTOCOL) return;
+
+  switch (msg.type) {
+    case 'INIT':
+      applyTheme(msg.payload.theme || {});
+      sendReady();
+      break;
+    case 'THEME':
+      applyTheme(msg.payload);
+      break;
+    case 'PLAN_UPDATE':
+      handlePlanUpdate(msg.payload);
+      break;
+  }
+});
+
+function getShell() {
+  if (window.parent !== window) return window.parent;
+  if (window.opener) return window.opener;
+  return null;
+}
+
+function sendReady() {
+  const shell = getShell();
+  if (!shell) return;
+  shell.postMessage({
+    protocol: PROTOCOL, version: VERSION,
+    type: 'READY',
+    payload: { name: 'Plan Viewer', icon: 'plan', accepts: ['PLAN_UPDATE'], version: 1 }
+  }, '*');
+}
+
+// ── Theme ───────────────────────────────────────────────────────
+function applyTheme(t) {
+  const r = document.documentElement;
+  const set = (k, v) => v && r.style.setProperty(k, v);
+  set('--dash-bg', t.bg); set('--dash-bg-surface', t.bg_surface);
+  set('--dash-bg-hover', t.bg_hover); set('--dash-fg', t.fg);
+  set('--dash-fg-muted', t.fg_muted); set('--dash-accent', t.accent);
+  set('--dash-success', t.success); set('--dash-warning', t.warning);
+  set('--dash-error', t.error); set('--dash-info', t.info);
+  set('--dash-border', t.border); set('--dash-font-mono', t.font_mono);
+  set('--dash-font-ui', t.font_ui); set('--dash-font-size', t.font_size);
+  set('--dash-radius', t.radius); set('--dash-spacing', t.spacing);
+}
+
+// ── Plan updates ────────────────────────────────────────────────
+function handlePlanUpdate(payload) {
+  currentPlan = payload;
+  headerEl.style.display = 'block';
+  progressBar.style.display = 'block';
+
+  titleEl.textContent = payload.title || 'Plan';
+
+  const steps = payload.steps || [];
+  const total = steps.length;
+  const completed = steps.filter(s => s.status === 'complete' || s.status === 'failed' || s.status === 'skipped').length;
+  const running = steps.filter(s => s.status === 'running').length;
+
+  // Status badge
+  const planStatus = payload.status || 'running';
+  const safePlanStatus = esc(planStatus).replace(/[^a-z]/g, '');
+  statusEl.innerHTML = `<span class="plan-status-badge ${safePlanStatus}">${esc(planStatus)}</span> ${completed}/${total} steps`;
+
+  // Progress bar
+  const pct = total > 0 ? (completed / total) * 100 : 0;
+  progressFill.style.width = pct + '%';
+  if (planStatus === 'complete') progressFill.style.background = 'var(--dash-success)';
+  else if (planStatus === 'failed') progressFill.style.background = 'var(--dash-error)';
+  else progressFill.style.background = 'var(--dash-accent)';
+
+  // Render steps
+  stepsEl.innerHTML = '';
+  for (const step of steps) {
+    stepsEl.appendChild(buildStepCard(step));
+  }
+}
+
+function buildStepCard(step) {
+  const card = document.createElement('div');
+  const status = step.status || 'pending';
+  card.className = `step-card ${status}`;
+
+  let icon = '○';
+  if (status === 'running')  icon = '◎';
+  if (status === 'complete') icon = '✓';
+  if (status === 'failed')   icon = '✗';
+  if (status === 'skipped')  icon = '−';
+
+  let meta = '';
+  if (step.tool) meta += `<span class="step-tool">${esc(step.tool)}</span>`;
+  if (step.duration != null) meta += `<span class="step-duration">${Number(step.duration).toFixed(1)}s</span>`;
+
+  let error = '';
+  if (step.error) error = `<div class="step-error">${esc(step.error)}</div>`;
+
+  card.innerHTML = `
+    <div class="step-icon">${icon}</div>
+    <div class="step-body">
+      <div class="step-title">${esc(step.title || `Step ${step.index || ''}`)}</div>
+      <div class="step-meta">${meta}</div>
+      ${error}
+    </div>
+  `;
+
+  return card;
+}
+
+function esc(s) {
+  return String(s).replace(/&/g,'&amp;').replace(/</g,'&lt;').replace(/>/g,'&gt;');
+}
+
+sendReady();
+</script>
+</body>
+</html>
diff --git a/src/mcp_cli/dashboard/static/views/tool-browser.html b/src/mcp_cli/dashboard/static/views/tool-browser.html
new file mode 100644
index 00000000..222f7ffa
--- /dev/null
+++ b/src/mcp_cli/dashboard/static/views/tool-browser.html
@@ -0,0 +1,430 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0">
+<title>Tool Browser</title>
+<style>
+*, *::before, *::after { box-sizing: border-box; margin: 0; padding: 0; }
+html, body { height: 100%; overflow: hidden; }
+:root {
+  --dash-bg: #1e1e2e; --dash-bg-surface: #262637; --dash-bg-hover: #2e2e42;
+  --dash-fg: #e0e0e0; --dash-fg-muted: #888899;
+  --dash-accent: #7aa2f7; --dash-success: #9ece6a; --dash-warning: #e0af68;
+  --dash-error: #f7768e; --dash-info: #7dcfff; --dash-border: #3b3b52;
+  --dash-font-mono: 'JetBrains Mono','Fira Code',monospace;
+  --dash-font-ui: 'Inter',-apple-system,sans-serif;
+  --dash-font-size: 13px; --dash-radius: 6px; --dash-spacing: 8px;
+}
+body {
+  background: var(--dash-bg);
+  color: var(--dash-fg);
+  font-family: var(--dash-font-ui);
+  font-size: var(--dash-font-size);
+  display: flex;
+  flex-direction: column;
+  height: 100vh;
+}
+
+/* Search bar */
+#search-bar {
+  display: flex;
+  gap: 6px;
+  padding: 6px 8px;
+  background: var(--dash-bg-surface);
+  border-bottom: 1px solid var(--dash-border);
+  flex-shrink: 0;
+}
+#search-bar input {
+  flex: 1;
+  background: var(--dash-bg);
+  border: 1px solid var(--dash-border);
+  border-radius: var(--dash-radius);
+  color: var(--dash-fg);
+  padding: 4px 8px;
+  font-size: 12px;
+  font-family: var(--dash-font-ui);
+  outline: none;
+}
+#search-bar input:focus { border-color: var(--dash-accent); }
+#tool-count {
+  font-size: 11px;
+  color: var(--dash-fg-muted);
+  align-self: center;
+  white-space: nowrap;
+}
+
+/* Tool list */
+#tools {
+  flex: 1;
+  overflow-y: auto;
+  padding: 6px;
+  display: flex;
+  flex-direction: column;
+  gap: 4px;
+}
+#tools::-webkit-scrollbar { width: 6px; }
+#tools::-webkit-scrollbar-track { background: transparent; }
+#tools::-webkit-scrollbar-thumb { background: var(--dash-border); border-radius: 3px; }
+
+/* Server group */
+.server-group {
+  margin-bottom: 4px;
+}
+.server-group-header {
+  font-size: 10px;
+  color: var(--dash-fg-muted);
+  text-transform: uppercase;
+  letter-spacing: .05em;
+  padding: 6px 4px 2px;
+  border-bottom: 1px solid var(--dash-border);
+  margin-bottom: 4px;
+}
+
+/* Tool card */
+.tool-card {
+  background: var(--dash-bg-surface);
+  border: 1px solid var(--dash-border);
+  border-left: 3px solid var(--dash-accent);
+  border-radius: var(--dash-radius);
+  overflow: hidden;
+}
+.tool-header {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  padding: 6px 8px;
+  cursor: pointer;
+}
+.tool-header:hover { background: var(--dash-bg-hover); }
+.tool-name {
+  font-family: var(--dash-font-mono);
+  font-weight: 600;
+  font-size: 12px;
+  color: var(--dash-accent);
+  flex: 1;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+.tool-tags {
+  display: flex;
+  gap: 4px;
+}
+.tool-tag {
+  font-size: 9px;
+  padding: 1px 5px;
+  border-radius: 3px;
+  background: var(--dash-bg);
+  color: var(--dash-fg-muted);
+  border: 1px solid var(--dash-border);
+}
+.tool-desc {
+  font-size: 11px;
+  color: var(--dash-fg-muted);
+  padding: 0 8px 6px;
+  line-height: 1.4;
+}
+
+/* Expanded detail */
+.tool-detail {
+  display: none;
+  padding: 8px;
+  border-top: 1px solid var(--dash-border);
+}
+.tool-card.expanded .tool-detail { display: block; }
+
+.schema-section {
+  margin-bottom: 8px;
+}
+.schema-section h4 {
+  font-size: 10px;
+  color: var(--dash-fg-muted);
+  text-transform: uppercase;
+  letter-spacing: .04em;
+  margin-bottom: 4px;
+}
+.param-row {
+  display: flex;
+  gap: 8px;
+  padding: 3px 0;
+  font-size: 11px;
+  border-bottom: 1px solid var(--dash-border);
+}
+.param-row:last-child { border-bottom: none; }
+.param-name {
+  font-family: var(--dash-font-mono);
+  color: var(--dash-accent);
+  min-width: 100px;
+}
+.param-type {
+  color: var(--dash-warning);
+  min-width: 60px;
+}
+.param-desc {
+  color: var(--dash-fg-muted);
+  flex: 1;
+}
+.param-req {
+  color: var(--dash-error);
+  font-size: 10px;
+}
+
+/* Try it form */
+.try-form {
+  margin-top: 8px;
+  padding: 8px;
+  background: var(--dash-bg);
+  border-radius: var(--dash-radius);
+}
+.try-form textarea {
+  width: 100%;
+  background: var(--dash-bg-surface);
+  border: 1px solid var(--dash-border);
+  border-radius: var(--dash-radius);
+  color: var(--dash-fg);
+  font-family: var(--dash-font-mono);
+  font-size: 11px;
+  padding: 6px;
+  resize: vertical;
+  min-height: 60px;
+  outline: none;
+}
+.try-form textarea:focus { border-color: var(--dash-accent); }
+.try-form button {
+  margin-top: 4px;
+  background: var(--dash-accent);
+  color: var(--dash-bg);
+  border: none;
+  border-radius: var(--dash-radius);
+  padding: 4px 12px;
+  font-size: 11px;
+  cursor: pointer;
+  font-family: var(--dash-font-ui);
+}
+.try-form button:hover { opacity: 0.9; }
+
+/* Empty state */
+.empty-state {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  flex: 1;
+  color: var(--dash-fg-muted);
+  font-size: 12px;
+  text-align: center;
+  padding: 24px;
+}
+</style>
+</head>
+<body>
+
+<div id="search-bar">
+  <input type="text" id="search-input" placeholder="Search tools…">
+  <span id="tool-count"></span>
+</div>
+
+<div id="tools">
+  <div class="empty-state">Waiting for tool registry…</div>
+</div>
+
+<script>
+'use strict';
+
+const PROTOCOL = 'mcp-dashboard';
+const VERSION  = 1;
+
+const toolsEl     = document.getElementById('tools');
+const searchInput = document.getElementById('search-input');
+const toolCountEl = document.getElementById('tool-count');
+
+let allTools = [];
+let filterText = '';
+
+// ── postMessage handler ─────────────────────────────────────────
+window.addEventListener('message', (evt) => {
+  const msg = evt.data;
+  if (!msg || msg.protocol !== PROTOCOL) return;
+
+  switch (msg.type) {
+    case 'INIT':
+      applyTheme(msg.payload.theme || {});
+      sendReady();
+      break;
+    case 'THEME':
+      applyTheme(msg.payload);
+      break;
+    case 'TOOL_REGISTRY':
+      allTools = msg.payload.tools || [];
+      render();
+      break;
+    case 'TOOL_RESULT':
+      handleToolResult(msg.payload);
+      break;
+  }
+});
+
+function getShell() {
+  if (window.parent !== window) return window.parent;
+  if (window.opener) return window.opener;
+  return null;
+}
+
+function sendReady() {
+  const shell = getShell();
+  if (!shell) return;
+  shell.postMessage({
+    protocol: PROTOCOL, version: VERSION,
+    type: 'READY',
+    payload: { name: 'Tool Browser', icon: 'tools', accepts: ['TOOL_REGISTRY', 'TOOL_RESULT'], version: 1 }
+  }, '*');
+}
+
+// ── Theme ───────────────────────────────────────────────────────
+function applyTheme(t) {
+  const r = document.documentElement;
+  const set = (k, v) => v && r.style.setProperty(k, v);
+  set('--dash-bg', t.bg); set('--dash-bg-surface', t.bg_surface);
+  set('--dash-bg-hover', t.bg_hover); set('--dash-fg', t.fg);
+  set('--dash-fg-muted', t.fg_muted); set('--dash-accent', t.accent);
+  set('--dash-success', t.success); set('--dash-warning', t.warning);
+  set('--dash-error', t.error); set('--dash-info', t.info);
+  set('--dash-border', t.border); set('--dash-font-mono', t.font_mono);
+  set('--dash-font-ui', t.font_ui); set('--dash-font-size', t.font_size);
+  set('--dash-radius', t.radius); set('--dash-spacing', t.spacing);
+}
+
+// ── Render ──────────────────────────────────────────────────────
+function render() {
+  toolsEl.innerHTML = '';
+  const filtered = filterText
+    ? allTools.filter(t => {
+        const hay = `${t.name} ${t.namespace} ${t.description || ''} ${(t.tags||[]).join(' ')}`.toLowerCase();
+        return hay.includes(filterText);
+      })
+    : allTools;
+
+  toolCountEl.textContent = `${filtered.length}/${allTools.length} tools`;
+
+  if (!filtered.length) {
+    toolsEl.innerHTML = `<div class="empty-state">${allTools.length ? 'No matching tools' : 'No tools available'}</div>`;
+    return;
+  }
+
+  // Group by namespace
+  const groups = new Map();
+  for (const t of filtered) {
+    const ns = t.namespace || 'unknown';
+    if (!groups.has(ns)) groups.set(ns, []);
+    groups.get(ns).push(t);
+  }
+
+  for (const [ns, tools] of groups) {
+    const group = document.createElement('div');
+    group.className = 'server-group';
+    group.innerHTML = `<div class="server-group-header">${esc(ns)} (${tools.length})</div>`;
+    for (const t of tools) {
+      group.appendChild(buildToolCard(t));
+    }
+    toolsEl.appendChild(group);
+  }
+}
+
+function buildToolCard(tool) {
+  const card = document.createElement('div');
+  card.className = 'tool-card';
+
+  const tags = (tool.tags || []).map(t => `<span class="tool-tag">${esc(t)}</span>`).join('');
+
+  card.innerHTML = `
+    <div class="tool-header">
+      <span class="tool-name">${esc(tool.name)}</span>
+      <div class="tool-tags">${tags}</div>
+    </div>
+    ${tool.description ? `<div class="tool-desc">${esc(tool.description)}</div>` : ''}
+    <div class="tool-detail">
+      ${buildSchemaSection(tool)}
+      <div class="try-form">
+        <textarea placeholder='{"key": "value"}'>{}</textarea>
+        <button data-tool="${esc(tool.name)}">Run Tool</button>
+      </div>
+    </div>
+  `;
+
+  card.querySelector('.tool-header').addEventListener('click', () => card.classList.toggle('expanded'));
+  card.querySelector('.try-form button').addEventListener('click', () => {
+    const textarea = card.querySelector('.try-form textarea');
+    try {
+      const args = JSON.parse(textarea.value || '{}');
+      executeTool(tool.name, args);
+    } catch (e) {
+      notify('error', 'Invalid JSON arguments');
+    }
+  });
+
+  return card;
+}
+
+function buildSchemaSection(tool) {
+  const params = tool.parameters;
+  if (!params || !params.properties || Object.keys(params.properties).length === 0) {
+    return '<div class="schema-section"><h4>Parameters</h4><div style="font-size:11px;color:var(--dash-fg-muted)">No parameters</div></div>';
+  }
+
+  const required = new Set(params.required || []);
+  let rows = '';
+  for (const [name, schema] of Object.entries(params.properties)) {
+    const type = schema.type || 'any';
+    const desc = schema.description || '';
+    const req = required.has(name) ? '<span class="param-req">required</span>' : '';
+    rows += `<div class="param-row">
+      <span class="param-name">${esc(name)}</span>
+      <span class="param-type">${esc(type)}</span>
+      <span class="param-desc">${esc(desc)} ${req}</span>
+    </div>`;
+  }
+
+  return `<div class="schema-section"><h4>Parameters</h4>${rows}</div>`;
+}
+
+function executeTool(toolName, args) {
+  const shell = getShell();
+  if (!shell) return;
+  shell.postMessage({
+    protocol: PROTOCOL, version: VERSION,
+    type: 'REQUEST_TOOL',
+    payload: { tool_name: toolName, arguments: args, call_id: `try-${Date.now()}` }
+  }, '*');
+  notify('info', `Executing ${toolName}…`);
+}
+
+function handleToolResult(payload) {
+  if (!payload.call_id || !payload.call_id.startsWith('try-')) return;
+  const ok = payload.success !== false;
+  notify(ok ? 'success' : 'error', `${payload.tool_name}: ${ok ? 'success' : (payload.error || 'failed')}`);
+}
+
+function notify(level, message) {
+  const shell = getShell();
+  if (!shell) return;
+  shell.postMessage({
+    protocol: PROTOCOL, version: VERSION,
+    type: 'NOTIFY',
+    payload: { level, message }
+  }, '*');
+}
+
+// ── Search ──────────────────────────────────────────────────────
+searchInput.addEventListener('input', () => {
+  filterText = searchInput.value.toLowerCase();
+  render();
+});
+
+function esc(s) {
+  return String(s).replace(/&/g,'&amp;').replace(/</g,'&lt;').replace(/>/g,'&gt;').replace(/"/g,'&quot;');
+}
+
+sendReady();
+</script>
+</body>
+</html>
diff --git a/src/mcp_cli/main.py b/src/mcp_cli/main.py
index e35b0e02..0d8c1ef7 100644
--- a/src/mcp_cli/main.py
+++ b/src/mcp_cli/main.py
@@ -165,6 +165,16 @@ def main_callback(
         "--dashboard-port",
         help="Dashboard HTTP port (0 = auto-select starting at 9120)",
     ),
+    multi_agent: bool = typer.Option(
+        False,
+        "--multi-agent",
+        help="Enable multi-agent orchestration tools (agent_spawn, agent_stop, etc.). Implies --dashboard.",
+    ),
+    attach: list[str] | None = typer.Option(
+        None,
+        "--attach",
+        help="Attach files to the first message (repeatable: --attach img.png --attach code.py).",
+    ),
 ) -> None:
     """MCP CLI - If no subcommand is given, start chat mode."""
 
@@ -395,6 +405,8 @@ async def _start_chat():
                 dashboard=dashboard,
                 no_browser=no_browser,
                 dashboard_port=dashboard_port,
+                multi_agent=multi_agent,
+                initial_attachments=attach,
             )
             logger.debug(f"Chat mode completed with success: {success}")
         except asyncio.TimeoutError:
@@ -514,6 +526,16 @@ def _chat_command(
         "--dashboard-port",
         help="Dashboard HTTP port (0 = auto-select starting at 9120)",
     ),
+    multi_agent: bool = typer.Option(
+        False,
+        "--multi-agent",
+        help="Enable multi-agent orchestration tools (agent_spawn, agent_stop, etc.). Implies --dashboard.",
+    ),
+    attach: list[str] | None = typer.Option(
+        None,
+        "--attach",
+        help="Attach files to the first message (repeatable: --attach img.png --attach code.py).",
+    ),
 ) -> None:
     """Start chat mode (same as default behavior without subcommand)."""
     # Re-configure logging based on user options
@@ -652,6 +674,8 @@ async def _start_chat():
                 dashboard=dashboard,
                 no_browser=no_browser,
                 dashboard_port=dashboard_port,
+                multi_agent=multi_agent,
+                initial_attachments=attach,
             )
             logger.debug(f"Chat mode completed with success: {success}")
         except asyncio.TimeoutError:
diff --git a/src/mcp_cli/tools/manager.py b/src/mcp_cli/tools/manager.py
index 94867364..0f7a1c68 100644
--- a/src/mcp_cli/tools/manager.py
+++ b/src/mcp_cli/tools/manager.py
@@ -178,14 +178,12 @@ async def initialize(
         """
         self._on_progress = on_progress
         try:
-            from chuk_term.ui import output
-
             self._report_progress("Loading server configuration...")
 
             # Load config and detect server types (file I/O → off event loop)
             config = await asyncio.to_thread(self._config_loader.load)
             if not config:
-                output.warning("No config found, initializing with empty toolset")
+                logger.warning("No config found, initializing with empty toolset")
                 return await self._setup_empty_toolset()
 
             self._config_loader.detect_server_types(config)
diff --git a/tests/agents/__init__.py b/tests/agents/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/agents/test_config.py b/tests/agents/test_config.py
new file mode 100644
index 00000000..9b0e4365
--- /dev/null
+++ b/tests/agents/test_config.py
@@ -0,0 +1,90 @@
+# tests/agents/test_config.py
+"""Unit tests for AgentConfig."""
+
+from __future__ import annotations
+
+import pytest
+
+from mcp_cli.agents.config import AgentConfig
+
+
+class TestAgentConfigDefaults:
+    def test_minimal(self):
+        cfg = AgentConfig(agent_id="a1")
+        assert cfg.agent_id == "a1"
+        assert cfg.name == ""
+        assert cfg.role == ""
+        assert cfg.model is None
+        assert cfg.provider is None
+        assert cfg.system_prompt is None
+        assert cfg.allowed_tools is None
+        assert cfg.denied_tools is None
+        assert cfg.allowed_servers is None
+        assert cfg.tool_timeout_override is None
+        assert cfg.auto_approve_tools is None
+        assert cfg.parent_agent_id is None
+        assert cfg.initial_prompt == ""
+
+    def test_full(self):
+        cfg = AgentConfig(
+            agent_id="agent-research",
+            name="Researcher",
+            role="research",
+            model="gpt-4o",
+            provider="openai",
+            system_prompt="You are a research assistant.",
+            allowed_tools=["web_search", "read_file"],
+            denied_tools=["write_file"],
+            allowed_servers=["server-1"],
+            tool_timeout_override=30.0,
+            auto_approve_tools=["web_search"],
+            parent_agent_id="agent-main",
+            initial_prompt="Find the MCP spec.",
+        )
+        assert cfg.name == "Researcher"
+        assert cfg.role == "research"
+        assert cfg.model == "gpt-4o"
+        assert cfg.provider == "openai"
+        assert cfg.allowed_tools == ["web_search", "read_file"]
+        assert cfg.denied_tools == ["write_file"]
+        assert cfg.parent_agent_id == "agent-main"
+        assert cfg.initial_prompt == "Find the MCP spec."
+
+
+class TestAgentConfigSerialization:
+    def test_dict_roundtrip(self):
+        cfg = AgentConfig(agent_id="x", name="X", role="worker", model="gpt-4")
+        d = cfg.model_dump()
+        assert d["agent_id"] == "x"
+        assert d["role"] == "worker"
+        cfg2 = AgentConfig(**d)
+        assert cfg2 == cfg
+
+    def test_json_roundtrip(self):
+        cfg = AgentConfig(
+            agent_id="a",
+            name="A",
+            allowed_tools=["t1", "t2"],
+        )
+        json_str = cfg.model_dump_json()
+        cfg2 = AgentConfig.model_validate_json(json_str)
+        assert cfg2 == cfg
+
+
+class TestAgentConfigImport:
+    def test_importable_from_package(self):
+        from mcp_cli.agents import AgentConfig as AC
+
+        assert AC is AgentConfig
+
+
+class TestAgentConfigValidation:
+    def test_agent_id_required(self):
+        with pytest.raises(Exception):
+            AgentConfig()  # type: ignore[call-arg]
+
+    def test_extra_fields_ignored(self):
+        """Extra fields are silently ignored by Pydantic v2 default."""
+        cfg = AgentConfig(agent_id="x", unknown_field="ignored")  # type: ignore[call-arg]
+        assert cfg.agent_id == "x"
+        assert not hasattr(cfg, "unknown_field")
diff --git a/tests/agents/test_group_store.py b/tests/agents/test_group_store.py
new file mode 100644
index 00000000..218071fd
--- /dev/null
+++ b/tests/agents/test_group_store.py
@@ -0,0 +1,171 @@
+# tests/agents/test_group_store.py
+"""Unit tests for group save/restore."""
+
+from __future__ import annotations
+
+import json
+from unittest.mock import MagicMock
+
+import pytest
+
+from mcp_cli.agents.config import AgentConfig
+from mcp_cli.agents.group_store import (
+    list_groups,
+    load_group_manifest,
+    save_group,
+)
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+
+def _make_agent_manager(*agent_configs):
+    """Create a mock AgentManager with the given agent configs."""
+    mgr = MagicMock()
+    snapshots = {}
+    statuses = []
+
+    for cfg in agent_configs:
+        ctx = MagicMock()
+        ctx.agent_id = cfg.agent_id
+        ctx.session_id = f"session-{cfg.agent_id}"
+        ctx.conversation_history = []
+        snapshots[cfg.agent_id] = {"config": cfg, "context": ctx}
+        statuses.append(
+            {
+                "agent_id": cfg.agent_id,
+                "name": cfg.name,
+                "role": cfg.role,
+                "status": "active",
+            }
+        )
+
+    mgr.list_agents.return_value = statuses
+    mgr.get_agent_snapshot.side_effect = lambda aid: snapshots.get(aid)
+    return mgr
+
+
+# ---------------------------------------------------------------------------
+# TestSaveGroup
+# ---------------------------------------------------------------------------
+
+
+class TestSaveGroup:
+    @pytest.mark.asyncio
+    async def test_save_empty_group(self, tmp_path):
+        mgr = _make_agent_manager()
+        result = await save_group(mgr, description="empty", group_dir=tmp_path)
+        assert result == tmp_path
+        manifest = json.loads((tmp_path / "group.json").read_text())
+        assert manifest["description"] == "empty"
+        assert manifest["agents"] == []
+
+    @pytest.mark.asyncio
+    async def test_save_with_agents(self, tmp_path):
+        cfg_a = AgentConfig(agent_id="a", name="Agent A", role="worker")
+        cfg_b = AgentConfig(agent_id="b", name="Agent B", role="researcher")
+        mgr = _make_agent_manager(cfg_a, cfg_b)
+
+        result = await save_group(mgr, description="test group", group_dir=tmp_path)
+        manifest = json.loads((result / "group.json").read_text())
+        assert len(manifest["agents"]) == 2
+        agent_ids = {a["agent_id"] for a in manifest["agents"]}
+        assert agent_ids == {"a", "b"}
+
+        # Check session files exist
+        assert (tmp_path / "a" / "session.json").exists()
+        assert (tmp_path / "b" / "session.json").exists()
+
+    @pytest.mark.asyncio
+    async def test_save_preserves_config_fields(self, tmp_path):
+        cfg = AgentConfig(
+            agent_id="x",
+            name="X",
+            role="coder",
+            model="gpt-4",
+            provider="openai",
+            parent_agent_id="main",
+        )
+        mgr = _make_agent_manager(cfg)
+        await save_group(mgr, group_dir=tmp_path)
+
+        manifest = json.loads((tmp_path / "group.json").read_text())
+        agent = manifest["agents"][0]
+        assert agent["agent_id"] == "x"
+        assert agent["role"] == "coder"
+        assert agent["model"] == "gpt-4"
+        assert agent["parent_agent_id"] == "main"
+
+
+# ---------------------------------------------------------------------------
+# TestLoadGroupManifest
+# ---------------------------------------------------------------------------
+
+
+class TestLoadGroupManifest:
+    def test_load_valid(self, tmp_path):
+        data = {
+            "group_id": "g1",
+            "created_at": "2026-01-01T00:00:00Z",
+            "description": "test",
+            "agents": [],
+        }
+        (tmp_path / "group.json").write_text(json.dumps(data))
+        manifest = load_group_manifest(tmp_path)
+        assert manifest["group_id"] == "g1"
+        assert manifest["description"] == "test"
+
+    def test_load_missing_raises(self, tmp_path):
+        with pytest.raises(FileNotFoundError):
+            load_group_manifest(tmp_path)
+
+
+# ---------------------------------------------------------------------------
+# TestListGroups
+# ---------------------------------------------------------------------------
+
+
+class TestListGroups:
+    def test_empty_dir(self, tmp_path):
+        assert list_groups(tmp_path) == []
+
+    def test_nonexistent_dir(self, tmp_path):
+        assert list_groups(tmp_path / "nope") == []
+
+    def test_lists_groups(self, tmp_path):
+        # Create two groups
+        for name in ["group-1", "group-2"]:
+            d = tmp_path / name
+            d.mkdir()
+            data = {
+                "group_id": name,
+                "description": f"desc-{name}",
+                "created_at": "2026-01-01",
+                "agents": [{"agent_id": "a"}],
+            }
+            (d / "group.json").write_text(json.dumps(data))
+
+        groups = list_groups(tmp_path)
+        assert len(groups) == 2
+        ids = {g["group_id"] for g in groups}
+        assert ids == {"group-1", "group-2"}
+        for g in groups:
+            assert g["agent_count"] == 1
+
+    def test_skips_invalid(self, tmp_path):
+        # Create one valid and one invalid group
+        valid = tmp_path / "valid"
+        valid.mkdir()
+        (valid / "group.json").write_text(
+            json.dumps({"group_id": "valid", "agents": []})
+        )
+
+        invalid = tmp_path / "invalid"
+        invalid.mkdir()
+        (invalid / "group.json").write_text("not json")
+
+        groups = list_groups(tmp_path)
+        assert len(groups) == 1
+        assert groups[0]["group_id"] == "valid"
diff --git a/tests/agents/test_loop.py b/tests/agents/test_loop.py
new file mode 100644
index 00000000..c8e85ac8
--- /dev/null
+++ b/tests/agents/test_loop.py
@@ -0,0 +1,254 @@
+# tests/agents/test_loop.py
+"""Unit tests for the headless agent loop."""
+
+from __future__ import annotations
+
+import asyncio
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import pytest
+
+from mcp_cli.agents.loop import run_agent_loop
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+
+def _make_context(agent_id: str = "test-agent"):
+    """Return a mock ChatContext."""
+    ctx = MagicMock()
+    ctx.agent_id = agent_id
+    ctx.exit_requested = False
+    ctx.conversation_history = []
+    ctx.dashboard_bridge = None
+    ctx.add_user_message = AsyncMock()
+    return ctx
+
+
+def _make_ui(agent_id: str = "test-agent"):
+    from mcp_cli.agents.headless_ui import HeadlessUIManager
+
+    return HeadlessUIManager(agent_id=agent_id)
+
+
+# ---------------------------------------------------------------------------
+# Tests
+# ---------------------------------------------------------------------------
+
+
+class TestRunAgentLoop:
+    @pytest.mark.asyncio
+    async def test_exit_on_stop_signal(self):
+        """Loop exits on '__stop__' message."""
+        ctx = _make_context()
+        ui = _make_ui()
+        q: asyncio.Queue = asyncio.Queue()
+        done = asyncio.Event()
+
+        await q.put("__stop__")
+
+        with patch("mcp_cli.chat.conversation.ConversationProcessor"):
+            result = await run_agent_loop(ctx, ui, q, done)
+
+        assert done.is_set()
+        assert isinstance(result, str)
+
+    @pytest.mark.asyncio
+    async def test_exit_on_quit(self):
+        """Loop exits on 'quit' message."""
+        ctx = _make_context()
+        ui = _make_ui()
+        q: asyncio.Queue = asyncio.Queue()
+        done = asyncio.Event()
+
+        await q.put("quit")
+
+        with patch("mcp_cli.chat.conversation.ConversationProcessor"):
+            await run_agent_loop(ctx, ui, q, done)
+
+        assert done.is_set()
+
+    @pytest.mark.asyncio
+    async def test_skip_empty_and_none(self):
+        """Loop skips None and empty messages."""
+        ctx = _make_context()
+        ui = _make_ui()
+        q: asyncio.Queue = asyncio.Queue()
+        done = asyncio.Event()
+
+        await q.put(None)
+        await q.put("")
+        await q.put("   ")
+        await q.put("exit")
+
+        with patch("mcp_cli.chat.conversation.ConversationProcessor"):
+            await run_agent_loop(ctx, ui, q, done)
+
+        assert done.is_set()
+        ctx.add_user_message.assert_not_called()
+
+    @pytest.mark.asyncio
+    async def test_processes_prompt(self):
+        """Loop processes a normal prompt via ConversationProcessor."""
+        ctx = _make_context()
+        ui = _make_ui()
+        q: asyncio.Queue = asyncio.Queue()
+        done = asyncio.Event()
+
+        await q.put("Hello agent")
+        await q.put("exit")
+
+        mock_convo = MagicMock()
+        mock_convo.process_conversation = AsyncMock()
+
+        with patch(
+            "mcp_cli.chat.conversation.ConversationProcessor",
+            return_value=mock_convo,
+        ):
+            await run_agent_loop(ctx, ui, q, done)
+
+        ctx.add_user_message.assert_called_once_with("Hello agent")
+        mock_convo.process_conversation.assert_called_once()
+        assert done.is_set()
+
+    @pytest.mark.asyncio
+    async def test_captures_last_response(self):
+        """Loop captures the last assistant response from history."""
+        ctx = _make_context()
+        ctx.conversation_history = [
+            {"role": "user", "content": "hi"},
+            {"role": "assistant", "content": "Hello there!"},
+        ]
+        ui = _make_ui()
+        q: asyncio.Queue = asyncio.Queue()
+        done = asyncio.Event()
+
+        await q.put("hi")
+        await q.put("exit")
+
+        mock_convo = MagicMock()
+        mock_convo.process_conversation = AsyncMock()
+
+        with patch(
+            "mcp_cli.chat.conversation.ConversationProcessor",
+            return_value=mock_convo,
+        ):
+            result = await run_agent_loop(ctx, ui, q, done)
+
+        assert "Hello there!" in result
+
+    @pytest.mark.asyncio
+    async def test_handles_cancellation(self):
+        """Loop handles CancelledError gracefully."""
+        ctx = _make_context()
+        ui = _make_ui()
+        q: asyncio.Queue = asyncio.Queue()
+        done = asyncio.Event()
+
+        mock_convo = MagicMock()
+        mock_convo.process_conversation = AsyncMock(
+            side_effect=asyncio.CancelledError()
+        )
+
+        await q.put("do something")
+
+        with patch(
+            "mcp_cli.chat.conversation.ConversationProcessor",
+            return_value=mock_convo,
+        ):
+            await run_agent_loop(ctx, ui, q, done)
+
+        assert done.is_set()
+
+    @pytest.mark.asyncio
+    async def test_handles_exception(self):
+        """Loop handles unexpected exceptions."""
+        ctx = _make_context()
+        ui = _make_ui()
+        q: asyncio.Queue = asyncio.Queue()
+        done = asyncio.Event()
+
+        mock_convo = MagicMock()
+        mock_convo.process_conversation = AsyncMock(side_effect=RuntimeError("boom"))
+
+        await q.put("do something")
+
+        with patch(
+            "mcp_cli.chat.conversation.ConversationProcessor",
+            return_value=mock_convo,
+        ):
+            result = await run_agent_loop(ctx, ui, q, done)
+
+        assert done.is_set()
+        assert "Error" in result
+
+    @pytest.mark.asyncio
+    async def test_exit_requested_stops_loop(self):
+        """Loop exits when context.exit_requested is True."""
+        ctx = _make_context()
+        ctx.exit_requested = True
+        ui = _make_ui()
+        q: asyncio.Queue = asyncio.Queue()
+        done = asyncio.Event()
+
+        with patch("mcp_cli.chat.conversation.ConversationProcessor"):
+            result = await run_agent_loop(ctx, ui, q, done)
+
+        assert done.is_set()
+        assert result == "Agent completed."
+
+    @pytest.mark.asyncio
+    async def test_dashboard_bridge_wired(self):
+        """Loop wires dashboard bridge input queue and broadcasts messages."""
+        ctx = _make_context()
+        bridge = MagicMock()
+        bridge.set_input_queue = MagicMock()
+        bridge.on_message = AsyncMock()
+        ctx.dashboard_bridge = bridge
+
+        ui = _make_ui()
+        q: asyncio.Queue = asyncio.Queue()
+        done = asyncio.Event()
+
+        await q.put("hello")
+        await q.put("exit")
+
+        mock_convo = MagicMock()
+        mock_convo.process_conversation = AsyncMock()
+
+        with patch(
+            "mcp_cli.chat.conversation.ConversationProcessor",
+            return_value=mock_convo,
+        ):
+            await run_agent_loop(ctx, ui, q, done)
+
+        bridge.set_input_queue.assert_called_once_with(q)
+        bridge.on_message.assert_called_once_with("user", "hello")
+
+    @pytest.mark.asyncio
+    async def test_max_response_length_truncated(self):
+        """Loop truncates last_response to 500 chars."""
+        ctx = _make_context()
+        long_response = "x" * 1000
+        ctx.conversation_history = [
+            {"role": "assistant", "content": long_response},
+        ]
+        ui = _make_ui()
+        q: asyncio.Queue = asyncio.Queue()
+        done = asyncio.Event()
+
+        await q.put("go")
+        await q.put("exit")
+
+        mock_convo = MagicMock()
+        mock_convo.process_conversation = AsyncMock()
+
+        with patch(
+            "mcp_cli.chat.conversation.ConversationProcessor",
+            return_value=mock_convo,
+        ):
+            result = await run_agent_loop(ctx, ui, q, done)
+
+        assert len(result) == 500
diff --git a/tests/agents/test_manager.py b/tests/agents/test_manager.py
new file mode 100644
index 00000000..19f74e22
--- /dev/null
+++ b/tests/agents/test_manager.py
@@ -0,0 +1,323 @@
+# tests/agents/test_manager.py
+"""Unit tests for AgentManager."""
+
+from __future__ import annotations
+
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import pytest
+
+from mcp_cli.agents.config import AgentConfig
+from mcp_cli.agents.headless_ui import HeadlessUIManager
+from mcp_cli.agents.manager import MAX_AGENTS, AgentManager
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+
+def _make_router():
+    from mcp_cli.dashboard.router import AgentRouter
+
+    server = MagicMock()
+    server.broadcast = AsyncMock()
+    server.send_to_client = AsyncMock()
+    server.has_clients = False
+    server.on_browser_message = None
+    server.on_client_connected = None
+    server.on_client_disconnected = None
+    return AgentRouter(server)
+
+
+def _make_tool_manager():
+    tm = MagicMock()
+    tm.list_tools = MagicMock(return_value=[])
+    tm.execute_tool = AsyncMock()
+    tm.close = AsyncMock()
+    return tm
+
+
+def _make_model_manager():
+    mm = MagicMock()
+    mm.active_provider = "test"
+    mm.active_model = "test-model"
+    return mm
+
+
+# ---------------------------------------------------------------------------
+# TestHeadlessUIManager
+# ---------------------------------------------------------------------------
+
+
+class TestHeadlessUIManager:
+    def test_defaults(self):
+        ui = HeadlessUIManager(agent_id="a1")
+        assert ui.agent_id == "a1"
+        assert ui.verbose_mode is False
+        assert ui.is_streaming_response is False
+
+    @pytest.mark.asyncio
+    async def test_auto_approve(self):
+        ui = HeadlessUIManager()
+        assert await ui.do_confirm_tool_execution("tool", {}) is True
+
+    @pytest.mark.asyncio
+    async def test_start_stop_streaming(self):
+        ui = HeadlessUIManager()
+        await ui.start_streaming_response()
+        await ui.stop_streaming_response()
+        assert ui.streaming_handler is None
+
+    @pytest.mark.asyncio
+    async def test_tool_lifecycle(self):
+        ui = HeadlessUIManager()
+        ui.print_tool_call("test_tool", {"a": 1})
+        await ui.start_tool_execution("test_tool", {"a": 1})
+        await ui.finish_tool_execution(result="ok", success=True)
+        await ui.finish_tool_calls()
+
+    @pytest.mark.asyncio
+    async def test_cleanup(self):
+        ui = HeadlessUIManager()
+        await ui.cleanup()
+
+
+# ---------------------------------------------------------------------------
+# TestAgentManagerBasic
+# ---------------------------------------------------------------------------
+
+
+class TestAgentManagerBasic:
+    def test_init(self):
+        tm = _make_tool_manager()
+        router = _make_router()
+        mgr = AgentManager(tm, router)
+        assert mgr.list_agents() == []
+        assert mgr.list_artifacts() == []
+
+    @pytest.mark.asyncio
+    async def test_spawn_duplicate_raises(self):
+        tm = _make_tool_manager()
+        router = _make_router()
+        mgr = AgentManager(tm, router)
+
+        # Mock spawn internals — patch at the source modules since
+        # manager.py uses lazy imports inside spawn_agent()
+        mock_ctx = MagicMock()
+        mock_ctx.agent_id = "a"
+        mock_ctx.initialize = AsyncMock(return_value=True)
+        mock_ctx.openai_tools = []
+        mock_ctx.conversation_history = []
+        mock_ctx.exit_requested = True  # stop loop immediately
+        mock_ctx.dashboard_bridge = None
+        mock_ctx._system_prompt = ""
+        mock_ctx._system_prompt_dirty = False
+
+        with (
+            patch(
+                "mcp_cli.chat.chat_context.ChatContext.create",
+                return_value=mock_ctx,
+            ),
+            patch("mcp_cli.dashboard.bridge.DashboardBridge") as MockBridge,
+        ):
+            mock_bridge = MagicMock()
+            mock_bridge.set_context = MagicMock()
+            mock_bridge.set_input_queue = MagicMock()
+            MockBridge.return_value = mock_bridge
+
+            await mgr.spawn_agent(AgentConfig(agent_id="a", name="A"))
+            with pytest.raises(ValueError, match="already exists"):
+                await mgr.spawn_agent(AgentConfig(agent_id="a", name="A2"))
+
+            await mgr.stop_all()
+
+    @pytest.mark.asyncio
+    async def test_stop_nonexistent(self):
+        mgr = AgentManager(_make_tool_manager(), _make_router())
+        assert await mgr.stop_agent("no-such") is False
+
+
+# ---------------------------------------------------------------------------
+# TestAgentManagerArtifacts
+# ---------------------------------------------------------------------------
+
+
+class TestAgentManagerArtifacts:
+    def test_publish_and_get(self):
+        mgr = AgentManager(_make_tool_manager(), _make_router())
+        mgr.publish_artifact("agent-a", "results", {"data": [1, 2, 3]})
+        assert mgr.get_artifact("results") == {"data": [1, 2, 3]}
+
+    def test_get_nonexistent(self):
+        mgr = AgentManager(_make_tool_manager(), _make_router())
+        assert mgr.get_artifact("nope") is None
+
+    def test_list_artifacts(self):
+        mgr = AgentManager(_make_tool_manager(), _make_router())
+        mgr.publish_artifact("a", "art1", "content1")
+        mgr.publish_artifact("b", "art2", "content2")
+        arts = mgr.list_artifacts()
+        assert len(arts) == 2
+        ids = {a["artifact_id"] for a in arts}
+        assert ids == {"art1", "art2"}
+
+
+# ---------------------------------------------------------------------------
+# TestAgentManagerMessaging
+# ---------------------------------------------------------------------------
+
+
+class TestAgentManagerMessaging:
+    @pytest.mark.asyncio
+    async def test_send_to_nonexistent_returns_false(self):
+        mgr = AgentManager(_make_tool_manager(), _make_router())
+        assert await mgr.send_message("a", "b", "hello") is False
+
+    @pytest.mark.asyncio
+    async def test_get_messages_empty(self):
+        mgr = AgentManager(_make_tool_manager(), _make_router())
+        assert await mgr.get_messages("nonexistent") == []
+
+
+# ---------------------------------------------------------------------------
+# TestAgentManagerStatus
+# ---------------------------------------------------------------------------
+
+
+class TestAgentManagerStatus:
+    def test_get_status_nonexistent(self):
+        mgr = AgentManager(_make_tool_manager(), _make_router())
+        assert mgr.get_agent_status("nope") is None
+
+
+# ---------------------------------------------------------------------------
+# TestAgentManagerMaxAgents
+# ---------------------------------------------------------------------------
+
+
+class TestAgentManagerMaxAgents:
+    def test_max_agents_constant(self):
+        assert MAX_AGENTS == 10
+
+
+# ---------------------------------------------------------------------------
+# Helper: spawn a mock agent into the manager
+# ---------------------------------------------------------------------------
+
+
+async def _spawn_mock_agent(mgr, agent_id="a", name="A", **kwargs):
+    """Spawn a mock agent, returns the manager."""
+    mock_ctx = MagicMock()
+    mock_ctx.agent_id = agent_id
+    mock_ctx.initialize = AsyncMock(return_value=True)
+    mock_ctx.openai_tools = []
+    mock_ctx.conversation_history = []
+    mock_ctx.exit_requested = True  # stop loop immediately
+    mock_ctx.dashboard_bridge = None
+    mock_ctx._system_prompt = ""
+    mock_ctx._system_prompt_dirty = False
+
+    with (
+        patch(
+            "mcp_cli.chat.chat_context.ChatContext.create",
+            return_value=mock_ctx,
+        ),
+        patch("mcp_cli.dashboard.bridge.DashboardBridge") as MockBridge,
+    ):
+        mock_bridge = MagicMock()
+        mock_bridge.set_context = MagicMock()
+        mock_bridge.set_input_queue = MagicMock()
+        MockBridge.return_value = mock_bridge
+
+        cfg = AgentConfig(agent_id=agent_id, name=name, **kwargs)
+        await mgr.spawn_agent(cfg)
+
+    return mgr
+
+
+# ---------------------------------------------------------------------------
+# TestAgentManagerLifecycle (with spawned agent)
+# ---------------------------------------------------------------------------
+
+
+class TestAgentManagerLifecycle:
+    @pytest.mark.asyncio
+    async def test_spawn_and_list(self):
+        mgr = AgentManager(_make_tool_manager(), _make_router())
+        await _spawn_mock_agent(mgr, "x", "Agent X", role="worker")
+        agents = mgr.list_agents()
+        assert len(agents) == 1
+        assert agents[0]["agent_id"] == "x"
+        assert agents[0]["name"] == "Agent X"
+        await mgr.stop_all()
+
+    @pytest.mark.asyncio
+    async def test_stop_agent_returns_true(self):
+        mgr = AgentManager(_make_tool_manager(), _make_router())
+        await _spawn_mock_agent(mgr)
+        assert await mgr.stop_agent("a") is True
+        assert mgr.list_agents() == []
+
+    @pytest.mark.asyncio
+    async def test_get_agent_snapshot(self):
+        mgr = AgentManager(_make_tool_manager(), _make_router())
+        await _spawn_mock_agent(mgr, "s1", "Snap Agent")
+        snap = mgr.get_agent_snapshot("s1")
+        assert snap is not None
+        assert snap["config"].agent_id == "s1"
+        assert snap["context"] is not None
+        await mgr.stop_all()
+
+    @pytest.mark.asyncio
+    async def test_get_agent_snapshot_nonexistent(self):
+        mgr = AgentManager(_make_tool_manager(), _make_router())
+        assert mgr.get_agent_snapshot("nope") is None
+
+
+# ---------------------------------------------------------------------------
+# TestAgentManagerMessagingWithAgent
+# ---------------------------------------------------------------------------
+
+
+class TestAgentManagerMessagingWithAgent:
+    @pytest.mark.asyncio
+    async def test_send_message_injects_into_queue(self):
+        mgr = AgentManager(_make_tool_manager(), _make_router())
+        await _spawn_mock_agent(mgr, "target", "Target")
+
+        result = await mgr.send_message("sender", "target", "hello world")
+        assert result is True
+
+        # Verify the message is in the agent's input queue
+        handle = mgr._agents["target"]
+        msg = handle.input_queue.get_nowait()
+        assert "[Message from sender]" in msg
+        assert "hello world" in msg
+        await mgr.stop_all()
+
+
+# ---------------------------------------------------------------------------
+# TestAgentManagerWait
+# ---------------------------------------------------------------------------
+
+
+class TestAgentManagerWait:
+    @pytest.mark.asyncio
+    async def test_wait_unknown_returns_error(self):
+        mgr = AgentManager(_make_tool_manager(), _make_router())
+        result = await mgr.wait_agent("nonexistent")
+        assert "error" in result
+
+    @pytest.mark.asyncio
+    async def test_wait_timeout(self):
+        mgr = AgentManager(_make_tool_manager(), _make_router())
+        await _spawn_mock_agent(mgr, "w1", "Waiter")
+        # The done_event is not set by mock, so wait should timeout
+        # But the agent loop exits immediately (exit_requested=True),
+        # so let's just test with a very short timeout
+        # The done_event might already be set by the loop finishing
+        result = await mgr.wait_agent("w1", timeout=0.01)
+        assert result["agent_id"] == "w1"
+        assert result["status"] in ("completed", "timeout")
+        await mgr.stop_all()
diff --git a/tests/agents/test_tools.py b/tests/agents/test_tools.py
new file mode 100644
index 00000000..e9074bc6
--- /dev/null
+++ b/tests/agents/test_tools.py
@@ -0,0 +1,166 @@
+# tests/agents/test_tools.py
+"""Unit tests for agent orchestration tool definitions and handler."""
+
+from __future__ import annotations
+
+import json
+from unittest.mock import AsyncMock, MagicMock
+
+import pytest
+
+from mcp_cli.agents.tools import (
+    _AGENT_TOOL_NAMES,
+    get_agent_tools_as_dicts,
+    handle_agent_tool,
+)
+
+
+# ---------------------------------------------------------------------------
+# TestToolDefinitions
+# ---------------------------------------------------------------------------
+
+
+class TestToolDefinitions:
+    def test_tool_count(self):
+        tools = get_agent_tools_as_dicts()
+        assert len(tools) == 6
+
+    def test_tool_names_match_frozenset(self):
+        tools = get_agent_tools_as_dicts()
+        names = {t["function"]["name"] for t in tools}
+        assert names == _AGENT_TOOL_NAMES
+
+    def test_all_have_function_key(self):
+        tools = get_agent_tools_as_dicts()
+        for t in tools:
+            assert t["type"] == "function"
+            assert "name" in t["function"]
+            assert "description" in t["function"]
+            assert "parameters" in t["function"]
+
+    def test_spawn_has_required_fields(self):
+        tools = get_agent_tools_as_dicts()
+        spawn = next(t for t in tools if t["function"]["name"] == "agent_spawn")
+        required = spawn["function"]["parameters"]["required"]
+        assert "name" in required
+        assert "initial_prompt" in required
+
+
+# ---------------------------------------------------------------------------
+# TestHandleAgentTool
+# ---------------------------------------------------------------------------
+
+
+class TestHandleAgentTool:
+    @pytest.mark.asyncio
+    async def test_unknown_tool(self):
+        mgr = MagicMock()
+        result = await handle_agent_tool("unknown_tool", {}, mgr)
+        data = json.loads(result)
+        assert "error" in data
+
+    @pytest.mark.asyncio
+    async def test_agent_stop(self):
+        mgr = MagicMock()
+        mgr.stop_agent = AsyncMock(return_value=True)
+        result = await handle_agent_tool("agent_stop", {"agent_id": "a1"}, mgr)
+        data = json.loads(result)
+        assert data["success"] is True
+        mgr.stop_agent.assert_awaited_once_with("a1")
+
+    @pytest.mark.asyncio
+    async def test_agent_stop_missing_id(self):
+        mgr = MagicMock()
+        result = await handle_agent_tool("agent_stop", {}, mgr)
+        data = json.loads(result)
+        assert "error" in data
+
+    @pytest.mark.asyncio
+    async def test_agent_message(self):
+        mgr = MagicMock()
+        mgr.send_message = AsyncMock(return_value=True)
+        result = await handle_agent_tool(
+            "agent_message",
+            {"agent_id": "a1", "content": "hello"},
+            mgr,
+            caller_agent_id="supervisor",
+        )
+        data = json.loads(result)
+        assert data["success"] is True
+        mgr.send_message.assert_awaited_once_with("supervisor", "a1", "hello")
+
+    @pytest.mark.asyncio
+    async def test_agent_message_missing_fields(self):
+        mgr = MagicMock()
+        result = await handle_agent_tool("agent_message", {}, mgr)
+        data = json.loads(result)
+        assert "error" in data
+
+    @pytest.mark.asyncio
+    async def test_agent_wait(self):
+        mgr = MagicMock()
+        mgr.wait_agent = AsyncMock(
+            return_value={"agent_id": "a1", "status": "completed", "summary": "done"}
+        )
+        result = await handle_agent_tool("agent_wait", {"agent_id": "a1"}, mgr)
+        data = json.loads(result)
+        assert data["status"] == "completed"
+
+    @pytest.mark.asyncio
+    async def test_agent_status(self):
+        mgr = MagicMock()
+        mgr.get_agent_status.return_value = {
+            "agent_id": "a1",
+            "status": "active",
+            "name": "Test",
+        }
+        result = await handle_agent_tool("agent_status", {"agent_id": "a1"}, mgr)
+        data = json.loads(result)
+        assert data["status"] == "active"
+
+    @pytest.mark.asyncio
+    async def test_agent_status_unknown(self):
+        mgr = MagicMock()
+        mgr.get_agent_status.return_value = None
+        result = await handle_agent_tool("agent_status", {"agent_id": "nope"}, mgr)
+        data = json.loads(result)
+        assert "error" in data
+
+    @pytest.mark.asyncio
+    async def test_agent_list(self):
+        mgr = MagicMock()
+        mgr.list_agents.return_value = [
+            {"agent_id": "a", "status": "active"},
+            {"agent_id": "b", "status": "completed"},
+        ]
+        result = await handle_agent_tool("agent_list", {}, mgr)
+        data = json.loads(result)
+        assert len(data["agents"]) == 2
+
+    @pytest.mark.asyncio
+    async def test_agent_spawn(self):
+        mgr = MagicMock()
+        mgr.spawn_agent = AsyncMock(return_value="agent-research")
+        result = await handle_agent_tool(
+            "agent_spawn",
+            {"name": "Research", "initial_prompt": "Find docs"},
+            mgr,
+            caller_agent_id="main",
+        )
+        data = json.loads(result)
+        assert data["success"] is True
+        assert data["agent_id"] == "agent-research"
+        # Verify spawn was called with an AgentConfig
+        mgr.spawn_agent.assert_awaited_once()
+        config = mgr.spawn_agent.call_args[0][0]
+        assert config.name == "Research"
+        assert config.parent_agent_id == "main"
+
+    @pytest.mark.asyncio
+    async def test_handler_catches_exceptions(self):
+        mgr = MagicMock()
+        mgr.stop_agent = AsyncMock(side_effect=RuntimeError("boom"))
+        result = await handle_agent_tool("agent_stop", {"agent_id": "a1"}, mgr)
+        data = json.loads(result)
+        assert "error" in data
+        assert "boom" in data["error"]
diff --git a/tests/chat/test_agent_tool_state.py b/tests/chat/test_agent_tool_state.py
new file mode 100644
index 00000000..cec7e1bc
--- /dev/null
+++ b/tests/chat/test_agent_tool_state.py
@@ -0,0 +1,76 @@
+# tests/chat/test_agent_tool_state.py
+"""Unit tests for per-agent tool state isolation."""
+
+from __future__ import annotations
+
+from mcp_cli.chat.agent_tool_state import (
+    _reset_registry,
+    get_agent_tool_state,
+    remove_agent_tool_state,
+)
+
+
+class TestAgentToolStateRegistry:
+    """Tests for the agent_tool_state registry."""
+
+    def setup_method(self):
+        _reset_registry()
+
+    def teardown_method(self):
+        _reset_registry()
+
+    def test_default_returns_global_singleton(self):
+        """'default' agent_id delegates to the upstream singleton."""
+        from chuk_ai_session_manager.guards import get_tool_state
+
+        global_ts = get_tool_state()
+        default_ts = get_agent_tool_state("default")
+        assert default_ts is global_ts
+
+    def test_non_default_returns_new_instance(self):
+        """Non-default agent_id creates a fresh ToolStateManager."""
+        from chuk_ai_session_manager.guards import get_tool_state
+
+        agent_ts = get_agent_tool_state("agent-research")
+        global_ts = get_tool_state()
+        assert agent_ts is not global_ts
+
+    def test_same_agent_id_returns_same_instance(self):
+        """Repeated calls with the same agent_id return the same instance."""
+        ts1 = get_agent_tool_state("agent-a")
+        ts2 = get_agent_tool_state("agent-a")
+        assert ts1 is ts2
+
+    def test_different_agent_ids_return_different_instances(self):
+        """Different agent_ids get independent instances."""
+        ts_a = get_agent_tool_state("agent-a")
+        ts_b = get_agent_tool_state("agent-b")
+        assert ts_a is not ts_b
+
+    def test_remove_agent_tool_state(self):
+        """Removing tool state means next access creates a fresh instance."""
+        ts1 = get_agent_tool_state("agent-a")
+        remove_agent_tool_state("agent-a")
+        ts2 = get_agent_tool_state("agent-a")
+        assert ts1 is not ts2
+
+    def test_remove_nonexistent_is_noop(self):
+        """Removing a non-existent agent_id doesn't raise."""
+        remove_agent_tool_state("no-such-agent")  # should not raise
+
+    def test_reset_registry_clears_all(self):
+        """_reset_registry clears all per-agent instances."""
+        get_agent_tool_state("agent-a")
+        get_agent_tool_state("agent-b")
+        _reset_registry()
+        # After reset, new calls should create fresh instances
+        ts = get_agent_tool_state("agent-a")
+        assert ts is not None  # it exists but is fresh
+
+    def test_default_not_in_registry(self):
+        """The 'default' agent's state is NOT stored in the internal registry."""
+        get_agent_tool_state("default")
+        _reset_registry()  # only clears internal registry
+        # default should still work (delegates to global singleton)
+        ts = get_agent_tool_state("default")
+        assert ts is not None
diff --git a/tests/chat/test_attachments.py b/tests/chat/test_attachments.py
new file mode 100644
index 00000000..7cc72a61
--- /dev/null
+++ b/tests/chat/test_attachments.py
@@ -0,0 +1,529 @@
+# tests/chat/test_attachments.py
+"""Unit tests for multi-modal attachment processing."""
+
+from __future__ import annotations
+
+import pytest
+
+from mcp_cli.chat.attachments import (
+    AUDIO_EXTENSIONS,
+    IMAGE_EXTENSIONS,
+    TEXT_EXTENSIONS,
+    Attachment,
+    AttachmentStaging,
+    _classify_kind,
+    attachment_descriptor,
+    build_multimodal_content,
+    detect_image_urls,
+    detect_mime_type,
+    parse_inline_refs,
+    process_browser_file,
+    process_local_file,
+    process_url,
+)
+from mcp_cli.config.defaults import DEFAULT_MAX_ATTACHMENT_SIZE_BYTES
+
+
+# ---------------------------------------------------------------------------
+# MIME detection
+# ---------------------------------------------------------------------------
+
+
+class TestDetectMimeType:
+    def test_png(self, tmp_path):
+        from pathlib import Path
+
+        assert detect_mime_type(Path("test.png")) == "image/png"
+
+    def test_jpg(self, tmp_path):
+        from pathlib import Path
+
+        assert detect_mime_type(Path("photo.jpg")) == "image/jpeg"
+
+    def test_jpeg(self):
+        from pathlib import Path
+
+        assert detect_mime_type(Path("photo.jpeg")) == "image/jpeg"
+
+    def test_mp3(self):
+        from pathlib import Path
+
+        assert detect_mime_type(Path("audio.mp3")) == "audio/mpeg"
+
+    def test_python(self):
+        from pathlib import Path
+
+        assert detect_mime_type(Path("code.py")) == "text/plain"
+
+    def test_csv(self):
+        from pathlib import Path
+
+        assert detect_mime_type(Path("data.csv")) == "text/csv"
+
+    def test_unknown(self):
+        from pathlib import Path
+
+        assert detect_mime_type(Path("file.xyz")) == "application/octet-stream"
+
+
+# ---------------------------------------------------------------------------
+# Inline @file: parsing
+# ---------------------------------------------------------------------------
+
+
+class TestParseInlineRefs:
+    def test_single_ref(self):
+        text, paths = parse_inline_refs("Look at @file:img.png please")
+        assert paths == ["img.png"]
+        assert "@file" not in text
+        assert "Look at" in text
+        assert "please" in text
+
+    def test_multiple_refs(self):
+        text, paths = parse_inline_refs("Compare @file:a.png and @file:b.jpg")
+        assert len(paths) == 2
+        assert "a.png" in paths
+        assert "b.jpg" in paths
+        assert "@file" not in text
+
+    def test_no_refs(self):
+        text, paths = parse_inline_refs("No refs here")
+        assert paths == []
+        assert text == "No refs here"
+
+    def test_path_with_directory(self):
+        text, paths = parse_inline_refs("See @file:/tmp/dir/photo.png")
+        assert paths == ["/tmp/dir/photo.png"]
+
+    def test_empty_string(self):
+        text, paths = parse_inline_refs("")
+        assert paths == []
+        assert text == ""
+
+    def test_collapses_spaces(self):
+        text, _ = parse_inline_refs("before @file:x.png after")
+        # Should not have double spaces
+        assert "  " not in text
+
+
+# ---------------------------------------------------------------------------
+# Image URL detection
+# ---------------------------------------------------------------------------
+
+
+class TestDetectImageUrls:
+    def test_png_url(self):
+        urls = detect_image_urls("Look at https://example.com/cat.png")
+        assert urls == ["https://example.com/cat.png"]
+
+    def test_jpg_url(self):
+        urls = detect_image_urls("https://example.com/photo.jpg is nice")
+        assert urls == ["https://example.com/photo.jpg"]
+
+    def test_case_insensitive(self):
+        urls = detect_image_urls("https://example.com/cat.PNG")
+        assert len(urls) == 1
+
+    def test_url_with_query(self):
+        urls = detect_image_urls("https://example.com/img.png?size=large")
+        assert len(urls) == 1
+        assert "?size=large" in urls[0]
+
+    def test_no_urls(self):
+        urls = detect_image_urls("Just plain text here")
+        assert urls == []
+
+    def test_non_image_url(self):
+        urls = detect_image_urls("Visit https://example.com/page.html")
+        assert urls == []
+
+    def test_multiple_urls(self):
+        urls = detect_image_urls("https://a.com/1.png and https://b.com/2.jpg")
+        assert len(urls) == 2
+
+
+# ---------------------------------------------------------------------------
+# AttachmentStaging
+# ---------------------------------------------------------------------------
+
+
+class TestAttachmentStaging:
+    def _make_att(self, name: str = "test.png") -> Attachment:
+        return Attachment(
+            source=name,
+            content_blocks=[{"type": "text", "text": "mock"}],
+            display_name=name,
+            size_bytes=100,
+            mime_type="image/png",
+        )
+
+    def test_stage_and_count(self):
+        staging = AttachmentStaging()
+        assert staging.count == 0
+        staging.stage(self._make_att())
+        assert staging.count == 1
+
+    def test_drain_returns_and_clears(self):
+        staging = AttachmentStaging()
+        staging.stage(self._make_att("a.png"))
+        staging.stage(self._make_att("b.png"))
+        drained = staging.drain()
+        assert len(drained) == 2
+        assert staging.count == 0
+
+    def test_peek_does_not_clear(self):
+        staging = AttachmentStaging()
+        staging.stage(self._make_att())
+        peeked = staging.peek()
+        assert len(peeked) == 1
+        assert staging.count == 1
+
+    def test_clear(self):
+        staging = AttachmentStaging()
+        staging.stage(self._make_att())
+        staging.clear()
+        assert staging.count == 0
+
+    def test_drain_empty(self):
+        staging = AttachmentStaging()
+        assert staging.drain() == []
+
+
+# ---------------------------------------------------------------------------
+# process_local_file
+# ---------------------------------------------------------------------------
+
+
+class TestProcessLocalFile:
+    def test_image_file(self, tmp_path):
+        img = tmp_path / "test.png"
+        img.write_bytes(b"\x89PNG\r\n\x1a\n" + b"\x00" * 100)
+        att = process_local_file(str(img))
+        assert att.mime_type == "image/png"
+        assert att.display_name == "test.png"
+        assert att.size_bytes > 0
+        assert len(att.content_blocks) == 1
+        block = att.content_blocks[0]
+        assert block["type"] == "image_url"
+        assert block["image_url"]["url"].startswith("data:image/png;base64,")
+
+    def test_text_file(self, tmp_path):
+        txt = tmp_path / "code.py"
+        txt.write_text("print('hello')")
+        att = process_local_file(str(txt))
+        assert att.mime_type == "text/plain"
+        assert len(att.content_blocks) == 1
+        block = att.content_blocks[0]
+        assert block["type"] == "text"
+        assert "print('hello')" in block["text"]
+        assert "--- code.py ---" in block["text"]
+
+    def test_audio_file(self, tmp_path):
+        audio = tmp_path / "clip.mp3"
+        audio.write_bytes(b"\xff\xfb\x90\x00" + b"\x00" * 50)
+        att = process_local_file(str(audio))
+        assert att.mime_type == "audio/mpeg"
+        block = att.content_blocks[0]
+        assert block["type"] == "input_audio"
+        assert block["input_audio"]["format"] == "mp3"
+
+    def test_wav_audio(self, tmp_path):
+        audio = tmp_path / "clip.wav"
+        audio.write_bytes(b"RIFF" + b"\x00" * 50)
+        att = process_local_file(str(audio))
+        block = att.content_blocks[0]
+        assert block["input_audio"]["format"] == "wav"
+
+    def test_csv_file(self, tmp_path):
+        csv = tmp_path / "data.csv"
+        csv.write_text("a,b,c\n1,2,3")
+        att = process_local_file(str(csv))
+        assert att.mime_type == "text/csv"
+        assert "a,b,c" in att.content_blocks[0]["text"]
+
+    def test_file_not_found(self):
+        with pytest.raises(FileNotFoundError):
+            process_local_file("/nonexistent/file.png")
+
+    def test_not_a_file(self, tmp_path):
+        with pytest.raises(ValueError, match="Not a file"):
+            process_local_file(str(tmp_path))
+
+    def test_too_large(self, tmp_path):
+        big = tmp_path / "huge.png"
+        big.write_bytes(b"\x00" * (DEFAULT_MAX_ATTACHMENT_SIZE_BYTES + 1))
+        with pytest.raises(ValueError, match="too large"):
+            process_local_file(str(big))
+
+    def test_unsupported_extension(self, tmp_path):
+        f = tmp_path / "data.xyz"
+        f.write_bytes(b"\x00" * 10)
+        with pytest.raises(ValueError, match="Unsupported"):
+            process_local_file(str(f))
+
+    def test_tilde_expansion(self, tmp_path, monkeypatch):
+        # Just verify expanduser is called (don't rely on actual ~)
+        f = tmp_path / "test.txt"
+        f.write_text("content")
+        att = process_local_file(str(f))
+        assert att.display_name == "test.txt"
+
+    def test_json_file(self, tmp_path):
+        f = tmp_path / "config.json"
+        f.write_text('{"key": "value"}')
+        att = process_local_file(str(f))
+        assert att.mime_type == "application/json"
+        assert '{"key": "value"}' in att.content_blocks[0]["text"]
+
+
+# ---------------------------------------------------------------------------
+# process_url
+# ---------------------------------------------------------------------------
+
+
+class TestProcessUrl:
+    def test_basic_url(self):
+        att = process_url("https://example.com/photo.jpg")
+        assert att.source == "https://example.com/photo.jpg"
+        assert att.size_bytes == 0
+        block = att.content_blocks[0]
+        assert block["type"] == "image_url"
+        assert block["image_url"]["url"] == "https://example.com/photo.jpg"
+
+    def test_display_name(self):
+        att = process_url("https://example.com/path/to/image.png")
+        assert att.display_name == "image.png"
+
+
+# ---------------------------------------------------------------------------
+# build_multimodal_content
+# ---------------------------------------------------------------------------
+
+
+class TestBuildMultimodalContent:
+    def test_plain_text_passthrough(self):
+        result = build_multimodal_content("hello", [], [])
+        assert result == "hello"
+        assert isinstance(result, str)
+
+    def test_with_attachment(self):
+        att = Attachment(
+            source="test.png",
+            content_blocks=[
+                {"type": "image_url", "image_url": {"url": "data:image/png;base64,abc"}}
+            ],
+            display_name="test.png",
+            size_bytes=100,
+            mime_type="image/png",
+        )
+        result = build_multimodal_content("describe this", [att], [])
+        assert isinstance(result, list)
+        assert len(result) == 2
+        assert result[0] == {"type": "text", "text": "describe this"}
+        assert result[1]["type"] == "image_url"
+
+    def test_with_image_url(self):
+        result = build_multimodal_content(
+            "what is this", [], ["https://ex.com/img.png"]
+        )
+        assert isinstance(result, list)
+        assert len(result) == 2
+        assert result[1]["type"] == "image_url"
+        assert result[1]["image_url"]["url"] == "https://ex.com/img.png"
+
+    def test_dedup_urls(self):
+        """Image URLs already in attachments are not duplicated."""
+        att = Attachment(
+            source="https://ex.com/img.png",
+            content_blocks=[
+                {"type": "image_url", "image_url": {"url": "https://ex.com/img.png"}}
+            ],
+            display_name="img.png",
+            size_bytes=0,
+            mime_type="image/png",
+        )
+        result = build_multimodal_content("look", [att], ["https://ex.com/img.png"])
+        assert isinstance(result, list)
+        # Should have text + 1 image (not 2)
+        image_blocks = [b for b in result if b.get("type") == "image_url"]
+        assert len(image_blocks) == 1
+
+    def test_empty_text_with_attachment(self):
+        att = Attachment(
+            source="test.png",
+            content_blocks=[{"type": "image_url", "image_url": {"url": "data:..."}}],
+            display_name="test.png",
+            size_bytes=100,
+            mime_type="image/png",
+        )
+        result = build_multimodal_content("", [att], [])
+        assert isinstance(result, list)
+        # No text block when text is empty
+        text_blocks = [b for b in result if b.get("type") == "text"]
+        assert len(text_blocks) == 0
+
+    def test_multiple_attachments(self):
+        atts = [
+            Attachment(
+                source=f"f{i}.png",
+                content_blocks=[
+                    {"type": "image_url", "image_url": {"url": f"data:{i}"}}
+                ],
+                display_name=f"f{i}.png",
+                size_bytes=100,
+                mime_type="image/png",
+            )
+            for i in range(3)
+        ]
+        result = build_multimodal_content("compare these", atts, [])
+        assert isinstance(result, list)
+        assert len(result) == 4  # 1 text + 3 images
+
+
+# ---------------------------------------------------------------------------
+# Extension sets
+# ---------------------------------------------------------------------------
+
+
+class TestExtensionSets:
+    def test_no_overlap(self):
+        assert IMAGE_EXTENSIONS & AUDIO_EXTENSIONS == set()
+        assert IMAGE_EXTENSIONS & TEXT_EXTENSIONS == set()
+        assert AUDIO_EXTENSIONS & TEXT_EXTENSIONS == set()
+
+    def test_common_extensions_covered(self):
+        assert ".png" in IMAGE_EXTENSIONS
+        assert ".jpg" in IMAGE_EXTENSIONS
+        assert ".mp3" in AUDIO_EXTENSIONS
+        assert ".py" in TEXT_EXTENSIONS
+        assert ".txt" in TEXT_EXTENSIONS
+
+
+# ---------------------------------------------------------------------------
+# _classify_kind
+# ---------------------------------------------------------------------------
+
+
+class TestClassifyKind:
+    def test_image(self):
+        assert _classify_kind("image/png") == "image"
+        assert _classify_kind("image/jpeg") == "image"
+
+    def test_audio(self):
+        assert _classify_kind("audio/mpeg") == "audio"
+        assert _classify_kind("audio/wav") == "audio"
+
+    def test_text(self):
+        assert _classify_kind("text/plain") == "text"
+        assert _classify_kind("text/csv") == "text"
+
+    def test_json_is_text(self):
+        assert _classify_kind("application/json") == "text"
+
+    def test_unknown(self):
+        assert _classify_kind("application/octet-stream") == "unknown"
+
+
+# ---------------------------------------------------------------------------
+# attachment_descriptor
+# ---------------------------------------------------------------------------
+
+
+class TestAttachmentDescriptor:
+    def test_small_image(self, tmp_path):
+        img = tmp_path / "small.png"
+        img.write_bytes(b"\x89PNG\r\n\x1a\n" + b"\x00" * 50)
+        att = process_local_file(str(img))
+        desc = attachment_descriptor(att)
+        assert desc["kind"] == "image"
+        assert desc["display_name"] == "small.png"
+        assert desc["preview_url"] is not None
+        assert desc["preview_url"].startswith("data:image/png;base64,")
+
+    def test_large_image(self, tmp_path):
+        img = tmp_path / "big.png"
+        # Write >100KB to exceed threshold
+        img.write_bytes(b"\x89PNG\r\n\x1a\n" + b"\x00" * 110_000)
+        att = process_local_file(str(img))
+        desc = attachment_descriptor(att)
+        assert desc["kind"] == "image"
+        assert desc["preview_url"] is None
+
+    def test_url_image(self):
+        att = process_url("https://example.com/photo.jpg")
+        desc = attachment_descriptor(att)
+        assert desc["kind"] == "image"
+        assert desc["preview_url"] == "https://example.com/photo.jpg"
+
+    def test_text_file(self, tmp_path):
+        f = tmp_path / "code.py"
+        f.write_text("x = 42\n" * 100)
+        att = process_local_file(str(f))
+        desc = attachment_descriptor(att)
+        assert desc["kind"] == "text"
+        assert "x = 42" in desc["text_preview"]
+        assert isinstance(desc["text_truncated"], bool)
+
+    def test_text_file_truncation(self, tmp_path):
+        f = tmp_path / "big.txt"
+        f.write_text("A" * 5000)
+        att = process_local_file(str(f))
+        desc = attachment_descriptor(att, text_preview_chars=100)
+        assert len(desc["text_preview"]) == 100
+        assert desc["text_truncated"] is True
+
+    def test_audio(self, tmp_path):
+        audio = tmp_path / "clip.mp3"
+        audio.write_bytes(b"\xff\xfb\x90\x00" + b"\x00" * 50)
+        att = process_local_file(str(audio))
+        desc = attachment_descriptor(att)
+        assert desc["kind"] == "audio"
+        assert desc["audio_data_uri"].startswith("data:audio/mpeg;base64,")
+
+
+# ---------------------------------------------------------------------------
+# process_browser_file
+# ---------------------------------------------------------------------------
+
+
+class TestProcessBrowserFile:
+    """Tests for process_browser_file (browser-uploaded files)."""
+
+    def test_image(self):
+        import base64
+
+        raw = b"\x89PNG\r\n\x1a\n" + b"\x00" * 100
+        b64 = base64.b64encode(raw).decode()
+        att = process_browser_file("photo.png", b64, "image/png")
+        assert att.source == "browser:photo.png"
+        assert att.display_name == "photo.png"
+        assert att.mime_type == "image/png"
+        assert att.size_bytes == len(raw)
+        assert len(att.content_blocks) == 1
+        assert att.content_blocks[0]["type"] == "image_url"
+
+    def test_text(self):
+        import base64
+
+        raw = b"hello world"
+        b64 = base64.b64encode(raw).decode()
+        att = process_browser_file("readme.txt", b64, "text/plain")
+        assert att.source == "browser:readme.txt"
+        assert att.mime_type == "text/plain"
+        assert att.content_blocks[0]["type"] == "text"
+        assert "hello world" in att.content_blocks[0]["text"]
+
+    def test_too_large(self):
+        import base64
+
+        raw = b"\x00" * (DEFAULT_MAX_ATTACHMENT_SIZE_BYTES + 1)
+        b64 = base64.b64encode(raw).decode()
+        with pytest.raises(ValueError, match="too large"):
+            process_browser_file("big.bin", b64, "image/png")
+
+    def test_unsupported_extension(self):
+        import base64
+
+        b64 = base64.b64encode(b"data").decode()
+        with pytest.raises(ValueError, match="Unsupported"):
+            process_browser_file("file.xyz", b64, "application/octet-stream")
diff --git a/tests/chat/test_chat_context.py b/tests/chat/test_chat_context.py
index ff9674e2..9c203759 100644
--- a/tests/chat/test_chat_context.py
+++ b/tests/chat/test_chat_context.py
@@ -1918,7 +1918,9 @@ async def test_save_session_with_token_usage(self, monkeypatch, tmp_path):
         # Verify the saved file has token_usage
         import json
 
-        saved = json.loads(tmp_path.joinpath(f"{ctx.session_id}.json").read_text())
+        saved = json.loads(
+            tmp_path.joinpath("default", f"{ctx.session_id}.json").read_text()
+        )
         assert saved.get("token_usage") is not None
 
     @pytest.mark.asyncio
@@ -1962,7 +1964,7 @@ def test_load_session_not_found_returns_false(self, monkeypatch):
 
     @pytest.mark.asyncio
     async def test_load_session_exception_returns_false(self, monkeypatch, tmp_path):
-        """load_session returns False when add_event (or similar) raises."""
+        """load_session returns False when event injection raises."""
         from unittest.mock import Mock
         from mcp_cli.chat.session_store import SessionData, SessionMetadata
 
@@ -1986,8 +1988,11 @@ async def test_load_session_exception_returns_false(self, monkeypatch, tmp_path)
         mock_store.load.return_value = data
         ctx._session_store = mock_store
 
-        # load_session calls self.session.add_event which doesn't exist
-        # This triggers the except block -> returns False
+        # Make session._session.events raise on append to trigger the except block
+        mock_events = Mock()
+        mock_events.append.side_effect = RuntimeError("injection error")
+        ctx.session._session.events = mock_events
+
         result = ctx.load_session("fake-session")
         assert result is False
 
@@ -2137,7 +2142,7 @@ async def test_auto_save_check_below_threshold(self, monkeypatch, tmp_path):
             ctx.auto_save_check()
 
         # Nothing saved yet
-        assert list(tmp_path.glob("*.json")) == []
+        assert list(tmp_path.glob("**/*.json")) == []
 
     @pytest.mark.asyncio
     async def test_auto_save_check_triggers_save(self, monkeypatch, tmp_path):
@@ -2154,8 +2159,8 @@ async def test_auto_save_check_triggers_save(self, monkeypatch, tmp_path):
         for _ in range(DEFAULT_AUTO_SAVE_INTERVAL):
             ctx.auto_save_check()
 
-        # Should have saved
-        saved_files = list(tmp_path.glob("*.json"))
+        # Should have saved (files are in tmp_path/default/)
+        saved_files = list(tmp_path.glob("**/*.json"))
         assert len(saved_files) == 1
         # Counter should be reset to 0
         assert ctx._auto_save_counter == 0
@@ -2662,3 +2667,60 @@ async def test_conversation_history_mixed_events(self, monkeypatch):
         assert "user" in roles
         assert "assistant" in roles
         assert "tool" in roles
+
+
+# ---------------------------------------------------------------------------
+# agent_id plumbing
+# ---------------------------------------------------------------------------
+
+
+class TestAgentId:
+    """Verify agent_id is stored, propagated, and serialized."""
+
+    def test_agent_id_default(self, monkeypatch):
+        ctx = _make_initialized_ctx(monkeypatch)
+        assert ctx.agent_id == "default"
+
+    def test_agent_id_custom(self, monkeypatch):
+        ctx = _make_initialized_ctx(monkeypatch, agent_id="my-agent")
+        assert ctx.agent_id == "my-agent"
+
+    def test_to_dict_includes_agent_id(self, monkeypatch):
+        ctx = _make_initialized_ctx(monkeypatch, agent_id="export-agent")
+        d = ctx.to_dict()
+        assert d["agent_id"] == "export-agent"
+
+    def test_save_session_writes_agent_id(self, monkeypatch, tmp_path):
+        ctx = _make_initialized_ctx(monkeypatch, agent_id="save-agent")
+        # Point session store to tmp_path
+        from mcp_cli.chat.session_store import SessionStore
+
+        ctx._session_store = SessionStore(sessions_dir=tmp_path, agent_id="save-agent")
+        ctx._system_prompt = "SYS"
+
+        path = ctx.save_session()
+        assert path is not None
+
+        loaded = ctx._session_store.load(ctx.session_id)
+        assert loaded is not None
+        assert loaded.metadata.agent_id == "save-agent"
+
+    def test_create_forwards_agent_id(self, monkeypatch):
+        monkeypatch.setattr(
+            "mcp_cli.chat.chat_context.generate_system_prompt",
+            lambda tools=None, **kw: "SYS_PROMPT",
+        )
+        from unittest.mock import Mock
+        from mcp_cli.model_management import ModelManager
+
+        mock_mm = Mock(spec=ModelManager)
+        mock_mm.get_client.return_value = None
+        mock_mm.get_active_provider.return_value = "mock"
+        mock_mm.get_active_model.return_value = "mock-model"
+
+        ctx = ChatContext.create(
+            tool_manager=DummyToolManager(),
+            model_manager=mock_mm,
+            agent_id="factory-agent",
+        )
+        assert ctx.agent_id == "factory-agent"
diff --git a/tests/chat/test_chat_handler_coverage.py b/tests/chat/test_chat_handler_coverage.py
index 71e30c45..61263053 100644
--- a/tests/chat/test_chat_handler_coverage.py
+++ b/tests/chat/test_chat_handler_coverage.py
@@ -41,6 +41,10 @@ def _make_ctx(exit_requested=False):
     ctx.model = "gpt-4"
     ctx.exit_requested = exit_requested
     ctx.add_user_message = AsyncMock()
+    # Real staging so multi-modal processing works correctly (drain returns [])
+    from mcp_cli.chat.attachments import AttachmentStaging
+
+    ctx.attachment_staging = AttachmentStaging()
     return ctx
 
 
@@ -770,3 +774,182 @@ async def test_interrupt_nothing(self):
             result = await handle_interrupt_command(ui)
             assert result is True
             mock_output.info.assert_called()
+
+
+# ===========================================================================
+# Tests for multi-agent wiring
+# ===========================================================================
+
+
+class TestMultiAgentWiring:
+    """Tests for multi_agent=True flag in handle_chat_mode."""
+
+    @pytest.mark.asyncio
+    async def test_multi_agent_creates_agent_manager(self):
+        """multi_agent=True creates AgentManager and sets it on context."""
+        tool_mgr = MagicMock()
+        tool_mgr.close = AsyncMock()
+        tool_mgr.get_tool_count = MagicMock(return_value=5)
+
+        mock_ctx = _make_ctx()
+        mock_ctx.initialize = AsyncMock(return_value=True)
+        mock_ctx.agent_id = "default"
+        mock_ctx.dashboard_bridge = None
+        mock_ctx.conversation_history = []
+        mock_ctx.save_session = MagicMock(return_value=None)
+
+        mock_app_ctx = MagicMock()
+        mock_app_ctx.model_manager = MagicMock()
+        mock_app_ctx.initialize = AsyncMock()
+
+        ui = _make_ui()
+        convo = _make_convo()
+
+        mock_bridge = MagicMock()
+        mock_bridge.set_context = MagicMock()
+        mock_bridge.set_tool_call_callback = MagicMock()
+        mock_bridge.set_input_queue = MagicMock()
+        mock_bridge.on_shutdown = AsyncMock()
+        mock_bridge.server = MagicMock()
+        mock_bridge.server.stop = AsyncMock()
+
+        mock_launch = AsyncMock(return_value=(MagicMock(), MagicMock(), 9120))
+        mock_agent_manager = MagicMock()
+        mock_agent_manager.stop_all = AsyncMock()
+
+        with (
+            patch("mcp_cli.chat.chat_handler.initialize_config"),
+            patch(
+                "mcp_cli.chat.chat_handler.initialize_context",
+                return_value=mock_app_ctx,
+            ),
+            patch("mcp_cli.chat.chat_handler.output"),
+            patch("mcp_cli.chat.chat_handler.clear_screen"),
+            patch("mcp_cli.chat.chat_handler.display_chat_banner"),
+            patch("mcp_cli.chat.chat_handler.ChatContext") as MockCC,
+            patch("mcp_cli.chat.chat_handler.ChatUIManager", return_value=ui),
+            patch(
+                "mcp_cli.chat.chat_handler.ConversationProcessor",
+                return_value=convo,
+            ),
+            patch(
+                "mcp_cli.chat.chat_handler._run_enhanced_chat_loop",
+                new_callable=AsyncMock,
+            ),
+            patch(
+                "mcp_cli.chat.chat_handler._safe_cleanup",
+                new_callable=AsyncMock,
+            ),
+            patch(
+                "mcp_cli.dashboard.launcher.launch_dashboard",
+                mock_launch,
+            ),
+            patch(
+                "mcp_cli.dashboard.bridge.DashboardBridge",
+                return_value=mock_bridge,
+            ),
+            patch(
+                "mcp_cli.agents.manager.AgentManager",
+                return_value=mock_agent_manager,
+            ) as MockAM,
+        ):
+            MockCC.create.return_value = mock_ctx
+
+            from mcp_cli.chat.chat_handler import handle_chat_mode
+
+            result = await handle_chat_mode(
+                tool_mgr,
+                provider="openai",
+                model="gpt-4",
+                multi_agent=True,
+            )
+            assert result is True
+            # AgentManager was constructed
+            MockAM.assert_called_once()
+            # agent_manager set on context
+            assert mock_ctx.agent_manager == mock_agent_manager
+            # stop_all called during cleanup
+            mock_agent_manager.stop_all.assert_called_once()
+
+    @pytest.mark.asyncio
+    async def test_multi_agent_implies_dashboard(self):
+        """multi_agent=True forces dashboard=True even if not passed."""
+        tool_mgr = MagicMock()
+        tool_mgr.close = AsyncMock()
+        tool_mgr.get_tool_count = MagicMock(return_value=0)
+
+        mock_ctx = _make_ctx()
+        mock_ctx.initialize = AsyncMock(return_value=True)
+        mock_ctx.agent_id = "default"
+        mock_ctx.dashboard_bridge = None
+        mock_ctx.conversation_history = []
+        mock_ctx.save_session = MagicMock(return_value=None)
+
+        mock_app_ctx = MagicMock()
+        mock_app_ctx.model_manager = MagicMock()
+        mock_app_ctx.initialize = AsyncMock()
+
+        ui = _make_ui()
+        convo = _make_convo()
+
+        mock_bridge = MagicMock()
+        mock_bridge.set_context = MagicMock()
+        mock_bridge.set_tool_call_callback = MagicMock()
+        mock_bridge.set_input_queue = MagicMock()
+        mock_bridge.on_shutdown = AsyncMock()
+        mock_bridge.server = MagicMock()
+        mock_bridge.server.stop = AsyncMock()
+
+        mock_launch = AsyncMock(return_value=(MagicMock(), MagicMock(), 9120))
+
+        with (
+            patch("mcp_cli.chat.chat_handler.initialize_config"),
+            patch(
+                "mcp_cli.chat.chat_handler.initialize_context",
+                return_value=mock_app_ctx,
+            ),
+            patch("mcp_cli.chat.chat_handler.output"),
+            patch("mcp_cli.chat.chat_handler.clear_screen"),
+            patch("mcp_cli.chat.chat_handler.display_chat_banner"),
+            patch("mcp_cli.chat.chat_handler.ChatContext") as MockCC,
+            patch("mcp_cli.chat.chat_handler.ChatUIManager", return_value=ui),
+            patch(
+                "mcp_cli.chat.chat_handler.ConversationProcessor",
+                return_value=convo,
+            ),
+            patch(
+                "mcp_cli.chat.chat_handler._run_enhanced_chat_loop",
+                new_callable=AsyncMock,
+            ),
+            patch(
+                "mcp_cli.chat.chat_handler._safe_cleanup",
+                new_callable=AsyncMock,
+            ),
+            patch(
+                "mcp_cli.dashboard.launcher.launch_dashboard",
+                mock_launch,
+            ),
+            patch(
+                "mcp_cli.dashboard.bridge.DashboardBridge",
+                return_value=mock_bridge,
+            ),
+            patch(
+                "mcp_cli.agents.manager.AgentManager",
+                return_value=MagicMock(stop_all=AsyncMock()),
+            ),
+        ):
+            MockCC.create.return_value = mock_ctx
+
+            from mcp_cli.chat.chat_handler import handle_chat_mode
+
+            # dashboard=False but multi_agent=True — dashboard should still launch
+            result = await handle_chat_mode(
+                tool_mgr,
+                provider="openai",
+                model="gpt-4",
+                dashboard=False,
+                multi_agent=True,
+            )
+            assert result is True
+            # launch_dashboard was called (proving dashboard was forced on)
+            mock_launch.assert_called_once()
diff --git a/tests/chat/test_memory_integration.py b/tests/chat/test_memory_integration.py
index c8d927ba..98771153 100644
--- a/tests/chat/test_memory_integration.py
+++ b/tests/chat/test_memory_integration.py
@@ -46,7 +46,7 @@ def print_tool_call(self, tool_name, raw_arguments):
     async def finish_tool_execution(self, result=None, success=True):
         pass
 
-    def do_confirm_tool_execution(self, tool_name, arguments):
+    async def do_confirm_tool_execution(self, tool_name, arguments):
         return True
 
     async def start_tool_execution(self, tool_name, arguments):
diff --git a/tests/chat/test_session_store.py b/tests/chat/test_session_store.py
index c6874ddc..73c1967e 100644
--- a/tests/chat/test_session_store.py
+++ b/tests/chat/test_session_store.py
@@ -8,7 +8,7 @@
 @pytest.fixture
 def store(tmp_path):
     """Session store with temporary directory."""
-    return SessionStore(sessions_dir=tmp_path)
+    return SessionStore(sessions_dir=tmp_path, agent_id="test-agent")
 
 
 @pytest.fixture
@@ -116,6 +116,69 @@ def test_path_traversal_prevention(self, store):
         assert str(store.sessions_dir) in str(path)
 
 
+class TestAgentNamespacing:
+    def test_agent_id_in_metadata(self, store, sample_data):
+        """Saved sessions carry agent_id in metadata."""
+        sample_data.metadata.agent_id = "test-agent"
+        store.save(sample_data)
+        loaded = store.load("test-abc123")
+        assert loaded is not None
+        assert loaded.metadata.agent_id == "test-agent"
+
+    def test_agent_namespacing(self, tmp_path):
+        """Two stores with different agent_ids use isolated directories."""
+        store_a = SessionStore(sessions_dir=tmp_path, agent_id="agent-a")
+        store_b = SessionStore(sessions_dir=tmp_path, agent_id="agent-b")
+
+        data_a = SessionData(
+            metadata=SessionMetadata(session_id="shared-id", agent_id="agent-a"),
+            messages=[{"role": "user", "content": "from A"}],
+        )
+        data_b = SessionData(
+            metadata=SessionMetadata(session_id="shared-id", agent_id="agent-b"),
+            messages=[{"role": "user", "content": "from B"}],
+        )
+        store_a.save(data_a)
+        store_b.save(data_b)
+
+        loaded_a = store_a.load("shared-id")
+        loaded_b = store_b.load("shared-id")
+        assert loaded_a is not None and loaded_b is not None
+        assert loaded_a.messages[0]["content"] == "from A"
+        assert loaded_b.messages[0]["content"] == "from B"
+
+        # Each store only sees its own session
+        assert len(store_a.list_sessions()) == 1
+        assert len(store_b.list_sessions()) == 1
+
+    def test_backward_compat_migration(self, tmp_path):
+        """Sessions in the flat root dir are auto-migrated on load."""
+        # Write a session file directly to the flat root (legacy layout)
+        legacy_data = SessionData(
+            metadata=SessionMetadata(session_id="legacy-sess", provider="openai"),
+            messages=[{"role": "user", "content": "old"}],
+        )
+        legacy_path = tmp_path / "legacy-sess.json"
+        legacy_path.write_text(legacy_data.model_dump_json(indent=2), encoding="utf-8")
+
+        # Create a namespaced store and try to load
+        store = SessionStore(sessions_dir=tmp_path, agent_id="default")
+        loaded = store.load("legacy-sess")
+        assert loaded is not None
+        assert loaded.metadata.session_id == "legacy-sess"
+
+        # Legacy file should be gone (migrated)
+        assert not legacy_path.exists()
+        # Now lives in the namespaced dir
+        assert (tmp_path / "default" / "legacy-sess.json").exists()
+
+    def test_sessions_dir_is_agent_scoped(self, tmp_path):
+        """SessionStore.sessions_dir points to the agent subdirectory."""
+        store = SessionStore(sessions_dir=tmp_path, agent_id="my-agent")
+        assert store.sessions_dir == tmp_path / "my-agent"
+        assert store.sessions_dir.exists()
+
+
 class TestAutoSave:
     def test_auto_save_triggers(self):
         """Auto-save fires after N turns."""
diff --git a/tests/chat/test_streaming_handler.py b/tests/chat/test_streaming_handler.py
index 335e67a7..33f55f39 100644
--- a/tests/chat/test_streaming_handler.py
+++ b/tests/chat/test_streaming_handler.py
@@ -3,6 +3,7 @@
 
 import asyncio
 import json
+import logging
 import pytest
 from unittest.mock import AsyncMock, MagicMock, patch
 
@@ -893,7 +894,7 @@ async def mock_aiter():
         assert 180.0 not in timeouts_used, f"Did not expect 180.0 in {timeouts_used}"
 
     @pytest.mark.asyncio
-    async def test_after_tool_calls_timeout_message_mentions_tool_results(self):
+    async def test_after_tool_calls_timeout_message_mentions_tool_results(self, caplog):
         """Timeout message after tool calls mentions tool result processing."""
         display = _make_display()
         # Use very short first_chunk to trigger timeout
@@ -909,7 +910,7 @@ async def mock_aiter():
 
         # Patch the after-tools default to a tiny value so timeout fires
         with (
-            patch("chuk_term.ui.output") as mock_output,
+            caplog.at_level(logging.WARNING, logger="mcp_cli.streaming"),
             patch(
                 "mcp_cli.config.defaults.DEFAULT_STREAMING_FIRST_CHUNK_AFTER_TOOLS_TIMEOUT",
                 0.01,
@@ -917,7 +918,10 @@ async def mock_aiter():
         ):
             await handler.stream_response(client, messages=[], after_tool_calls=True)
 
-        # Check that the error message mentions tool results
-        mock_output.error.assert_called_once()
-        error_msg = mock_output.error.call_args[0][0]
-        assert "tool" in error_msg.lower()
+        # Check that the warning message mentions tool calls
+        warning_msgs = [
+            r.message
+            for r in caplog.records
+            if r.levelname == "WARNING" and r.name == "mcp_cli.streaming"
+        ]
+        assert any("tool" in m.lower() for m in warning_msgs)
diff --git a/tests/chat/test_tool_processor.py b/tests/chat/test_tool_processor.py
index 544920c9..2e5aa2c8 100644
--- a/tests/chat/test_tool_processor.py
+++ b/tests/chat/test_tool_processor.py
@@ -55,7 +55,7 @@ async def finish_tool_execution(self, result=None, success=True):
         # Add async method that tool processor expects
         pass
 
-    def do_confirm_tool_execution(self, tool_name, arguments):
+    async def do_confirm_tool_execution(self, tool_name, arguments):
         # Mock confirmation - always return True for tests
         return True
 
@@ -452,7 +452,7 @@ async def test_process_tool_calls_exception_in_call():
 class DenyConfirmUIManager(DummyUIManager):
     """UI manager that denies tool confirmation."""
 
-    def do_confirm_tool_execution(self, tool_name, arguments):
+    async def do_confirm_tool_execution(self, tool_name, arguments):
         return False
 
 
@@ -483,7 +483,7 @@ async def test_cancelled_tool_still_gets_result_for_remaining():
     class SelectiveDenyUI(DummyUIManager):
         """Denies the second tool call."""
 
-        def do_confirm_tool_execution(self, tool_name, arguments):
+        async def do_confirm_tool_execution(self, tool_name, arguments):
             call_count[0] += 1
             return call_count[0] <= 1  # Allow first, deny second
 
diff --git a/tests/chat/test_tool_processor_extended.py b/tests/chat/test_tool_processor_extended.py
index acdc9ede..3a07c580 100644
--- a/tests/chat/test_tool_processor_extended.py
+++ b/tests/chat/test_tool_processor_extended.py
@@ -73,7 +73,7 @@ def print_tool_call(self, tool_name, raw_arguments):
     async def finish_tool_execution(self, result=None, success=True):
         self._finish_calls.append((result, success))
 
-    def do_confirm_tool_execution(self, tool_name, arguments):
+    async def do_confirm_tool_execution(self, tool_name, arguments):
         return True
 
     async def start_tool_execution(self, tool_name, arguments):
@@ -99,7 +99,7 @@ def print_tool_call(self, tool_name, raw_arguments):
     async def finish_tool_execution(self, result=None, success=True):
         pass
 
-    def do_confirm_tool_execution(self, tool_name, arguments):
+    async def do_confirm_tool_execution(self, tool_name, arguments):
         return True
 
     async def start_tool_execution(self, tool_name, arguments):
@@ -109,7 +109,7 @@ async def start_tool_execution(self, tool_name, arguments):
 class ConfirmDenyUIManager(DummyUIManager):
     """UI manager that denies tool confirmation."""
 
-    def do_confirm_tool_execution(self, tool_name, arguments):
+    async def do_confirm_tool_execution(self, tool_name, arguments):
         return False
 
 
@@ -1476,7 +1476,7 @@ async def test_missing_reference_blocks_tool(self):
         with (
             patch.object(tp, "_should_confirm_tool", return_value=False),
             patch(
-                "mcp_cli.chat.tool_processor.get_tool_state",
+                "mcp_cli.chat.tool_processor.get_agent_tool_state",
                 return_value=mock_tool_state,
             ),
         ):
@@ -1540,7 +1540,9 @@ async def test_precondition_failure_blocks_tool(self):
 
         with (
             patch.object(tp, "_should_confirm_tool", return_value=False),
-            patch("mcp_cli.chat.tool_processor.get_tool_state", return_value=mock_ts),
+            patch(
+                "mcp_cli.chat.tool_processor.get_agent_tool_state", return_value=mock_ts
+            ),
         ):
             await tp.process_tool_calls([tc])
 
@@ -1616,7 +1618,9 @@ async def test_repair_succeeds_rebind(self):
 
         with (
             patch.object(tp, "_should_confirm_tool", return_value=False),
-            patch("mcp_cli.chat.tool_processor.get_tool_state", return_value=mock_ts),
+            patch(
+                "mcp_cli.chat.tool_processor.get_agent_tool_state", return_value=mock_ts
+            ),
         ):
             await tp.process_tool_calls([tc])
 
@@ -1641,7 +1645,9 @@ async def test_repair_symbolic_fallback(self):
 
         with (
             patch.object(tp, "_should_confirm_tool", return_value=False),
-            patch("mcp_cli.chat.tool_processor.get_tool_state", return_value=mock_ts),
+            patch(
+                "mcp_cli.chat.tool_processor.get_agent_tool_state", return_value=mock_ts
+            ),
         ):
             await tp.process_tool_calls([tc])
 
@@ -1667,7 +1673,9 @@ async def test_repair_all_failed(self):
 
         with (
             patch.object(tp, "_should_confirm_tool", return_value=False),
-            patch("mcp_cli.chat.tool_processor.get_tool_state", return_value=mock_ts),
+            patch(
+                "mcp_cli.chat.tool_processor.get_agent_tool_state", return_value=mock_ts
+            ),
         ):
             await tp.process_tool_calls([tc])
 
@@ -1729,7 +1737,9 @@ async def test_per_tool_limit_blocks(self):
 
         with (
             patch.object(tp, "_should_confirm_tool", return_value=False),
-            patch("mcp_cli.chat.tool_processor.get_tool_state", return_value=mock_ts),
+            patch(
+                "mcp_cli.chat.tool_processor.get_agent_tool_state", return_value=mock_ts
+            ),
         ):
             await tp.process_tool_calls([tc])
 
@@ -1798,7 +1808,9 @@ async def test_requires_justification_logged(self):
         mock_search_engine = MagicMock()
 
         with (
-            patch("mcp_cli.chat.tool_processor.get_tool_state", return_value=mock_ts),
+            patch(
+                "mcp_cli.chat.tool_processor.get_agent_tool_state", return_value=mock_ts
+            ),
             patch(
                 "mcp_cli.chat.tool_processor.get_search_engine",
                 return_value=mock_search_engine,
@@ -1857,7 +1869,9 @@ async def test_discovery_tool_result(self):
         mock_search_engine = MagicMock()
 
         with (
-            patch("mcp_cli.chat.tool_processor.get_tool_state", return_value=mock_ts),
+            patch(
+                "mcp_cli.chat.tool_processor.get_agent_tool_state", return_value=mock_ts
+            ),
             patch(
                 "mcp_cli.chat.tool_processor.get_search_engine",
                 return_value=mock_search_engine,
diff --git a/tests/chat/test_ui_manager_coverage.py b/tests/chat/test_ui_manager_coverage.py
index 1b387f09..ba40f5c4 100644
--- a/tests/chat/test_ui_manager_coverage.py
+++ b/tests/chat/test_ui_manager_coverage.py
@@ -4,6 +4,7 @@
 This file is separate from test_ui_manager.py (which tests the command completer).
 """
 
+import asyncio
 import signal
 import time
 import pytest
@@ -301,54 +302,186 @@ def test_print_tool_call_no_op(self, ui_manager):
 class TestDoConfirmToolExecution:
     """Tests for do_confirm_tool_execution."""
 
-    def test_confirm_yes(self, ui_manager):
+    @pytest.mark.asyncio
+    async def test_confirm_yes(self, ui_manager):
         with (
             patch("mcp_cli.chat.ui_manager.output"),
             patch("builtins.input", return_value="y"),
         ):
-            result = ui_manager.do_confirm_tool_execution("fn", '{"x": 1}')
+            result = await ui_manager.do_confirm_tool_execution("fn", '{"x": 1}')
             assert result is True
 
-    def test_confirm_empty_default_yes(self, ui_manager):
+    @pytest.mark.asyncio
+    async def test_confirm_empty_default_yes(self, ui_manager):
         with (
             patch("mcp_cli.chat.ui_manager.output"),
             patch("builtins.input", return_value=""),
         ):
-            result = ui_manager.do_confirm_tool_execution("fn", {"x": 1})
+            result = await ui_manager.do_confirm_tool_execution("fn", {"x": 1})
             assert result is True
 
-    def test_confirm_no(self, ui_manager):
+    @pytest.mark.asyncio
+    async def test_confirm_no(self, ui_manager):
         with (
             patch("mcp_cli.chat.ui_manager.output"),
             patch("builtins.input", return_value="n"),
         ):
-            result = ui_manager.do_confirm_tool_execution("fn", {"x": 1})
+            result = await ui_manager.do_confirm_tool_execution("fn", {"x": 1})
             assert result is False
 
-    def test_confirm_invalid_json_string(self, ui_manager):
+    @pytest.mark.asyncio
+    async def test_confirm_invalid_json_string(self, ui_manager):
         with (
             patch("mcp_cli.chat.ui_manager.output"),
             patch("builtins.input", return_value="yes"),
         ):
-            result = ui_manager.do_confirm_tool_execution("fn", "{not json")
+            result = await ui_manager.do_confirm_tool_execution("fn", "{not json")
+            assert result is True
+
+    @pytest.mark.asyncio
+    async def test_confirm_none_args(self, ui_manager):
+        with (
+            patch("mcp_cli.chat.ui_manager.output"),
+            patch("builtins.input", return_value="y"),
+        ):
+            result = await ui_manager.do_confirm_tool_execution("fn", None)
+            assert result is True
+
+    @pytest.mark.asyncio
+    async def test_confirm_empty_string(self, ui_manager):
+        with (
+            patch("mcp_cli.chat.ui_manager.output"),
+            patch("builtins.input", return_value="y"),
+        ):
+            result = await ui_manager.do_confirm_tool_execution("fn", "")
+            assert result is True
+
+
+# ===========================================================================
+# Dashboard confirmation path tests
+# ===========================================================================
+
+
+class TestDoConfirmDashboardPath:
+    """Tests for do_confirm_tool_execution routing to dashboard bridge."""
+
+    @pytest.mark.asyncio
+    async def test_routes_to_dashboard_when_clients_connected(self, ui_manager):
+        """When dashboard bridge has clients, use bridge for approval."""
+        fut = asyncio.get_event_loop().create_future()
+        fut.set_result(True)
+
+        bridge = MagicMock()
+        bridge.has_clients = True
+        bridge.request_tool_approval = AsyncMock(return_value=fut)
+        ui_manager.context.dashboard_bridge = bridge
+
+        result = await ui_manager.do_confirm_tool_execution("test_tool", {"x": 1})
+        assert result is True
+        bridge.request_tool_approval.assert_awaited_once()
+
+    @pytest.mark.asyncio
+    async def test_falls_back_to_terminal_when_no_clients(self, ui_manager):
+        """When dashboard has no clients, fall back to terminal input."""
+        bridge = MagicMock()
+        bridge.has_clients = False
+        ui_manager.context.dashboard_bridge = bridge
+
+        with (
+            patch("mcp_cli.chat.ui_manager.output"),
+            patch("builtins.input", return_value="y"),
+        ):
+            result = await ui_manager.do_confirm_tool_execution("test_tool", {"x": 1})
             assert result is True
+        bridge.request_tool_approval.assert_not_called()
+
+    @pytest.mark.asyncio
+    async def test_falls_back_to_terminal_when_no_bridge(self, ui_manager):
+        """When no dashboard bridge, fall back to terminal input."""
+        ui_manager.context.dashboard_bridge = None
 
-    def test_confirm_none_args(self, ui_manager):
         with (
             patch("mcp_cli.chat.ui_manager.output"),
             patch("builtins.input", return_value="y"),
         ):
-            result = ui_manager.do_confirm_tool_execution("fn", None)
+            result = await ui_manager.do_confirm_tool_execution("test_tool", {"x": 1})
             assert result is True
 
-    def test_confirm_empty_string(self, ui_manager):
+    @pytest.mark.asyncio
+    async def test_dashboard_denial(self, ui_manager):
+        """Dashboard user denies the tool execution."""
+        fut = asyncio.get_event_loop().create_future()
+        fut.set_result(False)
+
+        bridge = MagicMock()
+        bridge.server = MagicMock()
+        bridge.server.has_clients = True
+        bridge.request_tool_approval = AsyncMock(return_value=fut)
+        ui_manager.context.dashboard_bridge = bridge
+
+        result = await ui_manager.do_confirm_tool_execution("test_tool", {"x": 1})
+        assert result is False
+
+    @pytest.mark.asyncio
+    async def test_dashboard_timeout_returns_false(self, ui_manager):
+        """If dashboard approval times out, return False."""
+        # Create a future that never resolves
+        fut = asyncio.get_event_loop().create_future()
+
+        bridge = MagicMock()
+        bridge.server = MagicMock()
+        bridge.server.has_clients = True
+        bridge.request_tool_approval = AsyncMock(return_value=fut)
+        ui_manager.context.dashboard_bridge = bridge
+
+        # Patch timeout to be very short for testing
+        with patch(
+            "mcp_cli.chat.ui_manager.asyncio.wait_for", side_effect=asyncio.TimeoutError
+        ):
+            result = await ui_manager.do_confirm_tool_execution("test_tool", {"x": 1})
+            assert result is False
+        # Clean up
+        fut.cancel()
+
+    @pytest.mark.asyncio
+    async def test_dashboard_exception_falls_back_to_terminal(self, ui_manager):
+        """If dashboard approval throws, fall back to terminal."""
+        bridge = MagicMock()
+        bridge.server = MagicMock()
+        bridge.server.has_clients = True
+        bridge.request_tool_approval = AsyncMock(
+            side_effect=RuntimeError("connection lost")
+        )
+        ui_manager.context.dashboard_bridge = bridge
+
         with (
             patch("mcp_cli.chat.ui_manager.output"),
             patch("builtins.input", return_value="y"),
         ):
-            result = ui_manager.do_confirm_tool_execution("fn", "")
+            result = await ui_manager.do_confirm_tool_execution("test_tool", {"x": 1})
             assert result is True
 
+    @pytest.mark.asyncio
+    async def test_string_args_parsed_for_dashboard(self, ui_manager):
+        """String arguments should be JSON-parsed before sending to dashboard."""
+        fut = asyncio.get_event_loop().create_future()
+        fut.set_result(True)
+
+        bridge = MagicMock()
+        bridge.server = MagicMock()
+        bridge.server.has_clients = True
+        bridge.request_tool_approval = AsyncMock(return_value=fut)
+        ui_manager.context.dashboard_bridge = bridge
+
+        await ui_manager.do_confirm_tool_execution("test_tool", '{"key": "value"}')
+        call_args = bridge.request_tool_approval.call_args
+        # Arguments should have been parsed from JSON string to dict
+        assert (
+            call_args.kwargs.get("arguments") == {"key": "value"}
+            or call_args[1].get("arguments") == {"key": "value"}
+            or (len(call_args[0]) >= 2 and call_args[0][1] == {"key": "value"})
+        )
+
 
 # ===========================================================================
 # Streaming support tests
diff --git a/tests/commands/attach/__init__.py b/tests/commands/attach/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/commands/attach/test_attach_command.py b/tests/commands/attach/test_attach_command.py
new file mode 100644
index 00000000..b2a10df6
--- /dev/null
+++ b/tests/commands/attach/test_attach_command.py
@@ -0,0 +1,221 @@
+# tests/commands/attach/test_attach_command.py
+"""Unit tests for the /attach slash command."""
+
+from __future__ import annotations
+
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from mcp_cli.chat.attachments import AttachmentStaging
+from mcp_cli.commands.attach.attach import AttachCommand
+from mcp_cli.commands.base import CommandMode
+
+
+# ---------------------------------------------------------------------------
+# Fixtures
+# ---------------------------------------------------------------------------
+
+
+@pytest.fixture
+def cmd():
+    return AttachCommand()
+
+
+@pytest.fixture
+def ctx():
+    """Mock ChatContext with a real AttachmentStaging."""
+    mock = MagicMock()
+    mock.attachment_staging = AttachmentStaging()
+    return mock
+
+
+# ---------------------------------------------------------------------------
+# Properties
+# ---------------------------------------------------------------------------
+
+
+class TestAttachCommandProperties:
+    def test_name(self, cmd):
+        assert cmd.name == "attach"
+
+    def test_aliases(self, cmd):
+        assert "file" in cmd.aliases
+        assert "image" in cmd.aliases
+
+    def test_modes(self, cmd):
+        assert cmd.modes == CommandMode.CHAT
+
+    def test_description(self, cmd):
+        assert "attach" in cmd.description.lower() or "file" in cmd.description.lower()
+
+    def test_help_text(self, cmd):
+        assert "/attach" in cmd.help_text
+        assert ".png" in cmd.help_text
+
+
+# ---------------------------------------------------------------------------
+# Execute: no context
+# ---------------------------------------------------------------------------
+
+
+class TestAttachNoContext:
+    @pytest.mark.asyncio
+    async def test_no_context(self, cmd):
+        result = await cmd.execute()
+        assert not result.success
+        assert "context" in result.error.lower()
+
+
+# ---------------------------------------------------------------------------
+# Execute: staging files
+# ---------------------------------------------------------------------------
+
+
+class TestAttachStageFiles:
+    @pytest.mark.asyncio
+    async def test_stage_image(self, cmd, ctx, tmp_path):
+        img = tmp_path / "photo.png"
+        img.write_bytes(b"\x89PNG\r\n\x1a\n" + b"\x00" * 50)
+
+        with patch("chuk_term.ui.output"):
+            result = await cmd.execute(chat_context=ctx, args=str(img))
+
+        assert result.success
+        assert ctx.attachment_staging.count == 1
+
+    @pytest.mark.asyncio
+    async def test_stage_text_file(self, cmd, ctx, tmp_path):
+        txt = tmp_path / "code.py"
+        txt.write_text("print('hello')")
+
+        with patch("chuk_term.ui.output"):
+            result = await cmd.execute(chat_context=ctx, args=str(txt))
+
+        assert result.success
+        assert ctx.attachment_staging.count == 1
+
+    @pytest.mark.asyncio
+    async def test_stage_multiple_files(self, cmd, ctx, tmp_path):
+        f1 = tmp_path / "a.txt"
+        f2 = tmp_path / "b.txt"
+        f1.write_text("alpha")
+        f2.write_text("beta")
+
+        with patch("chuk_term.ui.output"):
+            result = await cmd.execute(chat_context=ctx, args=f"{f1} {f2}")
+
+        assert result.success
+        assert ctx.attachment_staging.count == 2
+
+    @pytest.mark.asyncio
+    async def test_stage_missing_file(self, cmd, ctx):
+        with patch("chuk_term.ui.output"):
+            result = await cmd.execute(chat_context=ctx, args="/nonexistent/file.png")
+
+        assert not result.success
+        assert ctx.attachment_staging.count == 0
+
+    @pytest.mark.asyncio
+    async def test_stage_partial_failure(self, cmd, ctx, tmp_path):
+        good = tmp_path / "ok.txt"
+        good.write_text("good file")
+
+        with patch("chuk_term.ui.output"):
+            result = await cmd.execute(
+                chat_context=ctx, args=f"{good} /nonexistent/bad.png"
+            )
+
+        # Partially successful
+        assert result.success
+        assert ctx.attachment_staging.count == 1
+        assert "1 failed" in result.output
+
+    @pytest.mark.asyncio
+    async def test_args_as_list(self, cmd, ctx, tmp_path):
+        f = tmp_path / "data.csv"
+        f.write_text("a,b\n1,2")
+
+        with patch("chuk_term.ui.output"):
+            result = await cmd.execute(chat_context=ctx, args=[str(f)])
+
+        assert result.success
+        assert ctx.attachment_staging.count == 1
+
+
+# ---------------------------------------------------------------------------
+# Execute: list subcommand
+# ---------------------------------------------------------------------------
+
+
+class TestAttachList:
+    @pytest.mark.asyncio
+    async def test_list_empty(self, cmd, ctx):
+        with patch("chuk_term.ui.output"):
+            result = await cmd.execute(chat_context=ctx, args="list")
+
+        assert result.success
+        assert "no" in result.output.lower() or "0" in result.output
+
+    @pytest.mark.asyncio
+    async def test_list_with_staged(self, cmd, ctx, tmp_path):
+        f = tmp_path / "photo.png"
+        f.write_bytes(b"\x89PNG\r\n\x1a\n" + b"\x00" * 50)
+
+        with patch("chuk_term.ui.output"):
+            await cmd.execute(chat_context=ctx, args=str(f))
+            result = await cmd.execute(chat_context=ctx, args="list")
+
+        assert result.success
+        assert "photo.png" in result.output
+
+
+# ---------------------------------------------------------------------------
+# Execute: clear subcommand
+# ---------------------------------------------------------------------------
+
+
+class TestAttachClear:
+    @pytest.mark.asyncio
+    async def test_clear_empty(self, cmd, ctx):
+        with patch("chuk_term.ui.output"):
+            result = await cmd.execute(chat_context=ctx, args="clear")
+
+        assert result.success
+        assert "nothing" in result.output.lower() or "0" in result.output.lower()
+
+    @pytest.mark.asyncio
+    async def test_clear_with_staged(self, cmd, ctx, tmp_path):
+        f = tmp_path / "test.txt"
+        f.write_text("hello")
+
+        with patch("chuk_term.ui.output"):
+            await cmd.execute(chat_context=ctx, args=str(f))
+            assert ctx.attachment_staging.count == 1
+
+            result = await cmd.execute(chat_context=ctx, args="clear")
+
+        assert result.success
+        assert ctx.attachment_staging.count == 0
+        assert "1" in result.output
+
+
+# ---------------------------------------------------------------------------
+# Execute: no args (usage)
+# ---------------------------------------------------------------------------
+
+
+class TestAttachUsage:
+    @pytest.mark.asyncio
+    async def test_no_args_shows_usage(self, cmd, ctx):
+        with patch("chuk_term.ui.output"):
+            result = await cmd.execute(chat_context=ctx, args="")
+
+        assert result.success
+
+    @pytest.mark.asyncio
+    async def test_none_args_shows_usage(self, cmd, ctx):
+        with patch("chuk_term.ui.output"):
+            result = await cmd.execute(chat_context=ctx, args=None)
+
+        assert result.success
diff --git a/tests/config/test_cli_options.py b/tests/config/test_cli_options.py
index 81d9a9d4..bb29871e 100644
--- a/tests/config/test_cli_options.py
+++ b/tests/config/test_cli_options.py
@@ -328,11 +328,10 @@ def test_process_options_quiet_mode(mock_discovery, monkeypatch, tmp_path, caplo
     pass
 
 
-@patch("chuk_term.ui.output")
 @patch("mcp_cli.config.cli_options.trigger_discovery_after_setup")
 @patch("mcp_cli.utils.preferences.get_preference_manager")
 def test_process_options_disabled_server_blocked(
-    mock_pref_manager, mock_discovery, mock_output, monkeypatch, tmp_path, caplog
+    mock_pref_manager, mock_discovery, monkeypatch, tmp_path, caplog
 ):
     """Test that disabled servers are blocked even when explicitly requested."""
     mock_discovery.return_value = 0
@@ -370,10 +369,12 @@ def test_process_options_disabled_server_blocked(
         # specified should still contain what was requested
         assert specified == ["DisabledServer"]
 
-        # Should have called output.warning about disabled server
-        mock_output.warning.assert_called()
-        warning_calls = [str(call) for call in mock_output.warning.call_args_list]
-        assert any("disabled and cannot be used" in str(call) for call in warning_calls)
+        # Should have logged warning about disabled server
+        assert any(
+            "disabled" in r.message.lower()
+            for r in caplog.records
+            if r.levelname == "WARNING"
+        )
 
 
 @patch("mcp_cli.config.cli_options.trigger_discovery_after_setup")
diff --git a/tests/dashboard/test_bridge.py b/tests/dashboard/test_bridge.py
index a6528000..5e19fc5e 100644
--- a/tests/dashboard/test_bridge.py
+++ b/tests/dashboard/test_bridge.py
@@ -271,7 +271,7 @@ async def test_sends_registry_when_views_exist(self):
         ws.send.assert_awaited_once()
         sent = json.loads(ws.send.call_args[0][0])
         assert sent["type"] == "VIEW_REGISTRY"
-        assert len(sent["views"]) == 1
+        assert len(sent["payload"]["views"]) == 1
 
     @pytest.mark.asyncio
     async def test_no_send_when_registry_empty(self):
diff --git a/tests/dashboard/test_bridge_extended.py b/tests/dashboard/test_bridge_extended.py
new file mode 100644
index 00000000..90395f14
--- /dev/null
+++ b/tests/dashboard/test_bridge_extended.py
@@ -0,0 +1,898 @@
+# tests/dashboard/test_bridge_extended.py
+"""Extended tests for DashboardBridge — covers gaps identified in code review.
+
+Focus areas:
+  - on_shutdown / on_client_disconnected (pending approval cleanup)
+  - _serialise depth guard
+  - request_tool_approval return type and lifecycle
+  - Tool approval response handling edge cases
+  - on_tool_result with arguments parameter
+  - VIEW_REGISTRY envelope format consistency
+"""
+
+from __future__ import annotations
+
+import asyncio
+import json
+from unittest.mock import AsyncMock, MagicMock
+
+import pytest
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+
+def _make_bridge(agent_id: str = "test-agent"):
+    from mcp_cli.dashboard.bridge import DashboardBridge
+    from mcp_cli.dashboard.server import DashboardServer
+
+    server = MagicMock(spec=DashboardServer)
+    server.broadcast = AsyncMock()
+    server.on_browser_message = None
+    server.on_client_connected = None
+    server.on_client_disconnected = None
+    server.has_clients = True
+    bridge = DashboardBridge(server, agent_id=agent_id)
+    return bridge, server
+
+
+# ---------------------------------------------------------------------------
+# on_shutdown
+# ---------------------------------------------------------------------------
+
+
+class TestOnShutdown:
+    @pytest.mark.asyncio
+    async def test_cancels_pending_futures(self):
+        bridge, server = _make_bridge()
+        fut = asyncio.get_running_loop().create_future()
+        bridge._pending_approvals["call-1"] = fut
+        await bridge.on_shutdown()
+        assert fut.done()
+        assert fut.result() is False
+        assert len(bridge._pending_approvals) == 0
+
+    @pytest.mark.asyncio
+    async def test_shutdown_with_no_pending_is_safe(self):
+        bridge, server = _make_bridge()
+        await bridge.on_shutdown()
+        assert len(bridge._pending_approvals) == 0
+
+    @pytest.mark.asyncio
+    async def test_already_done_futures_not_modified(self):
+        bridge, server = _make_bridge()
+        fut = asyncio.get_running_loop().create_future()
+        fut.set_result(True)
+        bridge._pending_approvals["call-1"] = fut
+        await bridge.on_shutdown()
+        # Should still be True (not overwritten to False)
+        assert fut.result() is True
+
+
+# ---------------------------------------------------------------------------
+# on_client_disconnected
+# ---------------------------------------------------------------------------
+
+
+class TestOnClientDisconnected:
+    @pytest.mark.asyncio
+    async def test_cancels_pending_when_no_clients(self):
+        bridge, server = _make_bridge()
+        server.has_clients = False
+        fut = asyncio.get_running_loop().create_future()
+        bridge._pending_approvals["call-1"] = fut
+        await bridge.on_client_disconnected()
+        assert fut.done()
+        assert fut.result() is False
+
+    @pytest.mark.asyncio
+    async def test_keeps_pending_when_clients_remain(self):
+        bridge, server = _make_bridge()
+        server.has_clients = True
+        fut = asyncio.get_running_loop().create_future()
+        bridge._pending_approvals["call-1"] = fut
+        await bridge.on_client_disconnected()
+        assert not fut.done()
+        assert len(bridge._pending_approvals) == 1
+        # Clean up
+        fut.cancel()
+
+
+# ---------------------------------------------------------------------------
+# _serialise depth guard
+# ---------------------------------------------------------------------------
+
+
+class TestSerialiseDepth:
+    def test_max_depth_exceeded(self):
+        from mcp_cli.dashboard.bridge import DashboardBridge
+
+        # Build deeply nested dict
+        obj: dict = {}
+        current = obj
+        for i in range(25):
+            current["nested"] = {}
+            current = current["nested"]
+        current["value"] = "deep"
+
+        result = DashboardBridge._serialise(obj)
+        # Should hit depth limit and return placeholder string
+        serialized = json.dumps(result)
+        assert "<max depth exceeded>" in serialized
+
+    def test_normal_depth_works(self):
+        from mcp_cli.dashboard.bridge import DashboardBridge
+
+        obj = {"a": {"b": {"c": "value"}}}
+        result = DashboardBridge._serialise(obj)
+        assert result == {"a": {"b": {"c": "value"}}}
+
+    def test_circular_object_handled(self):
+        from mcp_cli.dashboard.bridge import DashboardBridge
+
+        class Circular:
+            def to_dict(self):
+                return {"self": self}
+
+        result = DashboardBridge._serialise(Circular())
+        # Should eventually hit depth limit or fall through to str()
+        serialized = json.dumps(result)
+        assert serialized  # Just ensure it doesn't crash
+
+
+# ---------------------------------------------------------------------------
+# request_tool_approval
+# ---------------------------------------------------------------------------
+
+
+class TestRequestToolApproval:
+    @pytest.mark.asyncio
+    async def test_returns_future(self):
+        bridge, server = _make_bridge()
+        fut = await bridge.request_tool_approval("test_tool", {"x": 1}, "call-1")
+        assert isinstance(fut, asyncio.Future)
+        assert "call-1" in bridge._pending_approvals
+        # Clean up
+        fut.cancel()
+
+    @pytest.mark.asyncio
+    async def test_broadcasts_approval_request(self):
+        bridge, server = _make_bridge()
+        fut = await bridge.request_tool_approval("test_tool", {"x": 1}, "call-1")
+        server.broadcast.assert_awaited_once()
+        msg = server.broadcast.call_args[0][0]
+        assert msg["type"] == "TOOL_APPROVAL_REQUEST"
+        assert msg["payload"]["tool_name"] == "test_tool"
+        assert msg["payload"]["call_id"] == "call-1"
+        # Clean up
+        fut.cancel()
+
+    @pytest.mark.asyncio
+    async def test_approval_response_resolves_future(self):
+        bridge, server = _make_bridge()
+        fut = await bridge.request_tool_approval("test_tool", {}, "call-1")
+        await bridge._handle_tool_approval_response(
+            {"call_id": "call-1", "approved": True}
+        )
+        assert fut.done()
+        assert fut.result() is True
+
+    @pytest.mark.asyncio
+    async def test_denial_response_resolves_future(self):
+        bridge, server = _make_bridge()
+        fut = await bridge.request_tool_approval("test_tool", {}, "call-1")
+        await bridge._handle_tool_approval_response(
+            {"call_id": "call-1", "approved": False}
+        )
+        assert fut.done()
+        assert fut.result() is False
+
+    @pytest.mark.asyncio
+    async def test_unknown_call_id_ignored(self):
+        bridge, server = _make_bridge()
+        # No pending approval — should not raise
+        await bridge._handle_tool_approval_response(
+            {"call_id": "nonexistent", "approved": True}
+        )
+
+    @pytest.mark.asyncio
+    async def test_response_for_done_future_ignored(self):
+        bridge, server = _make_bridge()
+        fut = await bridge.request_tool_approval("test_tool", {}, "call-1")
+        fut.set_result(False)  # Already resolved
+        # Should not raise even though future is done
+        await bridge._handle_tool_approval_response(
+            {"call_id": "call-1", "approved": True}
+        )
+
+
+# ---------------------------------------------------------------------------
+# on_tool_result with arguments
+# ---------------------------------------------------------------------------
+
+
+class TestOnToolResultArguments:
+    @pytest.mark.asyncio
+    async def test_arguments_included_in_payload(self):
+        bridge, server = _make_bridge()
+        await bridge.on_tool_result(
+            tool_name="read_file",
+            server_name="filesystem",
+            result="contents",
+            success=True,
+            arguments={"path": "/tmp/test.txt"},
+        )
+        msg = server.broadcast.call_args[0][0]
+        assert msg["payload"]["arguments"] == {"path": "/tmp/test.txt"}
+
+    @pytest.mark.asyncio
+    async def test_arguments_none_when_not_provided(self):
+        bridge, server = _make_bridge()
+        await bridge.on_tool_result(
+            tool_name="read_file",
+            server_name="filesystem",
+            result="contents",
+            success=True,
+        )
+        msg = server.broadcast.call_args[0][0]
+        assert msg["payload"]["arguments"] is None
+
+
+# ---------------------------------------------------------------------------
+# VIEW_REGISTRY envelope consistency
+# ---------------------------------------------------------------------------
+
+
+class TestViewRegistryEnvelope:
+    @pytest.mark.asyncio
+    async def test_broadcast_uses_envelope(self):
+        bridge, server = _make_bridge()
+        bridge._view_registry = [{"id": "test:view", "name": "Test"}]
+        await bridge.on_view_registry_update(bridge._view_registry)
+        msg = server.broadcast.call_args[0][0]
+        # Should be wrapped in envelope format
+        assert msg["protocol"] == "mcp-dashboard"
+        assert msg["version"] == 2
+        assert msg["type"] == "VIEW_REGISTRY"
+        assert msg["payload"]["views"] == bridge._view_registry
+
+    @pytest.mark.asyncio
+    async def test_client_connected_sends_envelope(self):
+        bridge, server = _make_bridge()
+        bridge._view_registry = [{"id": "test:view"}]
+        ws = AsyncMock()
+        await bridge._on_client_connected(ws)
+        ws.send.assert_awaited_once()
+        sent = json.loads(ws.send.call_args[0][0])
+        assert sent["protocol"] == "mcp-dashboard"
+        assert sent["type"] == "VIEW_REGISTRY"
+        assert sent["payload"]["views"] == [{"id": "test:view"}]
+
+
+# ---------------------------------------------------------------------------
+# on_plan_update
+# ---------------------------------------------------------------------------
+
+
+class TestOnPlanUpdate:
+    @pytest.mark.asyncio
+    async def test_broadcasts_plan_update(self):
+        bridge, server = _make_bridge()
+        await bridge.on_plan_update(
+            plan_id="plan-1",
+            title="Test Plan",
+            steps=[{"index": 0, "title": "Step 1", "status": "running"}],
+            status="running",
+        )
+        msg = server.broadcast.call_args[0][0]
+        assert msg["type"] == "PLAN_UPDATE"
+        assert msg["payload"]["plan_id"] == "plan-1"
+        assert msg["payload"]["title"] == "Test Plan"
+        assert len(msg["payload"]["steps"]) == 1
+        assert msg["payload"]["status"] == "running"
+
+    @pytest.mark.asyncio
+    async def test_plan_update_complete(self):
+        bridge, server = _make_bridge()
+        await bridge.on_plan_update(
+            plan_id="plan-1",
+            title="Done Plan",
+            steps=[{"index": 0, "title": "Step 1", "status": "complete"}],
+            status="complete",
+        )
+        msg = server.broadcast.call_args[0][0]
+        assert msg["payload"]["status"] == "complete"
+
+    @pytest.mark.asyncio
+    async def test_plan_update_with_error(self):
+        bridge, server = _make_bridge()
+        await bridge.on_plan_update(
+            plan_id="plan-1",
+            title="Failed Plan",
+            steps=[],
+            status="failed",
+            error="Something went wrong",
+        )
+        msg = server.broadcast.call_args[0][0]
+        assert msg["payload"]["error"] == "Something went wrong"
+
+
+# ---------------------------------------------------------------------------
+# _build_conversation_history filtering
+# ---------------------------------------------------------------------------
+
+
+class TestBuildConversationHistory:
+    """Verify that tool-role and system-role messages are excluded from history."""
+
+    def _make_ctx_with_history(self, messages):
+        """Build a mock ChatContext with the given conversation_history."""
+
+        class FakeMsg:
+            def __init__(self, d):
+                self._d = d
+
+            def to_dict(self):
+                return self._d
+
+        ctx = MagicMock()
+        ctx.conversation_history = [FakeMsg(m) for m in messages]
+        return ctx
+
+    def test_tool_messages_excluded(self):
+        bridge, _ = _make_bridge()
+        bridge.set_context(
+            self._make_ctx_with_history(
+                [
+                    {"role": "user", "content": "What time is it?"},
+                    {
+                        "role": "assistant",
+                        "content": "",
+                        "tool_calls": [
+                            {"function": {"name": "get_time", "arguments": "{}"}}
+                        ],
+                    },
+                    {
+                        "role": "tool",
+                        "content": "success=True result={'time': '12:00'}",
+                    },
+                    {
+                        "role": "assistant",
+                        "content": "It is 12:00.",
+                    },
+                ]
+            )
+        )
+        history = bridge._build_conversation_history()
+        roles = [m["role"] for m in history]
+        assert "tool" not in roles
+        assert roles == ["user", "assistant", "assistant"]
+
+    def test_system_messages_excluded(self):
+        bridge, _ = _make_bridge()
+        bridge.set_context(
+            self._make_ctx_with_history(
+                [
+                    {"role": "system", "content": "You are a helpful assistant."},
+                    {"role": "user", "content": "Hello"},
+                    {"role": "assistant", "content": "Hi there!"},
+                ]
+            )
+        )
+        history = bridge._build_conversation_history()
+        roles = [m["role"] for m in history]
+        assert "system" not in roles
+        assert roles == ["user", "assistant"]
+
+    def test_empty_history_returns_none(self):
+        bridge, _ = _make_bridge()
+        bridge.set_context(self._make_ctx_with_history([]))
+        assert bridge._build_conversation_history() is None
+
+    def test_only_tool_messages_returns_none(self):
+        bridge, _ = _make_bridge()
+        bridge.set_context(
+            self._make_ctx_with_history(
+                [
+                    {"role": "tool", "content": "result data"},
+                    {"role": "tool", "content": "more result data"},
+                ]
+            )
+        )
+        assert bridge._build_conversation_history() is None
+
+
+# ---------------------------------------------------------------------------
+# _build_activity_history
+# ---------------------------------------------------------------------------
+
+
+class TestBuildActivityHistory:
+    """Verify activity stream replay from session history."""
+
+    def _make_ctx_with_history(self, messages):
+        class FakeMsg:
+            def __init__(self, d):
+                self._d = d
+
+            def to_dict(self):
+                return self._d
+
+        ctx = MagicMock()
+        ctx.conversation_history = [FakeMsg(m) for m in messages]
+        return ctx
+
+    def test_pairs_tool_calls_with_results(self):
+        bridge, _ = _make_bridge()
+        bridge.set_context(
+            self._make_ctx_with_history(
+                [
+                    {"role": "user", "content": "What time is it?"},
+                    {
+                        "role": "assistant",
+                        "content": None,
+                        "tool_calls": [
+                            {
+                                "id": "call_1",
+                                "function": {
+                                    "name": "get_time",
+                                    "arguments": '{"tz": "UTC"}',
+                                },
+                            }
+                        ],
+                    },
+                    {
+                        "role": "tool",
+                        "content": "12:00 UTC",
+                        "tool_call_id": "call_1",
+                    },
+                    {"role": "assistant", "content": "It is 12:00 UTC."},
+                ]
+            )
+        )
+        events = bridge._build_activity_history()
+        assert events is not None
+
+        # Should have: 1 CONVERSATION_MESSAGE (for tool_calls) + 1 TOOL_RESULT
+        msg_events = [e for e in events if e["type"] == "CONVERSATION_MESSAGE"]
+        tool_events = [e for e in events if e["type"] == "TOOL_RESULT"]
+
+        assert len(msg_events) == 1
+        assert msg_events[0]["payload"]["tool_calls"] is not None
+        assert len(tool_events) == 1
+        assert tool_events[0]["payload"]["tool_name"] == "get_time"
+        assert tool_events[0]["payload"]["result"] == "12:00 UTC"
+        assert tool_events[0]["payload"]["arguments"] == {"tz": "UTC"}
+
+    def test_empty_history_returns_none(self):
+        bridge, _ = _make_bridge()
+        bridge.set_context(self._make_ctx_with_history([]))
+        assert bridge._build_activity_history() is None
+
+    def test_no_tool_calls_returns_none(self):
+        bridge, _ = _make_bridge()
+        bridge.set_context(
+            self._make_ctx_with_history(
+                [
+                    {"role": "user", "content": "Hello"},
+                    {"role": "assistant", "content": "Hi there!"},
+                ]
+            )
+        )
+        assert bridge._build_activity_history() is None
+
+    def test_reasoning_included(self):
+        bridge, _ = _make_bridge()
+        bridge.set_context(
+            self._make_ctx_with_history(
+                [
+                    {
+                        "role": "assistant",
+                        "content": "Answer",
+                        "reasoning_content": "Let me think...",
+                    },
+                ]
+            )
+        )
+        events = bridge._build_activity_history()
+        assert events is not None
+        assert len(events) == 1
+        assert events[0]["type"] == "CONVERSATION_MESSAGE"
+        assert events[0]["payload"]["reasoning"] == "Let me think..."
+
+    def test_multiple_tool_calls_in_one_message(self):
+        bridge, _ = _make_bridge()
+        bridge.set_context(
+            self._make_ctx_with_history(
+                [
+                    {
+                        "role": "assistant",
+                        "content": None,
+                        "tool_calls": [
+                            {
+                                "id": "c1",
+                                "function": {
+                                    "name": "tool_a",
+                                    "arguments": "{}",
+                                },
+                            },
+                            {
+                                "id": "c2",
+                                "function": {
+                                    "name": "tool_b",
+                                    "arguments": '{"x": 1}',
+                                },
+                            },
+                        ],
+                    },
+                    {"role": "tool", "content": "result_a", "tool_call_id": "c1"},
+                    {"role": "tool", "content": "result_b", "tool_call_id": "c2"},
+                ]
+            )
+        )
+        events = bridge._build_activity_history()
+        tool_events = [e for e in events if e["type"] == "TOOL_RESULT"]
+        assert len(tool_events) == 2
+        names = {e["payload"]["tool_name"] for e in tool_events}
+        assert names == {"tool_a", "tool_b"}
+
+
+# ---------------------------------------------------------------------------
+# Attachment support
+# ---------------------------------------------------------------------------
+
+
+class TestOnMessageWithAttachments:
+    """Verify on_message passes attachments through to payload."""
+
+    @pytest.mark.asyncio
+    async def test_with_attachments(self):
+        bridge, server = _make_bridge()
+        atts = [
+            {"display_name": "photo.png", "kind": "image", "preview_url": "data:..."}
+        ]
+        await bridge.on_message("user", "describe this", attachments=atts)
+        msg = server.broadcast.call_args[0][0]
+        assert msg["payload"]["attachments"] == atts
+        assert msg["payload"]["content"] == "describe this"
+
+    @pytest.mark.asyncio
+    async def test_no_attachments_backward_compat(self):
+        bridge, server = _make_bridge()
+        await bridge.on_message("user", "hello")
+        msg = server.broadcast.call_args[0][0]
+        assert msg["payload"]["attachments"] is None
+
+
+class TestConversationHistoryWithAttachments:
+    """Verify multimodal user messages produce attachments in history."""
+
+    def _make_ctx_with_history(self, messages):
+        class FakeMsg:
+            def __init__(self, d):
+                self._d = d
+
+            def to_dict(self):
+                return self._d
+
+        ctx = MagicMock()
+        ctx.conversation_history = [FakeMsg(m) for m in messages]
+        return ctx
+
+    def test_multimodal_user_message(self):
+        bridge, _ = _make_bridge()
+        bridge.set_context(
+            self._make_ctx_with_history(
+                [
+                    {
+                        "role": "user",
+                        "content": [
+                            {"type": "text", "text": "describe this image"},
+                            {
+                                "type": "image_url",
+                                "image_url": {"url": "https://example.com/cat.png"},
+                            },
+                        ],
+                    },
+                    {"role": "assistant", "content": "It's a cat!"},
+                ]
+            )
+        )
+        history = bridge._build_conversation_history()
+        assert len(history) == 2
+        user_msg = history[0]
+        assert user_msg["content"] == "describe this image"
+        assert user_msg["attachments"] is not None
+        assert len(user_msg["attachments"]) == 1
+        assert user_msg["attachments"][0]["kind"] == "image"
+        # Assistant message has no attachments
+        assert history[1]["attachments"] is None
+
+    def test_text_only_no_attachments(self):
+        bridge, _ = _make_bridge()
+        bridge.set_context(
+            self._make_ctx_with_history([{"role": "user", "content": "hello"}])
+        )
+        history = bridge._build_conversation_history()
+        assert history[0]["attachments"] is None
+
+
+class TestActivityHistoryWithAttachments:
+    """Verify user attachment events appear in activity history."""
+
+    def _make_ctx_with_history(self, messages):
+        class FakeMsg:
+            def __init__(self, d):
+                self._d = d
+
+            def to_dict(self):
+                return self._d
+
+        ctx = MagicMock()
+        ctx.conversation_history = [FakeMsg(m) for m in messages]
+        return ctx
+
+    def test_user_attachments_in_activity(self):
+        bridge, _ = _make_bridge()
+        bridge.set_context(
+            self._make_ctx_with_history(
+                [
+                    {
+                        "role": "user",
+                        "content": [
+                            {"type": "text", "text": "look at this"},
+                            {
+                                "type": "image_url",
+                                "image_url": {"url": "https://example.com/img.png"},
+                            },
+                        ],
+                    },
+                ]
+            )
+        )
+        events = bridge._build_activity_history()
+        assert events is not None
+        assert len(events) == 1
+        assert events[0]["payload"]["role"] == "user"
+        assert events[0]["payload"]["attachments"] is not None
+
+    def test_no_attachments_no_user_event(self):
+        bridge, _ = _make_bridge()
+        bridge.set_context(
+            self._make_ctx_with_history(
+                [
+                    {"role": "user", "content": "hello"},
+                    {"role": "assistant", "content": "hi"},
+                ]
+            )
+        )
+        assert bridge._build_activity_history() is None
+
+
+# ---------------------------------------------------------------------------
+# agent_id plumbing
+# ---------------------------------------------------------------------------
+
+
+class TestAgentIdInPayloads:
+    """Verify agent_id from bridge constructor appears in all payloads."""
+
+    @pytest.mark.asyncio
+    async def test_agent_id_in_tool_result_payload(self):
+        bridge, server = _make_bridge(agent_id="agent-x")
+        await bridge.on_tool_result(
+            tool_name="test_tool",
+            server_name="srv",
+            result="ok",
+            success=True,
+        )
+        msg = server.broadcast.call_args[0][0]
+        assert msg["payload"]["agent_id"] == "agent-x"
+
+    @pytest.mark.asyncio
+    async def test_agent_id_in_agent_state_payload(self):
+        bridge, server = _make_bridge(agent_id="agent-y")
+        await bridge.on_agent_state(status="thinking")
+        msg = server.broadcast.call_args[0][0]
+        assert msg["payload"]["agent_id"] == "agent-y"
+
+    @pytest.mark.asyncio
+    async def test_agent_id_in_message_payload(self):
+        bridge, server = _make_bridge(agent_id="agent-z")
+        await bridge.on_message(role="user", content="hello")
+        msg = server.broadcast.call_args[0][0]
+        assert msg["payload"]["agent_id"] == "agent-z"
+
+    @pytest.mark.asyncio
+    async def test_agent_id_in_plan_update_payload(self):
+        bridge, server = _make_bridge(agent_id="planner")
+        await bridge.on_plan_update(
+            plan_id="p1", title="Test", steps=[], status="running"
+        )
+        msg = server.broadcast.call_args[0][0]
+        assert msg["payload"]["agent_id"] == "planner"
+
+    def test_agent_id_in_activity_history(self):
+        bridge, _ = _make_bridge(agent_id="replay-agent")
+
+        class FakeMsg:
+            def __init__(self, d):
+                self._d = d
+
+            def to_dict(self):
+                return self._d
+
+        ctx = MagicMock()
+        ctx.conversation_history = [
+            FakeMsg(
+                {
+                    "role": "assistant",
+                    "content": None,
+                    "tool_calls": [
+                        {
+                            "id": "c1",
+                            "function": {"name": "tool_a", "arguments": "{}"},
+                        }
+                    ],
+                }
+            ),
+            FakeMsg(
+                {
+                    "role": "tool",
+                    "content": "result",
+                    "tool_call_id": "c1",
+                }
+            ),
+        ]
+        bridge.set_context(ctx)
+        events = bridge._build_activity_history()
+        tool_events = [e for e in events if e["type"] == "TOOL_RESULT"]
+        assert len(tool_events) == 1
+        assert tool_events[0]["payload"]["agent_id"] == "replay-agent"
+
+    def test_protocol_version_is_2(self):
+        from mcp_cli.dashboard.bridge import _VERSION
+
+        assert _VERSION == 2
+
+
+# ---------------------------------------------------------------------------
+# Bridge with AgentRouter
+# ---------------------------------------------------------------------------
+
+
+class TestBridgeWithRouter:
+    """Verify bridge works correctly when constructed with an AgentRouter."""
+
+    def _make_router_bridge(self, agent_id: str = "routed-agent"):
+        from mcp_cli.dashboard.bridge import DashboardBridge
+        from mcp_cli.dashboard.router import AgentRouter
+        from mcp_cli.dashboard.server import DashboardServer
+
+        server = MagicMock(spec=DashboardServer)
+        server.broadcast = AsyncMock()
+        server.send_to_client = AsyncMock()
+        server.has_clients = True
+        server.on_browser_message = None
+        server.on_client_connected = None
+        server.on_client_disconnected = None
+
+        router = AgentRouter(server)
+        bridge = DashboardBridge(router, agent_id=agent_id)
+        return bridge, router, server
+
+    @pytest.mark.asyncio
+    async def test_broadcast_goes_through_router(self):
+        bridge, router, server = self._make_router_bridge("agent-r")
+        await bridge.on_agent_state(status="thinking")
+        # Should ultimately reach server.broadcast via router
+        server.broadcast.assert_awaited_once()
+        msg = server.broadcast.call_args[0][0]
+        assert msg["type"] == "AGENT_STATE"
+        assert msg["payload"]["agent_id"] == "agent-r"
+
+    def test_has_clients_proxies_through_router(self):
+        bridge, router, server = self._make_router_bridge()
+        server.has_clients = True
+        assert bridge.has_clients is True
+        server.has_clients = False
+        assert bridge.has_clients is False
+
+    def test_server_attribute_still_accessible(self):
+        bridge, router, server = self._make_router_bridge()
+        # bridge.server should point to the DashboardServer, not the router
+        assert bridge.server is server
+
+
+# ---------------------------------------------------------------------------
+# Browser file staging via _on_browser_message
+# ---------------------------------------------------------------------------
+
+
+class TestBrowserFileStaging:
+    """Tests for file attachment handling in _on_browser_message."""
+
+    @staticmethod
+    def _make_ctx_with_staging():
+        from mcp_cli.chat.attachments import AttachmentStaging
+
+        ctx = MagicMock()
+        ctx.attachment_staging = AttachmentStaging()
+        return ctx
+
+    @pytest.mark.asyncio
+    async def test_files_staged_on_context(self):
+        import base64
+
+        bridge, _server = _make_bridge()
+        ctx = self._make_ctx_with_staging()
+        bridge._ctx = ctx
+        bridge._input_queue = asyncio.Queue()
+
+        raw = b"hello world"
+        b64 = base64.b64encode(raw).decode()
+        msg = {
+            "type": "USER_MESSAGE",
+            "content": "describe this",
+            "files": [{"name": "test.txt", "data": b64, "mime_type": "text/plain"}],
+        }
+        await bridge._on_browser_message(msg)
+
+        # File should be staged
+        assert ctx.attachment_staging.count == 1
+        att = ctx.attachment_staging.peek()[0]
+        assert att.display_name == "test.txt"
+        assert att.source == "browser:test.txt"
+        # Text should have been queued
+        assert bridge._input_queue.qsize() == 1
+        assert await bridge._input_queue.get() == "describe this"
+
+    @pytest.mark.asyncio
+    async def test_files_only_queues_space(self):
+        import base64
+
+        bridge, _server = _make_bridge()
+        ctx = self._make_ctx_with_staging()
+        bridge._ctx = ctx
+        bridge._input_queue = asyncio.Queue()
+
+        raw = b"\x89PNG\r\n\x1a\n" + b"\x00" * 50
+        b64 = base64.b64encode(raw).decode()
+        msg = {
+            "type": "USER_MESSAGE",
+            "content": "",
+            "files": [{"name": "img.png", "data": b64, "mime_type": "image/png"}],
+        }
+        await bridge._on_browser_message(msg)
+
+        # Space should be queued to trigger chat loop
+        assert bridge._input_queue.qsize() == 1
+        assert await bridge._input_queue.get() == " "
+        assert ctx.attachment_staging.count == 1
+
+    @pytest.mark.asyncio
+    async def test_bad_file_logged_not_crashed(self):
+        bridge, _server = _make_bridge()
+        ctx = self._make_ctx_with_staging()
+        bridge._ctx = ctx
+        bridge._input_queue = asyncio.Queue()
+
+        msg = {
+            "type": "USER_MESSAGE",
+            "content": "hi",
+            "files": [
+                {
+                    "name": "bad.xyz",
+                    "data": "aGVsbG8=",
+                    "mime_type": "application/octet-stream",
+                }
+            ],
+        }
+        # Should not raise
+        await bridge._on_browser_message(msg)
+        # Bad file should not be staged
+        assert ctx.attachment_staging.count == 0
+        # Text should still be queued
+        assert bridge._input_queue.qsize() == 1
diff --git a/tests/dashboard/test_integration.py b/tests/dashboard/test_integration.py
index 164f3e59..bb531a89 100644
--- a/tests/dashboard/test_integration.py
+++ b/tests/dashboard/test_integration.py
@@ -165,7 +165,7 @@ async def test_bridge_sends_view_registry_to_new_client(self, live_server):
 
         msg = json.loads(raw)
         assert msg["type"] == "VIEW_REGISTRY"
-        assert msg["views"][0]["id"] == "stats:main"
+        assert msg["payload"]["views"][0]["id"] == "stats:main"
 
 
 # ---------------------------------------------------------------------------
@@ -309,4 +309,4 @@ async def test_view_discovered_from_tool_result_meta_ui(self, live_server):
         assert "VIEW_REGISTRY" in types
 
         registry_msg = next(m for m in msgs if m["type"] == "VIEW_REGISTRY")
-        assert any(v["id"] == "stats:main" for v in registry_msg["views"])
+        assert any(v["id"] == "stats:main" for v in registry_msg["payload"]["views"])
diff --git a/tests/dashboard/test_launcher.py b/tests/dashboard/test_launcher.py
index 1d7680e3..0baa902a 100644
--- a/tests/dashboard/test_launcher.py
+++ b/tests/dashboard/test_launcher.py
@@ -7,26 +7,45 @@
 
 import pytest
 
+from mcp_cli.dashboard.router import AgentRouter
+
 
 def _mock_server(port: int = 9120):
     """Return a mock DashboardServer whose start() resolves to the given port."""
     srv = AsyncMock()
     srv.start = AsyncMock(return_value=port)
+    # AgentRouter needs to set these attributes
+    srv.on_browser_message = None
+    srv.on_client_connected = None
+    srv.on_client_disconnected = None
+    srv.has_clients = False
     return srv
 
 
 class TestLaunchDashboard:
     @pytest.mark.asyncio
-    async def test_returns_server_and_port(self):
+    async def test_returns_server_router_and_port(self):
         from mcp_cli.dashboard import launcher
 
         srv = _mock_server(9120)
         with patch.object(launcher, "DashboardServer", return_value=srv):
-            server, port = await launcher.launch_dashboard()
+            server, router, port = await launcher.launch_dashboard()
 
         assert server is srv
+        assert isinstance(router, AgentRouter)
         assert port == 9120
 
+    @pytest.mark.asyncio
+    async def test_returns_router(self):
+        from mcp_cli.dashboard import launcher
+
+        srv = _mock_server(9120)
+        with patch.object(launcher, "DashboardServer", return_value=srv):
+            _, router, _ = await launcher.launch_dashboard()
+
+        assert isinstance(router, AgentRouter)
+        assert router.server is srv
+
     @pytest.mark.asyncio
     async def test_opens_browser_when_no_browser_false(self):
         from mcp_cli.dashboard import launcher
@@ -53,7 +72,7 @@ async def test_webbrowser_exception_suppressed(self):
 
         with patch.object(launcher, "DashboardServer", return_value=_mock_server(9120)):
             with patch("webbrowser.open", side_effect=Exception("no display")):
-                server, port = await launcher.launch_dashboard(no_browser=False)
+                server, router, port = await launcher.launch_dashboard(no_browser=False)
 
         assert port == 9120  # function completed successfully
 
@@ -64,7 +83,7 @@ async def test_preferred_port_passed_to_server(self):
         srv = _mock_server(8080)
         with patch.object(launcher, "DashboardServer", return_value=srv):
             with patch("webbrowser.open"):
-                _, port = await launcher.launch_dashboard(port=8080)
+                _, _, port = await launcher.launch_dashboard(port=8080)
 
         srv.start.assert_called_once_with(8080)
         assert port == 8080
diff --git a/tests/dashboard/test_router.py b/tests/dashboard/test_router.py
new file mode 100644
index 00000000..01650afc
--- /dev/null
+++ b/tests/dashboard/test_router.py
@@ -0,0 +1,535 @@
+# tests/dashboard/test_router.py
+"""Unit tests for AgentRouter."""
+
+from __future__ import annotations
+
+from dataclasses import asdict
+from unittest.mock import AsyncMock, MagicMock
+
+import pytest
+
+from mcp_cli.dashboard.router import AgentDescriptor, AgentRouter
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+
+def _make_server():
+    """Return a mock DashboardServer."""
+    from mcp_cli.dashboard.server import DashboardServer
+
+    server = MagicMock(spec=DashboardServer)
+    server.broadcast = AsyncMock()
+    server.send_to_client = AsyncMock()
+    server.has_clients = True
+    server.on_browser_message = None
+    server.on_client_connected = None
+    server.on_client_disconnected = None
+    return server
+
+
+def _make_bridge(agent_id: str = "agent-1"):
+    """Return a mock DashboardBridge."""
+    bridge = MagicMock()
+    bridge.agent_id = agent_id
+    bridge._on_browser_message = AsyncMock()
+    bridge._on_client_connected = AsyncMock()
+    bridge.on_client_disconnected = AsyncMock()
+    return bridge
+
+
+# ---------------------------------------------------------------------------
+# TestRouterSingleAgent
+# ---------------------------------------------------------------------------
+
+
+class TestRouterSingleAgent:
+    """Single-bridge router behaves identically to direct wiring."""
+
+    @pytest.mark.asyncio
+    async def test_broadcast_from_agent_delegates_to_server(self):
+        server = _make_server()
+        router = AgentRouter(server)
+        bridge = _make_bridge("agent-1")
+        router.register_agent("agent-1", bridge)
+
+        msg = {"type": "TEST", "payload": {}}
+        await router.broadcast_from_agent("agent-1", msg)
+        server.broadcast.assert_awaited_once_with(msg)
+
+    @pytest.mark.asyncio
+    async def test_browser_message_routed_to_sole_bridge(self):
+        server = _make_server()
+        router = AgentRouter(server)
+        bridge = _make_bridge("agent-1")
+        router.register_agent("agent-1", bridge)
+
+        msg = {"type": "USER_MESSAGE", "content": "hi"}
+        await router._on_browser_message(msg)
+        bridge._on_browser_message.assert_awaited_once_with(msg)
+
+    @pytest.mark.asyncio
+    async def test_browser_message_with_agent_id_routes_correctly(self):
+        server = _make_server()
+        router = AgentRouter(server)
+        bridge = _make_bridge("agent-1")
+        router.register_agent("agent-1", bridge)
+
+        msg = {"type": "USER_MESSAGE", "content": "hi", "agent_id": "agent-1"}
+        await router._on_browser_message(msg)
+        bridge._on_browser_message.assert_awaited_once_with(msg)
+
+    @pytest.mark.asyncio
+    async def test_client_connected_delegates_to_bridge(self):
+        server = _make_server()
+        router = AgentRouter(server)
+        bridge = _make_bridge("agent-1")
+        router.register_agent("agent-1", bridge)
+
+        ws = AsyncMock()
+        await router._on_client_connected(ws)
+        bridge._on_client_connected.assert_awaited_once_with(ws)
+
+    @pytest.mark.asyncio
+    async def test_client_disconnected_delegates_to_bridge(self):
+        server = _make_server()
+        router = AgentRouter(server)
+        bridge = _make_bridge("agent-1")
+        router.register_agent("agent-1", bridge)
+
+        await router._on_client_disconnected()
+        bridge.on_client_disconnected.assert_awaited_once()
+
+    def test_has_clients_proxies_to_server(self):
+        server = _make_server()
+        server.has_clients = True
+        router = AgentRouter(server)
+        assert router.has_clients is True
+        server.has_clients = False
+        assert router.has_clients is False
+
+
+# ---------------------------------------------------------------------------
+# TestRouterRegistration
+# ---------------------------------------------------------------------------
+
+
+class TestRouterRegistration:
+    def test_register_agent_adds_bridge(self):
+        server = _make_server()
+        router = AgentRouter(server)
+        bridge = _make_bridge("a")
+        router.register_agent("a", bridge)
+        assert "a" in router._bridges
+
+    def test_unregister_agent_removes_bridge(self):
+        server = _make_server()
+        router = AgentRouter(server)
+        bridge = _make_bridge("a")
+        router.register_agent("a", bridge)
+        router.unregister_agent("a")
+        assert "a" not in router._bridges
+
+    def test_register_multiple_agents(self):
+        server = _make_server()
+        router = AgentRouter(server)
+        b1 = _make_bridge("a")
+        b2 = _make_bridge("b")
+        router.register_agent("a", b1)
+        router.register_agent("b", b2)
+        assert len(router._bridges) == 2
+
+
+# ---------------------------------------------------------------------------
+# TestRouterTwoAgents
+# ---------------------------------------------------------------------------
+
+
+class TestRouterTwoAgents:
+    @pytest.mark.asyncio
+    async def test_message_with_unknown_agent_id_logs_debug(self):
+        server = _make_server()
+        router = AgentRouter(server)
+        b1 = _make_bridge("a")
+        b2 = _make_bridge("b")
+        router.register_agent("a", b1)
+        router.register_agent("b", b2)
+
+        msg = {"type": "USER_MESSAGE", "agent_id": "unknown"}
+        await router._on_browser_message(msg)
+        b1._on_browser_message.assert_not_awaited()
+        b2._on_browser_message.assert_not_awaited()
+
+    @pytest.mark.asyncio
+    async def test_client_connected_replays_default_bridge_only(self):
+        server = _make_server()
+        router = AgentRouter(server)
+        b1 = _make_bridge("a")
+        b2 = _make_bridge("b")
+        router.register_agent("a", b1)
+        router.register_agent("b", b2)
+
+        ws = AsyncMock()
+        await router._on_client_connected(ws)
+        # Only the default (first registered) agent is replayed
+        b1._on_client_connected.assert_awaited_once_with(ws)
+        b2._on_client_connected.assert_not_awaited()
+
+    @pytest.mark.asyncio
+    async def test_client_disconnected_notifies_all_bridges(self):
+        server = _make_server()
+        router = AgentRouter(server)
+        b1 = _make_bridge("a")
+        b2 = _make_bridge("b")
+        router.register_agent("a", b1)
+        router.register_agent("b", b2)
+
+        await router._on_client_disconnected()
+        b1.on_client_disconnected.assert_awaited_once()
+        b2.on_client_disconnected.assert_awaited_once()
+
+
+# ---------------------------------------------------------------------------
+# TestAgentDescriptor
+# ---------------------------------------------------------------------------
+
+
+class TestAgentDescriptor:
+    def test_defaults(self):
+        desc = AgentDescriptor(agent_id="a1", name="Agent One")
+        assert desc.agent_id == "a1"
+        assert desc.name == "Agent One"
+        assert desc.status == "active"
+        assert desc.role == ""
+        assert desc.model == ""
+        assert desc.parent_agent_id is None
+        assert desc.tool_count == 0
+        assert desc.message_count == 0
+
+    def test_asdict_roundtrip(self):
+        desc = AgentDescriptor(agent_id="x", name="X", role="worker", model="gpt-4")
+        d = asdict(desc)
+        assert d["agent_id"] == "x"
+        assert d["role"] == "worker"
+        assert d["model"] == "gpt-4"
+
+
+# ---------------------------------------------------------------------------
+# TestRouterFocusTracking
+# ---------------------------------------------------------------------------
+
+
+class TestRouterFocusTracking:
+    @pytest.mark.asyncio
+    async def test_focus_agent_stores_focus(self):
+        server = _make_server()
+        router = AgentRouter(server)
+        b1 = _make_bridge("a")
+        b2 = _make_bridge("b")
+        router.register_agent("a", b1)
+        router.register_agent("b", b2)
+
+        ws = AsyncMock()
+        msg = {"type": "FOCUS_AGENT", "agent_id": "b"}
+        await router._on_browser_message(msg, ws)
+        assert router._client_focus[ws] == "b"
+
+    @pytest.mark.asyncio
+    async def test_focus_agent_replays_only_focused_bridge(self):
+        server = _make_server()
+        router = AgentRouter(server)
+        b1 = _make_bridge("a")
+        b2 = _make_bridge("b")
+        router.register_agent("a", b1)
+        router.register_agent("b", b2)
+
+        ws = AsyncMock()
+        msg = {"type": "FOCUS_AGENT", "agent_id": "b"}
+        await router._on_browser_message(msg, ws)
+        b2._on_client_connected.assert_awaited_once_with(ws)
+        b1._on_client_connected.assert_not_awaited()
+
+    @pytest.mark.asyncio
+    async def test_browser_message_uses_focus_when_no_agent_id(self):
+        server = _make_server()
+        router = AgentRouter(server)
+        b1 = _make_bridge("a")
+        b2 = _make_bridge("b")
+        router.register_agent("a", b1)
+        router.register_agent("b", b2)
+
+        ws = AsyncMock()
+        # Set focus to "b"
+        router._client_focus[ws] = "b"
+        msg = {"type": "USER_MESSAGE", "content": "hi"}
+        await router._on_browser_message(msg, ws)
+        b2._on_browser_message.assert_awaited_once_with(msg)
+        b1._on_browser_message.assert_not_awaited()
+
+
+# ---------------------------------------------------------------------------
+# TestRouterAgentList
+# ---------------------------------------------------------------------------
+
+
+class TestRouterAgentList:
+    @pytest.mark.asyncio
+    async def test_client_connected_sends_agent_list(self):
+        server = _make_server()
+        router = AgentRouter(server)
+        bridge = _make_bridge("a")
+        router.register_agent("a", bridge)
+
+        ws = AsyncMock()
+        await router._on_client_connected(ws)
+        # send_to_client is called with AGENT_LIST envelope
+        server.send_to_client.assert_awaited()
+        call_args = server.send_to_client.call_args_list[0]
+        msg = call_args[0][1]  # second positional arg
+        assert msg["type"] == "AGENT_LIST"
+        assert len(msg["payload"]["agents"]) == 1
+        assert msg["payload"]["agents"][0]["agent_id"] == "a"
+
+    @pytest.mark.asyncio
+    async def test_request_agent_list_not_forwarded_to_bridge(self):
+        server = _make_server()
+        router = AgentRouter(server)
+        bridge = _make_bridge("a")
+        router.register_agent("a", bridge)
+
+        ws = AsyncMock()
+        msg = {"type": "REQUEST_AGENT_LIST"}
+        await router._on_browser_message(msg, ws)
+        bridge._on_browser_message.assert_not_awaited()
+        server.send_to_client.assert_awaited()
+
+    @pytest.mark.asyncio
+    async def test_client_connected_sets_default_focus(self):
+        server = _make_server()
+        router = AgentRouter(server)
+        bridge = _make_bridge("a")
+        router.register_agent("a", bridge)
+
+        ws = AsyncMock()
+        await router._on_client_connected(ws)
+        assert router._client_focus[ws] == "a"
+
+
+# ---------------------------------------------------------------------------
+# TestRouterDescriptorBackwardCompat
+# ---------------------------------------------------------------------------
+
+
+class TestRouterDescriptorBackwardCompat:
+    def test_register_without_descriptor_creates_default(self):
+        server = _make_server()
+        router = AgentRouter(server)
+        bridge = _make_bridge("test-agent")
+        router.register_agent("test-agent", bridge)
+        desc = router._agent_descriptors["test-agent"]
+        assert desc.agent_id == "test-agent"
+        assert desc.name == "test-agent"
+        assert desc.status == "active"
+
+    def test_register_with_custom_descriptor(self):
+        server = _make_server()
+        router = AgentRouter(server)
+        bridge = _make_bridge("a")
+        desc = AgentDescriptor(agent_id="a", name="Custom", role="planner")
+        router.register_agent("a", bridge, descriptor=desc)
+        assert router._agent_descriptors["a"].name == "Custom"
+        assert router._agent_descriptors["a"].role == "planner"
+
+
+# ---------------------------------------------------------------------------
+# TestBroadcastGlobal
+# ---------------------------------------------------------------------------
+
+
+class TestBroadcastGlobal:
+    @pytest.mark.asyncio
+    async def test_broadcast_global_delegates_to_server(self):
+        server = _make_server()
+        router = AgentRouter(server)
+        msg = {"type": "AGENT_LIST", "payload": {}}
+        await router.broadcast_global(msg)
+        server.broadcast.assert_awaited_once_with(msg)
+
+
+# ---------------------------------------------------------------------------
+# TestUpdateAgentStatus
+# ---------------------------------------------------------------------------
+
+
+class TestUpdateAgentStatus:
+    @pytest.mark.asyncio
+    async def test_update_status_changes_descriptor_and_broadcasts(self):
+        server = _make_server()
+        router = AgentRouter(server)
+        bridge = _make_bridge("a")
+        router.register_agent("a", bridge)
+
+        await router.update_agent_status("a", "paused")
+        assert router._agent_descriptors["a"].status == "paused"
+        server.broadcast.assert_awaited_once()
+        msg = server.broadcast.call_args[0][0]
+        assert msg["type"] == "AGENT_STATUS"
+        assert msg["payload"]["agent_id"] == "a"
+        assert msg["payload"]["status"] == "paused"
+
+    @pytest.mark.asyncio
+    async def test_update_status_unknown_agent_does_nothing(self):
+        server = _make_server()
+        router = AgentRouter(server)
+        await router.update_agent_status("nonexistent", "failed")
+        server.broadcast.assert_not_awaited()
+
+
+# ---------------------------------------------------------------------------
+# TestRouterAgentMessage
+# ---------------------------------------------------------------------------
+
+
+class TestRouterAgentMessage:
+    @pytest.mark.asyncio
+    async def test_agent_message_forwarded_to_target(self):
+        server = _make_server()
+        router = AgentRouter(server)
+        b1 = _make_bridge("a")
+        b2 = _make_bridge("b")
+        router.register_agent("a", b1)
+        router.register_agent("b", b2)
+
+        msg = {
+            "type": "AGENT_MESSAGE",
+            "from_agent": "a",
+            "to_agent": "b",
+            "content": "hello",
+        }
+        await router._on_browser_message(msg)
+        b2._on_browser_message.assert_awaited_once()
+        call_msg = b2._on_browser_message.call_args[0][0]
+        assert call_msg["type"] == "USER_MESSAGE"
+        assert "hello" in call_msg["content"]
+        b1._on_browser_message.assert_not_awaited()
+
+    @pytest.mark.asyncio
+    async def test_agent_message_to_unknown_is_noop(self):
+        server = _make_server()
+        router = AgentRouter(server)
+        b1 = _make_bridge("a")
+        router.register_agent("a", b1)
+
+        msg = {
+            "type": "AGENT_MESSAGE",
+            "from_agent": "a",
+            "to_agent": "nonexistent",
+            "content": "hello",
+        }
+        await router._on_browser_message(msg)
+        b1._on_browser_message.assert_not_awaited()
+
+
+# ---------------------------------------------------------------------------
+# TestRouterSubscriptions
+# ---------------------------------------------------------------------------
+
+
+class TestRouterSubscriptions:
+    @pytest.mark.asyncio
+    async def test_subscribe_stores_subscriptions(self):
+        server = _make_server()
+        router = AgentRouter(server)
+        ws = AsyncMock()
+        msg = {"type": "SUBSCRIBE", "agents": ["a", "b"], "global": False}
+        await router._on_browser_message(msg, ws)
+        assert router._client_subscriptions[ws] == {"a", "b"}
+
+    @pytest.mark.asyncio
+    async def test_subscribe_global_adds_wildcard(self):
+        server = _make_server()
+        router = AgentRouter(server)
+        ws = AsyncMock()
+        msg = {"type": "SUBSCRIBE", "agents": ["a"], "global": True}
+        await router._on_browser_message(msg, ws)
+        assert "*" in router._client_subscriptions[ws]
+        assert "a" in router._client_subscriptions[ws]
+
+    @pytest.mark.asyncio
+    async def test_broadcast_from_agent_filters_by_subscription(self):
+        server = _make_server()
+        router = AgentRouter(server)
+        ws1 = AsyncMock()
+        ws2 = AsyncMock()
+        # ws1 subscribes to "a" only, ws2 subscribes to all
+        router._client_subscriptions[ws1] = {"a"}
+        router._client_subscriptions[ws2] = {"*"}
+
+        msg = {"type": "TOOL_RESULT", "payload": {}}
+        await router.broadcast_from_agent("b", msg)
+        # ws1 is NOT subscribed to "b", so only ws2 should receive
+        calls = server.send_to_client.call_args_list
+        assert len(calls) == 1
+        assert calls[0][0][0] is ws2
+
+    @pytest.mark.asyncio
+    async def test_broadcast_from_agent_no_subscriptions_broadcasts_all(self):
+        server = _make_server()
+        router = AgentRouter(server)
+        # No subscriptions configured — should broadcast to all
+        msg = {"type": "TOOL_RESULT", "payload": {}}
+        await router.broadcast_from_agent("a", msg)
+        server.broadcast.assert_awaited_once_with(msg)
+
+    @pytest.mark.asyncio
+    async def test_client_connected_sets_default_subscription(self):
+        server = _make_server()
+        router = AgentRouter(server)
+        bridge = _make_bridge("a")
+        router.register_agent("a", bridge)
+
+        ws = AsyncMock()
+        await router._on_client_connected(ws)
+        assert router._client_subscriptions[ws] == {"*"}
+
+    @pytest.mark.asyncio
+    async def test_client_disconnected_cleans_up_state(self):
+        server = _make_server()
+        router = AgentRouter(server)
+        bridge = _make_bridge("a")
+        router.register_agent("a", bridge)
+
+        ws = AsyncMock()
+        await router._on_client_connected(ws)
+        assert ws in router._client_focus
+        assert ws in router._client_subscriptions
+
+        await router._on_client_disconnected(ws)
+        assert ws not in router._client_focus
+        assert ws not in router._client_subscriptions
+
+    @pytest.mark.asyncio
+    async def test_client_disconnected_without_ws_still_works(self):
+        """Backward compat: calling with no ws arg doesn't crash."""
+        server = _make_server()
+        router = AgentRouter(server)
+        bridge = _make_bridge("a")
+        router.register_agent("a", bridge)
+
+        await router._on_client_disconnected()
+        bridge.on_client_disconnected.assert_awaited_once()
+
+    @pytest.mark.asyncio
+    async def test_subscribe_replaces_previous(self):
+        server = _make_server()
+        router = AgentRouter(server)
+        ws = AsyncMock()
+        msg1 = {"type": "SUBSCRIBE", "agents": ["a", "b"], "global": False}
+        await router._on_browser_message(msg1, ws)
+        assert router._client_subscriptions[ws] == {"a", "b"}
+
+        msg2 = {"type": "SUBSCRIBE", "agents": ["c"], "global": True}
+        await router._on_browser_message(msg2, ws)
+        assert router._client_subscriptions[ws] == {"c", "*"}
diff --git a/tests/dashboard/test_server.py b/tests/dashboard/test_server.py
index d5042e23..4363e83d 100644
--- a/tests/dashboard/test_server.py
+++ b/tests/dashboard/test_server.py
@@ -148,6 +148,73 @@ async def on_connect(ws):
             await result
         assert fake_ws in connected
 
+    @pytest.mark.asyncio
+    async def test_handle_browser_message_passes_ws_to_two_arg_callback(self):
+        from mcp_cli.dashboard.server import DashboardServer
+
+        s = DashboardServer()
+        received = []
+
+        async def handler(msg, ws):
+            received.append((msg, ws))
+
+        s.on_browser_message = handler
+        fake_ws = AsyncMock()
+        await s._handle_browser_message(
+            '{"type":"USER_MESSAGE","content":"hi"}', fake_ws
+        )
+        assert len(received) == 1
+        assert received[0][0] == {"type": "USER_MESSAGE", "content": "hi"}
+        assert received[0][1] is fake_ws
+
+    @pytest.mark.asyncio
+    async def test_handle_browser_message_fallback_to_one_arg_callback(self):
+        from mcp_cli.dashboard.server import DashboardServer
+
+        s = DashboardServer()
+        received = []
+
+        async def handler(msg):
+            received.append(msg)
+
+        s.on_browser_message = handler
+        fake_ws = AsyncMock()
+        await s._handle_browser_message(
+            '{"type":"USER_MESSAGE","content":"hi"}', fake_ws
+        )
+        assert len(received) == 1
+        assert received[0] == {"type": "USER_MESSAGE", "content": "hi"}
+
+
+# ---------------------------------------------------------------------------
+# send_to_client
+# ---------------------------------------------------------------------------
+
+
+class TestSendToClient:
+    @pytest.mark.asyncio
+    async def test_send_to_client_basic(self):
+        from mcp_cli.dashboard.server import DashboardServer
+
+        s = DashboardServer()
+        ws = AsyncMock()
+        s._clients.add(ws)
+        await s.send_to_client(ws, {"type": "TEST"})
+        ws.send.assert_awaited_once()
+        payload = json.loads(ws.send.call_args[0][0])
+        assert payload["type"] == "TEST"
+
+    @pytest.mark.asyncio
+    async def test_send_to_client_dead_ws_discarded(self):
+        from mcp_cli.dashboard.server import DashboardServer
+
+        s = DashboardServer()
+        ws = AsyncMock()
+        ws.send.side_effect = Exception("connection closed")
+        s._clients.add(ws)
+        await s.send_to_client(ws, {"type": "TEST"})
+        assert ws not in s._clients
+
 
 # ---------------------------------------------------------------------------
 # _find_port
diff --git a/uv.lock b/uv.lock
index ad560f59..68a7a6c7 100644
--- a/uv.lock
+++ b/uv.lock
@@ -163,7 +163,7 @@ wheels = [
 
 [[package]]
 name = "anthropic"
-version = "0.83.0"
+version = "0.84.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "anyio" },
@@ -175,9 +175,9 @@ dependencies = [
     { name = "sniffio" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/db/e5/02cd2919ec327b24234abb73082e6ab84c451182cc3cc60681af700f4c63/anthropic-0.83.0.tar.gz", hash = "sha256:a8732c68b41869266c3034541a31a29d8be0f8cd0a714f9edce3128b351eceb4", size = 534058, upload-time = "2026-02-19T19:26:38.904Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/04/ea/0869d6df9ef83dcf393aeefc12dd81677d091c6ffc86f783e51cf44062f2/anthropic-0.84.0.tar.gz", hash = "sha256:72f5f90e5aebe62dca316cb013629cfa24996b0f5a4593b8c3d712bc03c43c37", size = 539457, upload-time = "2026-02-25T05:22:38.54Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/5f/75/b9d58e4e2a4b1fc3e75ffbab978f999baf8b7c4ba9f96e60edb918ba386b/anthropic-0.83.0-py3-none-any.whl", hash = "sha256:f069ef508c73b8f9152e8850830d92bd5ef185645dbacf234bb213344a274810", size = 456991, upload-time = "2026-02-19T19:26:40.114Z" },
+    { url = "https://files.pythonhosted.org/packages/64/ca/218fa25002a332c0aa149ba18ffc0543175998b1f65de63f6d106689a345/anthropic-0.84.0-py3-none-any.whl", hash = "sha256:861c4c50f91ca45f942e091d83b60530ad6d4f98733bfe648065364da05d29e7", size = 455156, upload-time = "2026-02-25T05:22:40.468Z" },
 ]
 
 [[package]]
@@ -256,11 +256,11 @@ wheels = [
 
 [[package]]
 name = "certifi"
-version = "2026.1.4"
+version = "2026.2.25"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/e0/2d/a891ca51311197f6ad14a7ef42e2399f36cf2f9bd44752b3dc4eab60fdc5/certifi-2026.1.4.tar.gz", hash = "sha256:ac726dd470482006e014ad384921ed6438c457018f4b3d204aea4281258b2120", size = 154268, upload-time = "2026-01-04T02:42:41.825Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/af/2d/7bf41579a8986e348fa033a31cdd0e4121114f6bce2457e8876010b092dd/certifi-2026.2.25.tar.gz", hash = "sha256:e887ab5cee78ea814d3472169153c2d12cd43b14bd03329a39a9c6e2e80bfba7", size = 155029, upload-time = "2026-02-25T02:54:17.342Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/e6/ad/3cc14f097111b4de0040c83a525973216457bbeeb63739ef1ed275c1c021/certifi-2026.1.4-py3-none-any.whl", hash = "sha256:9943707519e4add1115f44c2bc244f782c0249876bf51b6599fee1ffbedd685c", size = 152900, upload-time = "2026-01-04T02:42:40.15Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/3c/c17fb3ca2d9c3acff52e30b309f538586f9f5b9c9cf454f3845fc9af4881/certifi-2026.2.25-py3-none-any.whl", hash = "sha256:027692e4402ad994f1c42e52a4997a9763c646b73e4096e4d5d6db8af1d6f0fa", size = 153684, upload-time = "2026-02-25T02:54:15.766Z" },
 ]
 
 [[package]]
@@ -980,10 +980,9 @@ requests = [
 
 [[package]]
 name = "google-genai"
-version = "1.64.0"
+version = "1.65.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "aiohttp" },
     { name = "anyio" },
     { name = "distro" },
     { name = "google-auth", extra = ["requests"] },
@@ -995,9 +994,9 @@ dependencies = [
     { name = "typing-extensions" },
     { name = "websockets" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/bc/14/344b450d4387845fc5c8b7f168ffbe734b831b729ece3333fc0fe8556f04/google_genai-1.64.0.tar.gz", hash = "sha256:8db94ab031f745d08c45c69674d1892f7447c74ed21542abe599f7888e28b924", size = 496434, upload-time = "2026-02-19T02:06:13.95Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/79/f9/cc1191c2540d6a4e24609a586c4ed45d2db57cfef47931c139ee70e5874a/google_genai-1.65.0.tar.gz", hash = "sha256:d470eb600af802d58a79c7f13342d9ea0d05d965007cae8f76c7adff3d7a4750", size = 497206, upload-time = "2026-02-26T00:20:33.824Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/54/56/765eca90c781fedbe2a7e7dc873ef6045048e28ba5f2d4a5bcb13e13062b/google_genai-1.64.0-py3-none-any.whl", hash = "sha256:78a4d2deeb33b15ad78eaa419f6f431755e7f0e03771254f8000d70f717e940b", size = 728836, upload-time = "2026-02-19T02:06:11.655Z" },
+    { url = "https://files.pythonhosted.org/packages/68/3c/3fea4e7c91357c71782d7dcaad7a2577d636c90317e003386893c25bc62c/google_genai-1.65.0-py3-none-any.whl", hash = "sha256:68c025205856919bc03edb0155c11b4b833810b7ce17ad4b7a9eeba5158f6c44", size = 724429, upload-time = "2026-02-26T00:20:32.186Z" },
 ]
 
 [[package]]
@@ -1040,31 +1039,34 @@ wheels = [
 
 [[package]]
 name = "hf-xet"
-version = "1.2.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/5e/6e/0f11bacf08a67f7fb5ee09740f2ca54163863b07b70d579356e9222ce5d8/hf_xet-1.2.0.tar.gz", hash = "sha256:a8c27070ca547293b6890c4bf389f713f80e8c478631432962bb7f4bc0bd7d7f", size = 506020, upload-time = "2025-10-24T19:04:32.129Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/9e/a5/85ef910a0aa034a2abcfadc360ab5ac6f6bc4e9112349bd40ca97551cff0/hf_xet-1.2.0-cp313-cp313t-macosx_10_12_x86_64.whl", hash = "sha256:ceeefcd1b7aed4956ae8499e2199607765fbd1c60510752003b6cc0b8413b649", size = 2861870, upload-time = "2025-10-24T19:04:11.422Z" },
-    { url = "https://files.pythonhosted.org/packages/ea/40/e2e0a7eb9a51fe8828ba2d47fe22a7e74914ea8a0db68a18c3aa7449c767/hf_xet-1.2.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:b70218dd548e9840224df5638fdc94bd033552963cfa97f9170829381179c813", size = 2717584, upload-time = "2025-10-24T19:04:09.586Z" },
-    { url = "https://files.pythonhosted.org/packages/a5/7d/daf7f8bc4594fdd59a8a596f9e3886133fdc68e675292218a5e4c1b7e834/hf_xet-1.2.0-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7d40b18769bb9a8bc82a9ede575ce1a44c75eb80e7375a01d76259089529b5dc", size = 3315004, upload-time = "2025-10-24T19:04:00.314Z" },
-    { url = "https://files.pythonhosted.org/packages/b1/ba/45ea2f605fbf6d81c8b21e4d970b168b18a53515923010c312c06cd83164/hf_xet-1.2.0-cp313-cp313t-manylinux_2_28_aarch64.whl", hash = "sha256:cd3a6027d59cfb60177c12d6424e31f4b5ff13d8e3a1247b3a584bf8977e6df5", size = 3222636, upload-time = "2025-10-24T19:03:58.111Z" },
-    { url = "https://files.pythonhosted.org/packages/4a/1d/04513e3cab8f29ab8c109d309ddd21a2705afab9d52f2ba1151e0c14f086/hf_xet-1.2.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:6de1fc44f58f6dd937956c8d304d8c2dea264c80680bcfa61ca4a15e7b76780f", size = 3408448, upload-time = "2025-10-24T19:04:20.951Z" },
-    { url = "https://files.pythonhosted.org/packages/f0/7c/60a2756d7feec7387db3a1176c632357632fbe7849fce576c5559d4520c7/hf_xet-1.2.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:f182f264ed2acd566c514e45da9f2119110e48a87a327ca271027904c70c5832", size = 3503401, upload-time = "2025-10-24T19:04:22.549Z" },
-    { url = "https://files.pythonhosted.org/packages/4e/64/48fffbd67fb418ab07451e4ce641a70de1c40c10a13e25325e24858ebe5a/hf_xet-1.2.0-cp313-cp313t-win_amd64.whl", hash = "sha256:293a7a3787e5c95d7be1857358a9130694a9c6021de3f27fa233f37267174382", size = 2900866, upload-time = "2025-10-24T19:04:33.461Z" },
-    { url = "https://files.pythonhosted.org/packages/e2/51/f7e2caae42f80af886db414d4e9885fac959330509089f97cccb339c6b87/hf_xet-1.2.0-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:10bfab528b968c70e062607f663e21e34e2bba349e8038db546646875495179e", size = 2861861, upload-time = "2025-10-24T19:04:19.01Z" },
-    { url = "https://files.pythonhosted.org/packages/6e/1d/a641a88b69994f9371bd347f1dd35e5d1e2e2460a2e350c8d5165fc62005/hf_xet-1.2.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:2a212e842647b02eb6a911187dc878e79c4aa0aa397e88dd3b26761676e8c1f8", size = 2717699, upload-time = "2025-10-24T19:04:17.306Z" },
-    { url = "https://files.pythonhosted.org/packages/df/e0/e5e9bba7d15f0318955f7ec3f4af13f92e773fbb368c0b8008a5acbcb12f/hf_xet-1.2.0-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:30e06daccb3a7d4c065f34fc26c14c74f4653069bb2b194e7f18f17cbe9939c0", size = 3314885, upload-time = "2025-10-24T19:04:07.642Z" },
-    { url = "https://files.pythonhosted.org/packages/21/90/b7fe5ff6f2b7b8cbdf1bd56145f863c90a5807d9758a549bf3d916aa4dec/hf_xet-1.2.0-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:29c8fc913a529ec0a91867ce3d119ac1aac966e098cf49501800c870328cc090", size = 3221550, upload-time = "2025-10-24T19:04:05.55Z" },
-    { url = "https://files.pythonhosted.org/packages/6f/cb/73f276f0a7ce46cc6a6ec7d6c7d61cbfe5f2e107123d9bbd0193c355f106/hf_xet-1.2.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:66e159cbfcfbb29f920db2c09ed8b660eb894640d284f102ada929b6e3dc410a", size = 3408010, upload-time = "2025-10-24T19:04:28.598Z" },
-    { url = "https://files.pythonhosted.org/packages/b8/1e/d642a12caa78171f4be64f7cd9c40e3ca5279d055d0873188a58c0f5fbb9/hf_xet-1.2.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:9c91d5ae931510107f148874e9e2de8a16052b6f1b3ca3c1b12f15ccb491390f", size = 3503264, upload-time = "2025-10-24T19:04:30.397Z" },
-    { url = "https://files.pythonhosted.org/packages/17/b5/33764714923fa1ff922770f7ed18c2daae034d21ae6e10dbf4347c854154/hf_xet-1.2.0-cp314-cp314t-win_amd64.whl", hash = "sha256:210d577732b519ac6ede149d2f2f34049d44e8622bf14eb3d63bbcd2d4b332dc", size = 2901071, upload-time = "2025-10-24T19:04:37.463Z" },
-    { url = "https://files.pythonhosted.org/packages/96/2d/22338486473df5923a9ab7107d375dbef9173c338ebef5098ef593d2b560/hf_xet-1.2.0-cp37-abi3-macosx_10_12_x86_64.whl", hash = "sha256:46740d4ac024a7ca9b22bebf77460ff43332868b661186a8e46c227fdae01848", size = 2866099, upload-time = "2025-10-24T19:04:15.366Z" },
-    { url = "https://files.pythonhosted.org/packages/7f/8c/c5becfa53234299bc2210ba314eaaae36c2875e0045809b82e40a9544f0c/hf_xet-1.2.0-cp37-abi3-macosx_11_0_arm64.whl", hash = "sha256:27df617a076420d8845bea087f59303da8be17ed7ec0cd7ee3b9b9f579dff0e4", size = 2722178, upload-time = "2025-10-24T19:04:13.695Z" },
-    { url = "https://files.pythonhosted.org/packages/9a/92/cf3ab0b652b082e66876d08da57fcc6fa2f0e6c70dfbbafbd470bb73eb47/hf_xet-1.2.0-cp37-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3651fd5bfe0281951b988c0facbe726aa5e347b103a675f49a3fa8144c7968fd", size = 3320214, upload-time = "2025-10-24T19:04:03.596Z" },
-    { url = "https://files.pythonhosted.org/packages/46/92/3f7ec4a1b6a65bf45b059b6d4a5d38988f63e193056de2f420137e3c3244/hf_xet-1.2.0-cp37-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:d06fa97c8562fb3ee7a378dd9b51e343bc5bc8190254202c9771029152f5e08c", size = 3229054, upload-time = "2025-10-24T19:04:01.949Z" },
-    { url = "https://files.pythonhosted.org/packages/0b/dd/7ac658d54b9fb7999a0ccb07ad863b413cbaf5cf172f48ebcd9497ec7263/hf_xet-1.2.0-cp37-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:4c1428c9ae73ec0939410ec73023c4f842927f39db09b063b9482dac5a3bb737", size = 3413812, upload-time = "2025-10-24T19:04:24.585Z" },
-    { url = "https://files.pythonhosted.org/packages/92/68/89ac4e5b12a9ff6286a12174c8538a5930e2ed662091dd2572bbe0a18c8a/hf_xet-1.2.0-cp37-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:a55558084c16b09b5ed32ab9ed38421e2d87cf3f1f89815764d1177081b99865", size = 3508920, upload-time = "2025-10-24T19:04:26.927Z" },
-    { url = "https://files.pythonhosted.org/packages/cb/44/870d44b30e1dcfb6a65932e3e1506c103a8a5aea9103c337e7a53180322c/hf_xet-1.2.0-cp37-abi3-win_amd64.whl", hash = "sha256:e6584a52253f72c9f52f9e549d5895ca7a471608495c4ecaa6cc73dba2b24d69", size = 2905735, upload-time = "2025-10-24T19:04:35.928Z" },
+version = "1.3.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/8b/cb/9bb543bd987ffa1ee48202cc96a756951b734b79a542335c566148ade36c/hf_xet-1.3.2.tar.gz", hash = "sha256:e130ee08984783d12717444e538587fa2119385e5bd8fc2bb9f930419b73a7af", size = 643646, upload-time = "2026-02-27T17:26:08.051Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/49/75/462285971954269432aad2e7938c5c7ff9ec7d60129cec542ab37121e3d6/hf_xet-1.3.2-cp313-cp313t-macosx_10_12_x86_64.whl", hash = "sha256:335a8f36c55fd35a92d0062f4e9201b4015057e62747b7e7001ffb203c0ee1d2", size = 3761019, upload-time = "2026-02-27T17:25:49.441Z" },
+    { url = "https://files.pythonhosted.org/packages/35/56/987b0537ddaf88e17192ea09afa8eca853e55f39a4721578be436f8409df/hf_xet-1.3.2-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:c1ae4d3a716afc774e66922f3cac8206bfa707db13f6a7e62dfff74bfc95c9a8", size = 3521565, upload-time = "2026-02-27T17:25:47.469Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/5c/7e4a33a3d689f77761156cc34558047569e54af92e4d15a8f493229f6767/hf_xet-1.3.2-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:d6dbdf231efac0b9b39adcf12a07f0c030498f9212a18e8c50224d0e84ab803d", size = 4176494, upload-time = "2026-02-27T17:25:40.247Z" },
+    { url = "https://files.pythonhosted.org/packages/6b/b3/71e856bf9d9a69b3931837e8bf22e095775f268c8edcd4a9e8c355f92484/hf_xet-1.3.2-cp313-cp313t-manylinux_2_28_aarch64.whl", hash = "sha256:c1980abfb68ecf6c1c7983379ed7b1e2b49a1aaf1a5aca9acc7d48e5e2e0a961", size = 3955601, upload-time = "2026-02-27T17:25:38.376Z" },
+    { url = "https://files.pythonhosted.org/packages/63/d7/aecf97b3f0a981600a67ff4db15e2d433389d698a284bb0ea5d8fcdd6f7f/hf_xet-1.3.2-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:1c88fbd90ad0d27c46b77a445f0a436ebaa94e14965c581123b68b1c52f5fd30", size = 4154770, upload-time = "2026-02-27T17:25:56.756Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/e1/3af961f71a40e09bf5ee909842127b6b00f5ab4ee3817599dc0771b79893/hf_xet-1.3.2-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:35b855024ca37f2dd113ac1c08993e997fbe167b9d61f9ef66d3d4f84015e508", size = 4394161, upload-time = "2026-02-27T17:25:58.111Z" },
+    { url = "https://files.pythonhosted.org/packages/a1/c3/859509bade9178e21b8b1db867b8e10e9f817ab9ac1de77cb9f461ced765/hf_xet-1.3.2-cp313-cp313t-win_amd64.whl", hash = "sha256:31612ba0629046e425ba50375685a2586e11fb9144270ebabd75878c3eaf6378", size = 3637377, upload-time = "2026-02-27T17:26:10.611Z" },
+    { url = "https://files.pythonhosted.org/packages/05/7f/724cfbef4da92d577b71f68bf832961c8919f36c60d28d289a9fc9d024d4/hf_xet-1.3.2-cp313-cp313t-win_arm64.whl", hash = "sha256:433c77c9f4e132b562f37d66c9b22c05b5479f243a1f06a120c1c06ce8b1502a", size = 3497875, upload-time = "2026-02-27T17:26:09.034Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/75/9d54c1ae1d05fb704f977eca1671747babf1957f19f38ae75c5933bc2dc1/hf_xet-1.3.2-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:c34e2c7aefad15792d57067c1c89b2b02c1bbaeabd7f8456ae3d07b4bbaf4094", size = 3761076, upload-time = "2026-02-27T17:25:55.42Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/8a/08a24b6c6f52b5d26848c16e4b6d790bb810d1bf62c3505bed179f7032d3/hf_xet-1.3.2-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:4bc995d6c41992831f762096020dc14a65fdf3963f86ffed580b596d04de32e3", size = 3521745, upload-time = "2026-02-27T17:25:54.217Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/db/a75cf400dd8a1a8acf226a12955ff6ee999f272dfc0505bafd8079a61267/hf_xet-1.3.2-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:959083c89dee30f7d6f890b36cdadda823386c4de63b1a30384a75bfd2ae995d", size = 4176301, upload-time = "2026-02-27T17:25:46.044Z" },
+    { url = "https://files.pythonhosted.org/packages/01/40/6c4c798ffdd83e740dd3925c4e47793b07442a9efa3bc3866ba141a82365/hf_xet-1.3.2-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:cfa760888633b08c01b398d212ce7e8c0d7adac6c86e4b20dfb2397d8acd78ee", size = 3955437, upload-time = "2026-02-27T17:25:44.703Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/09/9a3aa7c5f07d3e5cc57bb750d12a124ffa72c273a87164bd848f9ac5cc14/hf_xet-1.3.2-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:3155a02e083aa21fd733a7485c7c36025e49d5975c8d6bda0453d224dd0b0ac4", size = 4154535, upload-time = "2026-02-27T17:26:05.207Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/e0/831f7fa6d90cb47a230bc23284b502c700e1483bbe459437b3844cdc0776/hf_xet-1.3.2-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:91b1dc03c31cbf733d35dc03df7c5353686233d86af045e716f1e0ea4a2673cf", size = 4393891, upload-time = "2026-02-27T17:26:06.607Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/96/6ed472fdce7f8b70f5da6e3f05be76816a610063003bfd6d9cea0bbb58a3/hf_xet-1.3.2-cp314-cp314t-win_amd64.whl", hash = "sha256:211f30098512d95e85ad03ae63bd7dd2c4df476558a5095d09f9e38e78cbf674", size = 3637583, upload-time = "2026-02-27T17:26:17.349Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/e8/a069edc4570b3f8e123c0b80fadc94530f3d7b01394e1fc1bb223339366c/hf_xet-1.3.2-cp314-cp314t-win_arm64.whl", hash = "sha256:4a6817c41de7c48ed9270da0b02849347e089c5ece9a0e72ae4f4b3a57617f82", size = 3497977, upload-time = "2026-02-27T17:26:14.966Z" },
+    { url = "https://files.pythonhosted.org/packages/d8/28/dbb024e2e3907f6f3052847ca7d1a2f7a3972fafcd53ff79018977fcb3e4/hf_xet-1.3.2-cp37-abi3-macosx_10_12_x86_64.whl", hash = "sha256:f93b7595f1d8fefddfede775c18b5c9256757824f7f6832930b49858483cd56f", size = 3763961, upload-time = "2026-02-27T17:25:52.537Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/71/b99aed3823c9d1795e4865cf437d651097356a3f38c7d5877e4ac544b8e4/hf_xet-1.3.2-cp37-abi3-macosx_11_0_arm64.whl", hash = "sha256:a85d3d43743174393afe27835bde0cd146e652b5fcfdbcd624602daef2ef3259", size = 3526171, upload-time = "2026-02-27T17:25:50.968Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/ca/907890ce6ef5598b5920514f255ed0a65f558f820515b18db75a51b2f878/hf_xet-1.3.2-cp37-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:7c2a054a97c44e136b1f7f5a78f12b3efffdf2eed3abc6746fc5ea4b39511633", size = 4180750, upload-time = "2026-02-27T17:25:43.125Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/ad/bc7f41f87173d51d0bce497b171c4ee0cbde1eed2d7b4216db5d0ada9f50/hf_xet-1.3.2-cp37-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:06b724a361f670ae557836e57801b82c75b534812e351a87a2c739f77d1e0635", size = 3961035, upload-time = "2026-02-27T17:25:41.837Z" },
+    { url = "https://files.pythonhosted.org/packages/73/38/600f4dda40c4a33133404d9fe644f1d35ff2d9babb4d0435c646c63dd107/hf_xet-1.3.2-cp37-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:305f5489d7241a47e0458ef49334be02411d1d0f480846363c1c8084ed9916f7", size = 4161378, upload-time = "2026-02-27T17:26:00.365Z" },
+    { url = "https://files.pythonhosted.org/packages/00/b3/7bc1ff91d1ac18420b7ad1e169b618b27c00001b96310a89f8a9294fe509/hf_xet-1.3.2-cp37-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:06cdbde243c85f39a63b28e9034321399c507bcd5e7befdd17ed2ccc06dfe14e", size = 4398020, upload-time = "2026-02-27T17:26:03.977Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/0b/99bfd948a3ed3620ab709276df3ad3710dcea61976918cce8706502927af/hf_xet-1.3.2-cp37-abi3-win_amd64.whl", hash = "sha256:9298b47cce6037b7045ae41482e703c471ce36b52e73e49f71226d2e8e5685a1", size = 3641624, upload-time = "2026-02-27T17:26:13.542Z" },
+    { url = "https://files.pythonhosted.org/packages/cc/02/9a6e4ca1f3f73a164c0cd48e41b3cc56585dcc37e809250de443d673266f/hf_xet-1.3.2-cp37-abi3-win_arm64.whl", hash = "sha256:83d8ec273136171431833a6957e8f3af496bee227a0fe47c7b8b39c106d1749a", size = 3503976, upload-time = "2026-02-27T17:26:12.123Z" },
 ]
 
 [[package]]
@@ -1097,7 +1099,7 @@ wheels = [
 
 [[package]]
 name = "huggingface-hub"
-version = "1.4.1"
+version = "1.5.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "filelock" },
@@ -1106,14 +1108,13 @@ dependencies = [
     { name = "httpx" },
     { name = "packaging" },
     { name = "pyyaml" },
-    { name = "shellingham" },
     { name = "tqdm" },
-    { name = "typer-slim" },
+    { name = "typer" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/c4/fc/eb9bc06130e8bbda6a616e1b80a7aa127681c448d6b49806f61db2670b61/huggingface_hub-1.4.1.tar.gz", hash = "sha256:b41131ec35e631e7383ab26d6146b8d8972abc8b6309b963b306fbcca87f5ed5", size = 642156, upload-time = "2026-02-06T09:20:03.013Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/ae/76/b5efb3033d8499b17f9386beaf60f64c461798e1ee16d10bc9c0077beba5/huggingface_hub-1.5.0.tar.gz", hash = "sha256:f281838db29265880fb543de7a23b0f81d3504675de82044307ea3c6c62f799d", size = 695872, upload-time = "2026-02-26T15:35:32.745Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/d5/ae/2f6d96b4e6c5478d87d606a1934b5d436c4a2bce6bb7c6fdece891c128e3/huggingface_hub-1.4.1-py3-none-any.whl", hash = "sha256:9931d075fb7a79af5abc487106414ec5fba2c0ae86104c0c62fd6cae38873d18", size = 553326, upload-time = "2026-02-06T09:20:00.728Z" },
+    { url = "https://files.pythonhosted.org/packages/ec/74/2bc951622e2dbba1af9a460d93c51d15e458becd486e62c29cc0ccb08178/huggingface_hub-1.5.0-py3-none-any.whl", hash = "sha256:c9c0b3ab95a777fc91666111f3b3ede71c0cdced3614c553a64e98920585c4ee", size = 596261, upload-time = "2026-02-26T15:35:31.1Z" },
 ]
 
 [[package]]
@@ -1162,7 +1163,7 @@ sdist = { url = "https://files.pythonhosted.org/packages/f3/ff/c9baf0997266d398a
 
 [[package]]
 name = "ibm-watsonx-ai"
-version = "1.5.2"
+version = "1.5.3"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "cachetools" },
@@ -1176,9 +1177,9 @@ dependencies = [
     { name = "tabulate" },
     { name = "urllib3" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/bb/d7/5a4250bc0b4bde2aa9fb44289cd869c8b7df229759098d435ab169bc9eb9/ibm_watsonx_ai-1.5.2.tar.gz", hash = "sha256:c85ccf4eb79a03c8cc27ff891c24c3a9aebcc0da5887baa64bc9bb67d83aaf54", size = 710281, upload-time = "2026-02-12T08:20:37.855Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/50/a0/19e0bfefe4fe3409bb73821198a24eac931f12f8c2ea2eb05c98995dffaa/ibm_watsonx_ai-1.5.3.tar.gz", hash = "sha256:610c982416e18479e2029d16062e992d42a5454b6db5ed68541aa53b8f3bfa54", size = 710736, upload-time = "2026-02-26T09:18:03.628Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/d2/18/06dd0320590189c77283315da5368a361cef6b9807f6e44b9a59773139e9/ibm_watsonx_ai-1.5.2-py3-none-any.whl", hash = "sha256:0b9e80128a726788412ca50d63461dcea22ac23caf2057b8a6e32a0c376da18d", size = 1079661, upload-time = "2026-02-12T08:20:36.223Z" },
+    { url = "https://files.pythonhosted.org/packages/99/89/f6a113d08bd8796c8ed82b151009479fe7e8a7b4792a12c98918b806c0e6/ibm_watsonx_ai-1.5.3-py3-none-any.whl", hash = "sha256:a7a1af3bebd8271e0fb7a04b17792131ad7f3e697cd4aea0aae0687695cb884f", size = 1080316, upload-time = "2026-02-26T09:18:01.778Z" },
 ]
 
 [[package]]
@@ -1537,14 +1538,14 @@ html-clean = [
 
 [[package]]
 name = "lxml-html-clean"
-version = "0.4.3"
+version = "0.4.4"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "lxml" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/d9/cb/c9c5bb2a9c47292e236a808dd233a03531f53b626f36259dcd32b49c76da/lxml_html_clean-0.4.3.tar.gz", hash = "sha256:c9df91925b00f836c807beab127aac82575110eacff54d0a75187914f1bd9d8c", size = 21498, upload-time = "2025-10-02T20:49:24.895Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/9a/a4/5c62acfacd69ff4f5db395100f5cfb9b54e7ac8c69a235e4e939fd13f021/lxml_html_clean-0.4.4.tar.gz", hash = "sha256:58f39a9d632711202ed1d6d0b9b47a904e306c85de5761543b90e3e3f736acfb", size = 23899, upload-time = "2026-02-27T09:35:52.911Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/10/4a/63a9540e3ca73709f4200564a737d63a4c8c9c4dd032bab8535f507c190a/lxml_html_clean-0.4.3-py3-none-any.whl", hash = "sha256:63fd7b0b9c3a2e4176611c2ca5d61c4c07ffca2de76c14059a81a2825833731e", size = 14177, upload-time = "2025-10-02T20:49:23.749Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/76/7ffc1d3005cf7749123bc47cb3ea343cd97b0ac2211bab40f57283577d0e/lxml_html_clean-0.4.4-py3-none-any.whl", hash = "sha256:ce2ef506614ecb85ee1c5fe0a2aa45b06a19514ec7949e9c8f34f06925cfabcb", size = 14565, upload-time = "2026-02-27T09:35:51.86Z" },
 ]
 
 [[package]]
@@ -1635,7 +1636,7 @@ wheels = [
 
 [[package]]
 name = "mcp-cli"
-version = "0.16"
+version = "0.17"
 source = { editable = "." }
 dependencies = [
     { name = "asyncio" },
@@ -1969,7 +1970,7 @@ wheels = [
 
 [[package]]
 name = "openai"
-version = "2.21.0"
+version = "2.24.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "anyio" },
@@ -1981,9 +1982,9 @@ dependencies = [
     { name = "tqdm" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/92/e5/3d197a0947a166649f566706d7a4c8f7fe38f1fa7b24c9bcffe4c7591d44/openai-2.21.0.tar.gz", hash = "sha256:81b48ce4b8bbb2cc3af02047ceb19561f7b1dc0d4e52d1de7f02abfd15aa59b7", size = 644374, upload-time = "2026-02-14T00:12:01.577Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/55/13/17e87641b89b74552ed408a92b231283786523edddc95f3545809fab673c/openai-2.24.0.tar.gz", hash = "sha256:1e5769f540dbd01cb33bc4716a23e67b9d695161a734aff9c5f925e2bf99a673", size = 658717, upload-time = "2026-02-24T20:02:07.958Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/cc/56/0a89092a453bb2c676d66abee44f863e742b2110d4dbb1dbcca3f7e5fc33/openai-2.21.0-py3-none-any.whl", hash = "sha256:0bc1c775e5b1536c294eded39ee08f8407656537ccc71b1004104fe1602e267c", size = 1103065, upload-time = "2026-02-14T00:11:59.603Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/30/844dc675ee6902579b8eef01ed23917cc9319a1c9c0c14ec6e39340c96d0/openai-2.24.0-py3-none-any.whl", hash = "sha256:fed30480d7d6c884303287bde864980a4b137b60553ffbcf9ab4a233b7a73d94", size = 1120122, upload-time = "2026-02-24T20:02:05.669Z" },
 ]
 
 [[package]]
@@ -2680,106 +2681,106 @@ wheels = [
 
 [[package]]
 name = "regex"
-version = "2026.2.19"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/ff/c0/d8079d4f6342e4cec5c3e7d7415b5cd3e633d5f4124f7a4626908dbe84c7/regex-2026.2.19.tar.gz", hash = "sha256:6fb8cb09b10e38f3ae17cc6dc04a1df77762bd0351b6ba9041438e7cc85ec310", size = 414973, upload-time = "2026-02-19T19:03:47.899Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/6f/93/43f405a98f54cc59c786efb4fc0b644615ed2392fc89d57d30da11f35b5b/regex-2026.2.19-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:93b16a18cadb938f0f2306267161d57eb33081a861cee9ffcd71e60941eb5dfc", size = 488365, upload-time = "2026-02-19T19:00:17.857Z" },
-    { url = "https://files.pythonhosted.org/packages/66/46/da0efce22cd8f5ae28eeb25ac69703f49edcad3331ac22440776f4ea0867/regex-2026.2.19-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:78af1e499cab704131f6f4e2f155b7f54ce396ca2acb6ef21a49507e4752e0be", size = 290737, upload-time = "2026-02-19T19:00:19.869Z" },
-    { url = "https://files.pythonhosted.org/packages/fb/19/f735078448132c1c974974d30d5306337bc297fe6b6f126164bff72c1019/regex-2026.2.19-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:eb20c11aa4c3793c9ad04c19a972078cdadb261b8429380364be28e867a843f2", size = 288654, upload-time = "2026-02-19T19:00:21.307Z" },
-    { url = "https://files.pythonhosted.org/packages/e2/3e/6d7c24a2f423c03ad03e3fbddefa431057186ac1c4cb4fa98b03c7f39808/regex-2026.2.19-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:db5fd91eec71e7b08de10011a2223d0faa20448d4e1380b9daa179fa7bf58906", size = 793785, upload-time = "2026-02-19T19:00:22.926Z" },
-    { url = "https://files.pythonhosted.org/packages/67/32/fdb8107504b3122a79bde6705ac1f9d495ed1fe35b87d7cfc1864471999a/regex-2026.2.19-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:fdbade8acba71bb45057c2b72f477f0b527c4895f9c83e6cfc30d4a006c21726", size = 860731, upload-time = "2026-02-19T19:00:25.196Z" },
-    { url = "https://files.pythonhosted.org/packages/9a/fd/cc8c6f05868defd840be6e75919b1c3f462357969ac2c2a0958363b4dc23/regex-2026.2.19-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:31a5f561eb111d6aae14202e7043fb0b406d3c8dddbbb9e60851725c9b38ab1d", size = 907350, upload-time = "2026-02-19T19:00:27.093Z" },
-    { url = "https://files.pythonhosted.org/packages/b5/1b/4590db9caa8db3d5a3fe31197c4e42c15aab3643b549ef6a454525fa3a61/regex-2026.2.19-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4584a3ee5f257b71e4b693cc9be3a5104249399f4116fe518c3f79b0c6fc7083", size = 800628, upload-time = "2026-02-19T19:00:29.392Z" },
-    { url = "https://files.pythonhosted.org/packages/76/05/513eaa5b96fa579fd0b813e19ec047baaaf573d7374ff010fa139b384bf7/regex-2026.2.19-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:196553ba2a2f47904e5dc272d948a746352e2644005627467e055be19d73b39e", size = 773711, upload-time = "2026-02-19T19:00:30.996Z" },
-    { url = "https://files.pythonhosted.org/packages/95/65/5aed06d8c54563d37fea496cf888be504879a3981a7c8e12c24b2c92c209/regex-2026.2.19-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:0c10869d18abb759a3317c757746cc913d6324ce128b8bcec99350df10419f18", size = 783186, upload-time = "2026-02-19T19:00:34.598Z" },
-    { url = "https://files.pythonhosted.org/packages/2c/57/79a633ad90f2371b4ef9cd72ba3a69a1a67d0cfaab4fe6fa8586d46044ef/regex-2026.2.19-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:e689fed279cbe797a6b570bd18ff535b284d057202692c73420cb93cca41aa32", size = 854854, upload-time = "2026-02-19T19:00:37.306Z" },
-    { url = "https://files.pythonhosted.org/packages/eb/2d/0f113d477d9e91ec4545ec36c82e58be25038d06788229c91ad52da2b7f5/regex-2026.2.19-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:0782bd983f19ac7594039c9277cd6f75c89598c1d72f417e4d30d874105eb0c7", size = 762279, upload-time = "2026-02-19T19:00:39.793Z" },
-    { url = "https://files.pythonhosted.org/packages/39/cb/237e9fa4f61469fd4f037164dbe8e675a376c88cf73aaaa0aedfd305601c/regex-2026.2.19-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:dbb240c81cfed5d4a67cb86d7676d9f7ec9c3f186310bec37d8a1415210e111e", size = 846172, upload-time = "2026-02-19T19:00:42.134Z" },
-    { url = "https://files.pythonhosted.org/packages/ac/7c/104779c5915cc4eb557a33590f8a3f68089269c64287dd769afd76c7ce61/regex-2026.2.19-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:80d31c3f1fe7e4c6cd1831cd4478a0609903044dfcdc4660abfe6fb307add7f0", size = 789078, upload-time = "2026-02-19T19:00:43.908Z" },
-    { url = "https://files.pythonhosted.org/packages/a8/4a/eae4e88b1317fb2ff57794915e0099198f51e760f6280b320adfa0ad396d/regex-2026.2.19-cp311-cp311-win32.whl", hash = "sha256:66e6a43225ff1064f8926adbafe0922b370d381c3330edaf9891cade52daa790", size = 266013, upload-time = "2026-02-19T19:00:47.274Z" },
-    { url = "https://files.pythonhosted.org/packages/f9/29/ba89eb8fae79705e07ad1bd69e568f776159d2a8093c9dbc5303ee618298/regex-2026.2.19-cp311-cp311-win_amd64.whl", hash = "sha256:59a7a5216485a1896c5800e9feb8ff9213e11967b482633b6195d7da11450013", size = 277906, upload-time = "2026-02-19T19:00:49.011Z" },
-    { url = "https://files.pythonhosted.org/packages/e3/1a/042d8f04b28e318df92df69d8becb0f42221eb3dd4fe5e976522f4337c76/regex-2026.2.19-cp311-cp311-win_arm64.whl", hash = "sha256:ec661807ffc14c8d14bb0b8c1bb3d5906e476bc96f98b565b709d03962ee4dd4", size = 270463, upload-time = "2026-02-19T19:00:50.988Z" },
-    { url = "https://files.pythonhosted.org/packages/b3/73/13b39c7c9356f333e564ab4790b6cb0df125b8e64e8d6474e73da49b1955/regex-2026.2.19-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:c1665138776e4ac1aa75146669236f7a8a696433ec4e525abf092ca9189247cc", size = 489541, upload-time = "2026-02-19T19:00:52.728Z" },
-    { url = "https://files.pythonhosted.org/packages/15/77/fcc7bd9a67000d07fbcc11ed226077287a40d5c84544e62171d29d3ef59c/regex-2026.2.19-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:d792b84709021945597e05656aac059526df4e0c9ef60a0eaebb306f8fafcaa8", size = 291414, upload-time = "2026-02-19T19:00:54.51Z" },
-    { url = "https://files.pythonhosted.org/packages/f9/87/3997fc72dc59233426ef2e18dfdd105bb123812fff740ee9cc348f1a3243/regex-2026.2.19-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:db970bcce4d63b37b3f9eb8c893f0db980bbf1d404a1d8d2b17aa8189de92c53", size = 289140, upload-time = "2026-02-19T19:00:56.841Z" },
-    { url = "https://files.pythonhosted.org/packages/f3/d0/b7dd3883ed1cff8ee0c0c9462d828aaf12be63bf5dc55453cbf423523b13/regex-2026.2.19-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:03d706fbe7dfec503c8c3cb76f9352b3e3b53b623672aa49f18a251a6c71b8e6", size = 798767, upload-time = "2026-02-19T19:00:59.014Z" },
-    { url = "https://files.pythonhosted.org/packages/4a/7e/8e2d09103832891b2b735a2515abf377db21144c6dd5ede1fb03c619bf09/regex-2026.2.19-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:8dbff048c042beef60aa1848961384572c5afb9e8b290b0f1203a5c42cf5af65", size = 864436, upload-time = "2026-02-19T19:01:00.772Z" },
-    { url = "https://files.pythonhosted.org/packages/8a/2e/afea8d23a6db1f67f45e3a0da3057104ce32e154f57dd0c8997274d45fcd/regex-2026.2.19-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:ccaaf9b907ea6b4223d5cbf5fa5dff5f33dc66f4907a25b967b8a81339a6e332", size = 912391, upload-time = "2026-02-19T19:01:02.865Z" },
-    { url = "https://files.pythonhosted.org/packages/59/3c/ea5a4687adaba5e125b9bd6190153d0037325a0ba3757cc1537cc2c8dd90/regex-2026.2.19-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:75472631eee7898e16a8a20998d15106cb31cfde21cdf96ab40b432a7082af06", size = 803702, upload-time = "2026-02-19T19:01:05.298Z" },
-    { url = "https://files.pythonhosted.org/packages/dc/c5/624a0705e8473a26488ec1a3a4e0b8763ecfc682a185c302dfec71daea35/regex-2026.2.19-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:d89f85a5ccc0cec125c24be75610d433d65295827ebaf0d884cbe56df82d4774", size = 775980, upload-time = "2026-02-19T19:01:07.047Z" },
-    { url = "https://files.pythonhosted.org/packages/4d/4b/ed776642533232b5599b7c1f9d817fe11faf597e8a92b7a44b841daaae76/regex-2026.2.19-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:0d9f81806abdca3234c3dd582b8a97492e93de3602c8772013cb4affa12d1668", size = 788122, upload-time = "2026-02-19T19:01:08.744Z" },
-    { url = "https://files.pythonhosted.org/packages/8c/58/e93e093921d13b9784b4f69896b6e2a9e09580a265c59d9eb95e87d288f2/regex-2026.2.19-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:9dadc10d1c2bbb1326e572a226d2ec56474ab8aab26fdb8cf19419b372c349a9", size = 858910, upload-time = "2026-02-19T19:01:10.488Z" },
-    { url = "https://files.pythonhosted.org/packages/85/77/ff1d25a0c56cd546e0455cbc93235beb33474899690e6a361fa6b52d265b/regex-2026.2.19-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:6bc25d7e15f80c9dc7853cbb490b91c1ec7310808b09d56bd278fe03d776f4f6", size = 764153, upload-time = "2026-02-19T19:01:12.156Z" },
-    { url = "https://files.pythonhosted.org/packages/cd/ef/8ec58df26d52d04443b1dc56f9be4b409f43ed5ae6c0248a287f52311fc4/regex-2026.2.19-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:965d59792f5037d9138da6fed50ba943162160443b43d4895b182551805aff9c", size = 850348, upload-time = "2026-02-19T19:01:14.147Z" },
-    { url = "https://files.pythonhosted.org/packages/f5/b3/c42fd5ed91639ce5a4225b9df909180fc95586db071f2bf7c68d2ccbfbe6/regex-2026.2.19-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:38d88c6ed4a09ed61403dbdf515d969ccba34669af3961ceb7311ecd0cef504a", size = 789977, upload-time = "2026-02-19T19:01:15.838Z" },
-    { url = "https://files.pythonhosted.org/packages/b6/22/bc3b58ebddbfd6ca5633e71fd41829ee931963aad1ebeec55aad0c23044e/regex-2026.2.19-cp312-cp312-win32.whl", hash = "sha256:5df947cabab4b643d4791af5e28aecf6bf62e6160e525651a12eba3d03755e6b", size = 266381, upload-time = "2026-02-19T19:01:17.952Z" },
-    { url = "https://files.pythonhosted.org/packages/fc/4a/6ff550b63e67603ee60e69dc6bd2d5694e85046a558f663b2434bdaeb285/regex-2026.2.19-cp312-cp312-win_amd64.whl", hash = "sha256:4146dc576ea99634ae9c15587d0c43273b4023a10702998edf0fa68ccb60237a", size = 277274, upload-time = "2026-02-19T19:01:19.826Z" },
-    { url = "https://files.pythonhosted.org/packages/cc/29/9ec48b679b1e87e7bc8517dff45351eab38f74fbbda1fbcf0e9e6d4e8174/regex-2026.2.19-cp312-cp312-win_arm64.whl", hash = "sha256:cdc0a80f679353bd68450d2a42996090c30b2e15ca90ded6156c31f1a3b63f3b", size = 270509, upload-time = "2026-02-19T19:01:22.075Z" },
-    { url = "https://files.pythonhosted.org/packages/d2/2d/a849835e76ac88fcf9e8784e642d3ea635d183c4112150ca91499d6703af/regex-2026.2.19-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:8df08decd339e8b3f6a2eb5c05c687fe9d963ae91f352bc57beb05f5b2ac6879", size = 489329, upload-time = "2026-02-19T19:01:23.841Z" },
-    { url = "https://files.pythonhosted.org/packages/da/aa/78ff4666d3855490bae87845a5983485e765e1f970da20adffa2937b241d/regex-2026.2.19-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:3aa0944f1dc6e92f91f3b306ba7f851e1009398c84bfd370633182ee4fc26a64", size = 291308, upload-time = "2026-02-19T19:01:25.605Z" },
-    { url = "https://files.pythonhosted.org/packages/cd/58/714384efcc07ae6beba528a541f6e99188c5cc1bc0295337f4e8a868296d/regex-2026.2.19-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:c13228fbecb03eadbfd8f521732c5fda09ef761af02e920a3148e18ad0e09968", size = 289033, upload-time = "2026-02-19T19:01:27.243Z" },
-    { url = "https://files.pythonhosted.org/packages/75/ec/6438a9344d2869cf5265236a06af1ca6d885e5848b6561e10629bc8e5a11/regex-2026.2.19-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0d0e72703c60d68b18b27cde7cdb65ed2570ae29fb37231aa3076bfb6b1d1c13", size = 798798, upload-time = "2026-02-19T19:01:28.877Z" },
-    { url = "https://files.pythonhosted.org/packages/c2/be/b1ce2d395e3fd2ce5f2fde2522f76cade4297cfe84cd61990ff48308749c/regex-2026.2.19-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:46e69a4bf552e30e74a8aa73f473c87efcb7f6e8c8ece60d9fd7bf13d5c86f02", size = 864444, upload-time = "2026-02-19T19:01:30.933Z" },
-    { url = "https://files.pythonhosted.org/packages/d5/97/a3406460c504f7136f140d9461960c25f058b0240e4424d6fb73c7a067ab/regex-2026.2.19-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:8edda06079bd770f7f0cf7f3bba1a0b447b96b4a543c91fe0c142d034c166161", size = 912633, upload-time = "2026-02-19T19:01:32.744Z" },
-    { url = "https://files.pythonhosted.org/packages/8b/d9/e5dbef95008d84e9af1dc0faabbc34a7fbc8daa05bc5807c5cf86c2bec49/regex-2026.2.19-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9cbc69eae834afbf634f7c902fc72ff3e993f1c699156dd1af1adab5d06b7fe7", size = 803718, upload-time = "2026-02-19T19:01:34.61Z" },
-    { url = "https://files.pythonhosted.org/packages/2f/e5/61d80132690a1ef8dc48e0f44248036877aebf94235d43f63a20d1598888/regex-2026.2.19-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:bcf57d30659996ee5c7937999874504c11b5a068edc9515e6a59221cc2744dd1", size = 775975, upload-time = "2026-02-19T19:01:36.525Z" },
-    { url = "https://files.pythonhosted.org/packages/05/32/ae828b3b312c972cf228b634447de27237d593d61505e6ad84723f8eabba/regex-2026.2.19-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:8e6e77cd92216eb489e21e5652a11b186afe9bdefca8a2db739fd6b205a9e0a4", size = 788129, upload-time = "2026-02-19T19:01:38.498Z" },
-    { url = "https://files.pythonhosted.org/packages/cb/25/d74f34676f22bec401eddf0e5e457296941e10cbb2a49a571ca7a2c16e5a/regex-2026.2.19-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:b9ab8dec42afefa6314ea9b31b188259ffdd93f433d77cad454cd0b8d235ce1c", size = 858818, upload-time = "2026-02-19T19:01:40.409Z" },
-    { url = "https://files.pythonhosted.org/packages/1e/eb/0bc2b01a6b0b264e1406e5ef11cae3f634c3bd1a6e61206fd3227ce8e89c/regex-2026.2.19-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:294c0fb2e87c6bcc5f577c8f609210f5700b993151913352ed6c6af42f30f95f", size = 764186, upload-time = "2026-02-19T19:01:43.009Z" },
-    { url = "https://files.pythonhosted.org/packages/eb/37/5fe5a630d0d99ecf0c3570f8905dafbc160443a2d80181607770086c9812/regex-2026.2.19-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:c0924c64b082d4512b923ac016d6e1dcf647a3560b8a4c7e55cbbd13656cb4ed", size = 850363, upload-time = "2026-02-19T19:01:45.015Z" },
-    { url = "https://files.pythonhosted.org/packages/c3/45/ef68d805294b01ec030cfd388724ba76a5a21a67f32af05b17924520cb0b/regex-2026.2.19-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:790dbf87b0361606cb0d79b393c3e8f4436a14ee56568a7463014565d97da02a", size = 790026, upload-time = "2026-02-19T19:01:47.51Z" },
-    { url = "https://files.pythonhosted.org/packages/d6/3a/40d3b66923dfc5aeba182f194f0ca35d09afe8c031a193e6ae46971a0a0e/regex-2026.2.19-cp313-cp313-win32.whl", hash = "sha256:43cdde87006271be6963896ed816733b10967baaf0e271d529c82e93da66675b", size = 266372, upload-time = "2026-02-19T19:01:49.469Z" },
-    { url = "https://files.pythonhosted.org/packages/3d/f2/39082e8739bfd553497689e74f9d5e5bb531d6f8936d0b94f43e18f219c0/regex-2026.2.19-cp313-cp313-win_amd64.whl", hash = "sha256:127ea69273485348a126ebbf3d6052604d3c7da284f797bba781f364c0947d47", size = 277253, upload-time = "2026-02-19T19:01:51.208Z" },
-    { url = "https://files.pythonhosted.org/packages/c2/c2/852b9600d53fb47e47080c203e2cdc0ac7e84e37032a57e0eaa37446033a/regex-2026.2.19-cp313-cp313-win_arm64.whl", hash = "sha256:5e56c669535ac59cbf96ca1ece0ef26cb66809990cda4fa45e1e32c3b146599e", size = 270505, upload-time = "2026-02-19T19:01:52.865Z" },
-    { url = "https://files.pythonhosted.org/packages/a9/a2/e0b4575b93bc84db3b1fab24183e008691cd2db5c0ef14ed52681fbd94dd/regex-2026.2.19-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:93d881cab5afdc41a005dba1524a40947d6f7a525057aa64aaf16065cf62faa9", size = 492202, upload-time = "2026-02-19T19:01:54.816Z" },
-    { url = "https://files.pythonhosted.org/packages/24/b5/b84fec8cbb5f92a7eed2b6b5353a6a9eed9670fee31817c2da9eb85dc797/regex-2026.2.19-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:80caaa1ddcc942ec7be18427354f9d58a79cee82dea2a6b3d4fd83302e1240d7", size = 292884, upload-time = "2026-02-19T19:01:58.254Z" },
-    { url = "https://files.pythonhosted.org/packages/70/0c/fe89966dfae43da46f475362401f03e4d7dc3a3c955b54f632abc52669e0/regex-2026.2.19-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:d793c5b4d2b4c668524cd1651404cfc798d40694c759aec997e196fe9729ec60", size = 291236, upload-time = "2026-02-19T19:01:59.966Z" },
-    { url = "https://files.pythonhosted.org/packages/f2/f7/bda2695134f3e63eb5cccbbf608c2a12aab93d261ff4e2fe49b47fabc948/regex-2026.2.19-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b5100acb20648d9efd3f4e7e91f51187f95f22a741dcd719548a6cf4e1b34b3f", size = 807660, upload-time = "2026-02-19T19:02:01.632Z" },
-    { url = "https://files.pythonhosted.org/packages/11/56/6e3a4bf5e60d17326b7003d91bbde8938e439256dec211d835597a44972d/regex-2026.2.19-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:5e3a31e94d10e52a896adaa3adf3621bd526ad2b45b8c2d23d1bbe74c7423007", size = 873585, upload-time = "2026-02-19T19:02:03.522Z" },
-    { url = "https://files.pythonhosted.org/packages/35/5e/c90c6aa4d1317cc11839359479cfdd2662608f339e84e81ba751c8a4e461/regex-2026.2.19-cp313-cp313t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:8497421099b981f67c99eba4154cf0dfd8e47159431427a11cfb6487f7791d9e", size = 915243, upload-time = "2026-02-19T19:02:05.608Z" },
-    { url = "https://files.pythonhosted.org/packages/90/7c/981ea0694116793001496aaf9524e5c99e122ec3952d9e7f1878af3a6bf1/regex-2026.2.19-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1e7a08622f7d51d7a068f7e4052a38739c412a3e74f55817073d2e2418149619", size = 812922, upload-time = "2026-02-19T19:02:08.115Z" },
-    { url = "https://files.pythonhosted.org/packages/2d/be/9eda82afa425370ffdb3fa9f3ea42450b9ae4da3ff0a4ec20466f69e371b/regex-2026.2.19-cp313-cp313t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:8abe671cf0f15c26b1ad389bf4043b068ce7d3b1c5d9313e12895f57d6738555", size = 781318, upload-time = "2026-02-19T19:02:10.072Z" },
-    { url = "https://files.pythonhosted.org/packages/c6/d5/50f0bbe56a8199f60a7b6c714e06e54b76b33d31806a69d0703b23ce2a9e/regex-2026.2.19-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:5a8f28dd32a4ce9c41758d43b5b9115c1c497b4b1f50c457602c1d571fa98ce1", size = 795649, upload-time = "2026-02-19T19:02:11.96Z" },
-    { url = "https://files.pythonhosted.org/packages/c5/09/d039f081e44a8b0134d0bb2dd805b0ddf390b69d0b58297ae098847c572f/regex-2026.2.19-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:654dc41a5ba9b8cc8432b3f1aa8906d8b45f3e9502442a07c2f27f6c63f85db5", size = 868844, upload-time = "2026-02-19T19:02:14.043Z" },
-    { url = "https://files.pythonhosted.org/packages/ef/53/e2903b79a19ec8557fe7cd21cd093956ff2dbc2e0e33969e3adbe5b184dd/regex-2026.2.19-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:4a02faea614e7fdd6ba8b3bec6c8e79529d356b100381cec76e638f45d12ca04", size = 770113, upload-time = "2026-02-19T19:02:16.161Z" },
-    { url = "https://files.pythonhosted.org/packages/8f/e2/784667767b55714ebb4e59bf106362327476b882c0b2f93c25e84cc99b1a/regex-2026.2.19-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:d96162140bb819814428800934c7b71b7bffe81fb6da2d6abc1dcca31741eca3", size = 854922, upload-time = "2026-02-19T19:02:18.155Z" },
-    { url = "https://files.pythonhosted.org/packages/59/78/9ef4356bd4aed752775bd18071034979b85f035fec51f3a4f9dea497a254/regex-2026.2.19-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:c227f2922153ee42bbeb355fd6d009f8c81d9d7bdd666e2276ce41f53ed9a743", size = 799636, upload-time = "2026-02-19T19:02:20.04Z" },
-    { url = "https://files.pythonhosted.org/packages/cf/54/fcfc9287f20c5c9bd8db755aafe3e8cf4d99a6a3f1c7162ee182e0ca9374/regex-2026.2.19-cp313-cp313t-win32.whl", hash = "sha256:a178df8ec03011153fbcd2c70cb961bc98cbbd9694b28f706c318bee8927c3db", size = 268968, upload-time = "2026-02-19T19:02:22.816Z" },
-    { url = "https://files.pythonhosted.org/packages/1e/a0/ff24c6cb1273e42472706d277147fc38e1f9074a280fb6034b0fc9b69415/regex-2026.2.19-cp313-cp313t-win_amd64.whl", hash = "sha256:2c1693ca6f444d554aa246b592355b5cec030ace5a2729eae1b04ab6e853e768", size = 280390, upload-time = "2026-02-19T19:02:25.231Z" },
-    { url = "https://files.pythonhosted.org/packages/1a/b6/a3f6ad89d780ffdeebb4d5e2e3e30bd2ef1f70f6a94d1760e03dd1e12c60/regex-2026.2.19-cp313-cp313t-win_arm64.whl", hash = "sha256:c0761d7ae8d65773e01515ebb0b304df1bf37a0a79546caad9cbe79a42c12af7", size = 271643, upload-time = "2026-02-19T19:02:27.175Z" },
-    { url = "https://files.pythonhosted.org/packages/2d/e2/7ad4e76a6dddefc0d64dbe12a4d3ca3947a19ddc501f864a5df2a8222ddd/regex-2026.2.19-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:03d191a9bcf94d31af56d2575210cb0d0c6a054dbcad2ea9e00aa4c42903b919", size = 489306, upload-time = "2026-02-19T19:02:29.058Z" },
-    { url = "https://files.pythonhosted.org/packages/14/95/ee1736135733afbcf1846c58671046f99c4d5170102a150ebb3dd8d701d9/regex-2026.2.19-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:516ee067c6c721d0d0bfb80a2004edbd060fffd07e456d4e1669e38fe82f922e", size = 291218, upload-time = "2026-02-19T19:02:31.083Z" },
-    { url = "https://files.pythonhosted.org/packages/ef/08/180d1826c3d7065200a5168c6b993a44947395c7bb6e04b2c2a219c34225/regex-2026.2.19-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:997862c619994c4a356cb7c3592502cbd50c2ab98da5f61c5c871f10f22de7e5", size = 289097, upload-time = "2026-02-19T19:02:33.485Z" },
-    { url = "https://files.pythonhosted.org/packages/28/93/0651924c390c5740f5f896723f8ddd946a6c63083a7d8647231c343912ff/regex-2026.2.19-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:02b9e1b8a7ebe2807cd7bbdf662510c8e43053a23262b9f46ad4fc2dfc9d204e", size = 799147, upload-time = "2026-02-19T19:02:35.669Z" },
-    { url = "https://files.pythonhosted.org/packages/a7/00/2078bd8bcd37d58a756989adbfd9f1d0151b7ca4085a9c2a07e917fbac61/regex-2026.2.19-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:6c8fb3b19652e425ff24169dad3ee07f99afa7996caa9dfbb3a9106cd726f49a", size = 865239, upload-time = "2026-02-19T19:02:38.012Z" },
-    { url = "https://files.pythonhosted.org/packages/2a/13/75195161ec16936b35a365fa8c1dd2ab29fd910dd2587765062b174d8cfc/regex-2026.2.19-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:50f1ee9488dd7a9fda850ec7c68cad7a32fa49fd19733f5403a3f92b451dcf73", size = 911904, upload-time = "2026-02-19T19:02:40.737Z" },
-    { url = "https://files.pythonhosted.org/packages/96/72/ac42f6012179343d1c4bd0ffee8c948d841cb32ea188d37e96d80527fcc9/regex-2026.2.19-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ab780092b1424d13200aa5a62996e95f65ee3db8509be366437439cdc0af1a9f", size = 803518, upload-time = "2026-02-19T19:02:42.923Z" },
-    { url = "https://files.pythonhosted.org/packages/bc/d1/75a08e2269b007b9783f0f86aa64488e023141219cb5f14dc1e69cda56c6/regex-2026.2.19-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:17648e1a88e72d88641b12635e70e6c71c5136ba14edba29bf8fc6834005a265", size = 775866, upload-time = "2026-02-19T19:02:45.189Z" },
-    { url = "https://files.pythonhosted.org/packages/92/41/70e7d05faf6994c2ca7a9fcaa536da8f8e4031d45b0ec04b57040ede201f/regex-2026.2.19-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:2f914ae8c804c8a8a562fe216100bc156bfb51338c1f8d55fe32cf407774359a", size = 788224, upload-time = "2026-02-19T19:02:47.804Z" },
-    { url = "https://files.pythonhosted.org/packages/c8/83/34a2dd601f9deb13c20545c674a55f4a05c90869ab73d985b74d639bac43/regex-2026.2.19-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:c7e121a918bbee3f12ac300ce0a0d2f2c979cf208fb071ed8df5a6323281915c", size = 859682, upload-time = "2026-02-19T19:02:50.583Z" },
-    { url = "https://files.pythonhosted.org/packages/8e/30/136db9a09a7f222d6e48b806f3730e7af6499a8cad9c72ac0d49d52c746e/regex-2026.2.19-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:2fedd459c791da24914ecc474feecd94cf7845efb262ac3134fe27cbd7eda799", size = 764223, upload-time = "2026-02-19T19:02:52.777Z" },
-    { url = "https://files.pythonhosted.org/packages/9e/ea/bb947743c78a16df481fa0635c50aa1a439bb80b0e6dc24cd4e49c716679/regex-2026.2.19-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:ea8dfc99689240e61fb21b5fc2828f68b90abf7777d057b62d3166b7c1543c4c", size = 850101, upload-time = "2026-02-19T19:02:55.87Z" },
-    { url = "https://files.pythonhosted.org/packages/25/27/e3bfe6e97a99f7393665926be02fef772da7f8aa59e50bc3134e4262a032/regex-2026.2.19-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:9fff45852160960f29e184ec8a5be5ab4063cfd0b168d439d1fc4ac3744bf29e", size = 789904, upload-time = "2026-02-19T19:02:58.523Z" },
-    { url = "https://files.pythonhosted.org/packages/84/7b/7e2be6f00cea59d08761b027ad237002e90cac74b1607200ebaa2ba3d586/regex-2026.2.19-cp314-cp314-win32.whl", hash = "sha256:5390b130cce14a7d1db226a3896273b7b35be10af35e69f1cca843b6e5d2bb2d", size = 271784, upload-time = "2026-02-19T19:03:00.418Z" },
-    { url = "https://files.pythonhosted.org/packages/f7/f6/639911530335773e7ec60bcaa519557b719586024c1d7eaad1daf87b646b/regex-2026.2.19-cp314-cp314-win_amd64.whl", hash = "sha256:e581f75d5c0b15669139ca1c2d3e23a65bb90e3c06ba9d9ea194c377c726a904", size = 280506, upload-time = "2026-02-19T19:03:02.302Z" },
-    { url = "https://files.pythonhosted.org/packages/cd/ec/2582b56b4e036d46bb9b5d74a18548439ffa16c11cf59076419174d80f48/regex-2026.2.19-cp314-cp314-win_arm64.whl", hash = "sha256:7187fdee1be0896c1499a991e9bf7c78e4b56b7863e7405d7bb687888ac10c4b", size = 273557, upload-time = "2026-02-19T19:03:04.836Z" },
-    { url = "https://files.pythonhosted.org/packages/49/0b/f901cfeb4efd83e4f5c3e9f91a6de77e8e5ceb18555698aca3a27e215ed3/regex-2026.2.19-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:5ec1d7c080832fdd4e150c6f5621fe674c70c63b3ae5a4454cebd7796263b175", size = 492196, upload-time = "2026-02-19T19:03:08.188Z" },
-    { url = "https://files.pythonhosted.org/packages/94/0a/349b959e3da874e15eda853755567b4cde7e5309dbb1e07bfe910cfde452/regex-2026.2.19-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:8457c1bc10ee9b29cdfd897ccda41dce6bde0e9abd514bcfef7bcd05e254d411", size = 292878, upload-time = "2026-02-19T19:03:10.272Z" },
-    { url = "https://files.pythonhosted.org/packages/98/b0/9d81b3c2c5ddff428f8c506713737278979a2c476f6e3675a9c51da0c389/regex-2026.2.19-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:cce8027010d1ffa3eb89a0b19621cdc78ae548ea2b49fea1f7bfb3ea77064c2b", size = 291235, upload-time = "2026-02-19T19:03:12.5Z" },
-    { url = "https://files.pythonhosted.org/packages/04/e7/be7818df8691dbe9508c381ea2cc4c1153e4fdb1c4b06388abeaa93bd712/regex-2026.2.19-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:11c138febb40546ff9e026dbbc41dc9fb8b29e61013fa5848ccfe045f5b23b83", size = 807893, upload-time = "2026-02-19T19:03:15.064Z" },
-    { url = "https://files.pythonhosted.org/packages/0c/b6/b898a8b983190cfa0276031c17beb73cfd1db07c03c8c37f606d80b655e2/regex-2026.2.19-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:74ff212aa61532246bb3036b3dfea62233414b0154b8bc3676975da78383cac3", size = 873696, upload-time = "2026-02-19T19:03:17.848Z" },
-    { url = "https://files.pythonhosted.org/packages/1a/98/126ba671d54f19080ec87cad228fb4f3cc387fff8c4a01cb4e93f4ff9d94/regex-2026.2.19-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d00c95a2b6bfeb3ea1cb68d1751b1dfce2b05adc2a72c488d77a780db06ab867", size = 915493, upload-time = "2026-02-19T19:03:20.343Z" },
-    { url = "https://files.pythonhosted.org/packages/b2/10/550c84a1a1a7371867fe8be2bea7df55e797cbca4709974811410e195c5d/regex-2026.2.19-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:311fcccb76af31be4c588d5a17f8f1a059ae8f4b097192896ebffc95612f223a", size = 813094, upload-time = "2026-02-19T19:03:23.287Z" },
-    { url = "https://files.pythonhosted.org/packages/29/fb/ba221d2fc76a27b6b7d7a60f73a7a6a7bac21c6ba95616a08be2bcb434b0/regex-2026.2.19-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:77cfd6b5e7c4e8bf7a39d243ea05882acf5e3c7002b0ef4756de6606893b0ecd", size = 781583, upload-time = "2026-02-19T19:03:26.872Z" },
-    { url = "https://files.pythonhosted.org/packages/26/f1/af79231301297c9e962679efc04a31361b58dc62dec1fc0cb4b8dd95956a/regex-2026.2.19-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:6380f29ff212ec922b6efb56100c089251940e0526a0d05aa7c2d9b571ddf2fe", size = 795875, upload-time = "2026-02-19T19:03:29.223Z" },
-    { url = "https://files.pythonhosted.org/packages/a0/90/1e1d76cb0a2d0a4f38a039993e1c5cd971ae50435d751c5bae4f10e1c302/regex-2026.2.19-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:655f553a1fa3ab8a7fd570eca793408b8d26a80bfd89ed24d116baaf13a38969", size = 868916, upload-time = "2026-02-19T19:03:31.415Z" },
-    { url = "https://files.pythonhosted.org/packages/9a/67/a1c01da76dbcfed690855a284c665cc0a370e7d02d1bd635cf9ff7dd74b8/regex-2026.2.19-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:015088b8558502f1f0bccd58754835aa154a7a5b0bd9d4c9b7b96ff4ae9ba876", size = 770386, upload-time = "2026-02-19T19:03:33.972Z" },
-    { url = "https://files.pythonhosted.org/packages/49/6f/94842bf294f432ff3836bfd91032e2ecabea6d284227f12d1f935318c9c4/regex-2026.2.19-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:9e6693b8567a59459b5dda19104c4a4dbbd4a1c78833eacc758796f2cfef1854", size = 855007, upload-time = "2026-02-19T19:03:36.238Z" },
-    { url = "https://files.pythonhosted.org/packages/ff/93/393cd203ca0d1d368f05ce12d2c7e91a324bc93c240db2e6d5ada05835f4/regex-2026.2.19-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:4071209fd4376ab5ceec72ad3507e9d3517c59e38a889079b98916477a871868", size = 799863, upload-time = "2026-02-19T19:03:38.497Z" },
-    { url = "https://files.pythonhosted.org/packages/43/d9/35afda99bd92bf1a5831e55a4936d37ea4bed6e34c176a3c2238317faf4f/regex-2026.2.19-cp314-cp314t-win32.whl", hash = "sha256:2905ff4a97fad42f2d0834d8b1ea3c2f856ec209837e458d71a061a7d05f9f01", size = 274742, upload-time = "2026-02-19T19:03:40.804Z" },
-    { url = "https://files.pythonhosted.org/packages/ae/42/7edc3344dcc87b698e9755f7f685d463852d481302539dae07135202d3ca/regex-2026.2.19-cp314-cp314t-win_amd64.whl", hash = "sha256:64128549b600987e0f335c2365879895f860a9161f283b14207c800a6ed623d3", size = 284443, upload-time = "2026-02-19T19:03:42.954Z" },
-    { url = "https://files.pythonhosted.org/packages/3a/45/affdf2d851b42adf3d13fc5b3b059372e9bd299371fd84cf5723c45871fa/regex-2026.2.19-cp314-cp314t-win_arm64.whl", hash = "sha256:a09ae430e94c049dc6957f6baa35ee3418a3a77f3c12b6e02883bd80a2b679b0", size = 274932, upload-time = "2026-02-19T19:03:45.488Z" },
+version = "2026.2.28"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/8b/71/41455aa99a5a5ac1eaf311f5d8efd9ce6433c03ac1e0962de163350d0d97/regex-2026.2.28.tar.gz", hash = "sha256:a729e47d418ea11d03469f321aaf67cdee8954cde3ff2cf8403ab87951ad10f2", size = 415184, upload-time = "2026-02-28T02:19:42.792Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/04/db/8cbfd0ba3f302f2d09dd0019a9fcab74b63fee77a76c937d0e33161fb8c1/regex-2026.2.28-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:e621fb7c8dc147419b28e1702f58a0177ff8308a76fa295c71f3e7827849f5d9", size = 488462, upload-time = "2026-02-28T02:16:22.616Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/10/ccc22c52802223f2368731964ddd117799e1390ffc39dbb31634a83022ee/regex-2026.2.28-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:0d5bef2031cbf38757a0b0bc4298bb4824b6332d28edc16b39247228fbdbad97", size = 290774, upload-time = "2026-02-28T02:16:23.993Z" },
+    { url = "https://files.pythonhosted.org/packages/62/b9/6796b3bf3101e64117201aaa3a5a030ec677ecf34b3cd6141b5d5c6c67d5/regex-2026.2.28-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:bcb399ed84eabf4282587ba151f2732ad8168e66f1d3f85b1d038868fe547703", size = 288724, upload-time = "2026-02-28T02:16:25.403Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/02/291c0ae3f3a10cea941d0f5366da1843d8d1fa8a25b0671e20a0e454bb38/regex-2026.2.28-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7c1b34dfa72f826f535b20712afa9bb3ba580020e834f3c69866c5bddbf10098", size = 791924, upload-time = "2026-02-28T02:16:26.863Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/57/f0235cc520d9672742196c5c15098f8f703f2758d48d5a7465a56333e496/regex-2026.2.28-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:851fa70df44325e1e4cdb79c5e676e91a78147b1b543db2aec8734d2add30ec2", size = 860095, upload-time = "2026-02-28T02:16:28.772Z" },
+    { url = "https://files.pythonhosted.org/packages/b3/7c/393c94cbedda79a0f5f2435ebd01644aba0b338d327eb24b4aa5b8d6c07f/regex-2026.2.28-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:516604edd17b1c2c3e579cf4e9b25a53bf8fa6e7cedddf1127804d3e0140ca64", size = 906583, upload-time = "2026-02-28T02:16:30.977Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/73/a72820f47ca5abf2b5d911d0407ba5178fc52cf9780191ed3a54f5f419a2/regex-2026.2.28-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e7ce83654d1ab701cb619285a18a8e5a889c1216d746ddc710c914ca5fd71022", size = 800234, upload-time = "2026-02-28T02:16:32.55Z" },
+    { url = "https://files.pythonhosted.org/packages/34/b3/6e6a4b7b31fa998c4cf159a12cbeaf356386fbd1a8be743b1e80a3da51e4/regex-2026.2.28-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:f2791948f7c70bb9335a9102df45e93d428f4b8128020d85920223925d73b9e1", size = 772803, upload-time = "2026-02-28T02:16:34.029Z" },
+    { url = "https://files.pythonhosted.org/packages/10/e7/5da0280c765d5a92af5e1cd324b3fe8464303189cbaa449de9a71910e273/regex-2026.2.28-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:03a83cc26aa2acda6b8b9dfe748cf9e84cbd390c424a1de34fdcef58961a297a", size = 781117, upload-time = "2026-02-28T02:16:36.253Z" },
+    { url = "https://files.pythonhosted.org/packages/76/39/0b8d7efb256ae34e1b8157acc1afd8758048a1cf0196e1aec2e71fd99f4b/regex-2026.2.28-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:ec6f5674c5dc836994f50f1186dd1fafde4be0666aae201ae2fcc3d29d8adf27", size = 854224, upload-time = "2026-02-28T02:16:38.119Z" },
+    { url = "https://files.pythonhosted.org/packages/21/ff/a96d483ebe8fe6d1c67907729202313895d8de8495569ec319c6f29d0438/regex-2026.2.28-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:50c2fc924749543e0eacc93ada6aeeb3ea5f6715825624baa0dccaec771668ae", size = 761898, upload-time = "2026-02-28T02:16:40.333Z" },
+    { url = "https://files.pythonhosted.org/packages/89/bd/d4f2e75cb4a54b484e796017e37c0d09d8a0a837de43d17e238adf163f4e/regex-2026.2.28-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:ba55c50f408fb5c346a3a02d2ce0ebc839784e24f7c9684fde328ff063c3cdea", size = 844832, upload-time = "2026-02-28T02:16:41.875Z" },
+    { url = "https://files.pythonhosted.org/packages/8a/a7/428a135cf5e15e4e11d1e696eb2bf968362f8ea8a5f237122e96bc2ae950/regex-2026.2.28-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:edb1b1b3a5576c56f08ac46f108c40333f222ebfd5cf63afdfa3aab0791ebe5b", size = 788347, upload-time = "2026-02-28T02:16:43.472Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/59/68691428851cf9c9c3707217ab1d9b47cfeec9d153a49919e6c368b9e926/regex-2026.2.28-cp311-cp311-win32.whl", hash = "sha256:948c12ef30ecedb128903c2c2678b339746eb7c689c5c21957c4a23950c96d15", size = 266033, upload-time = "2026-02-28T02:16:45.094Z" },
+    { url = "https://files.pythonhosted.org/packages/42/8b/1483de1c57024e89296cbcceb9cccb3f625d416ddb46e570be185c9b05a9/regex-2026.2.28-cp311-cp311-win_amd64.whl", hash = "sha256:fd63453f10d29097cc3dc62d070746523973fb5aa1c66d25f8558bebd47fed61", size = 277978, upload-time = "2026-02-28T02:16:46.75Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/36/abec45dc6e7252e3dbc797120496e43bb5730a7abf0d9cb69340696a2f2d/regex-2026.2.28-cp311-cp311-win_arm64.whl", hash = "sha256:00f2b8d9615aa165fdff0a13f1a92049bfad555ee91e20d246a51aa0b556c60a", size = 270340, upload-time = "2026-02-28T02:16:48.626Z" },
+    { url = "https://files.pythonhosted.org/packages/07/42/9061b03cf0fc4b5fa2c3984cbbaed54324377e440a5c5a29d29a72518d62/regex-2026.2.28-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:fcf26c3c6d0da98fada8ae4ef0aa1c3405a431c0a77eb17306d38a89b02adcd7", size = 489574, upload-time = "2026-02-28T02:16:50.455Z" },
+    { url = "https://files.pythonhosted.org/packages/77/83/0c8a5623a233015595e3da499c5a1c13720ac63c107897a6037bb97af248/regex-2026.2.28-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:02473c954af35dd2defeb07e44182f5705b30ea3f351a7cbffa9177beb14da5d", size = 291426, upload-time = "2026-02-28T02:16:52.52Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/06/3ef1ac6910dc3295ebd71b1f9bfa737e82cfead211a18b319d45f85ddd09/regex-2026.2.28-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:9b65d33a17101569f86d9c5966a8b1d7fbf8afdda5a8aa219301b0a80f58cf7d", size = 289200, upload-time = "2026-02-28T02:16:54.08Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/c9/8cc8d850b35ab5650ff6756a1cb85286e2000b66c97520b29c1587455344/regex-2026.2.28-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e71dcecaa113eebcc96622c17692672c2d104b1d71ddf7adeda90da7ddeb26fc", size = 796765, upload-time = "2026-02-28T02:16:55.905Z" },
+    { url = "https://files.pythonhosted.org/packages/e9/5d/57702597627fc23278ebf36fbb497ac91c0ce7fec89ac6c81e420ca3e38c/regex-2026.2.28-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:481df4623fa4969c8b11f3433ed7d5e3dc9cec0f008356c3212b3933fb77e3d8", size = 863093, upload-time = "2026-02-28T02:16:58.094Z" },
+    { url = "https://files.pythonhosted.org/packages/02/6d/f3ecad537ca2811b4d26b54ca848cf70e04fcfc138667c146a9f3157779c/regex-2026.2.28-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:64e7c6ad614573e0640f271e811a408d79a9e1fe62a46adb602f598df42a818d", size = 909455, upload-time = "2026-02-28T02:17:00.918Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/40/bb226f203caa22c1043c1ca79b36340156eca0f6a6742b46c3bb222a3a57/regex-2026.2.28-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d6b08a06976ff4fb0d83077022fde3eca06c55432bb997d8c0495b9a4e9872f4", size = 802037, upload-time = "2026-02-28T02:17:02.842Z" },
+    { url = "https://files.pythonhosted.org/packages/44/7c/c6d91d8911ac6803b45ca968e8e500c46934e58c0903cbc6d760ee817a0a/regex-2026.2.28-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:864cdd1a2ef5716b0ab468af40139e62ede1b3a53386b375ec0786bb6783fc05", size = 775113, upload-time = "2026-02-28T02:17:04.506Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/8d/4a9368d168d47abd4158580b8c848709667b1cd293ff0c0c277279543bd0/regex-2026.2.28-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:511f7419f7afab475fd4d639d4aedfc54205bcb0800066753ef68a59f0f330b5", size = 784194, upload-time = "2026-02-28T02:17:06.888Z" },
+    { url = "https://files.pythonhosted.org/packages/cc/bf/2c72ab5d8b7be462cb1651b5cc333da1d0068740342f350fcca3bca31947/regex-2026.2.28-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:b42f7466e32bf15a961cf09f35fa6323cc72e64d3d2c990b10de1274a5da0a59", size = 856846, upload-time = "2026-02-28T02:17:09.11Z" },
+    { url = "https://files.pythonhosted.org/packages/7c/f4/6b65c979bb6d09f51bb2d2a7bc85de73c01ec73335d7ddd202dcb8cd1c8f/regex-2026.2.28-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:8710d61737b0c0ce6836b1da7109f20d495e49b3809f30e27e9560be67a257bf", size = 763516, upload-time = "2026-02-28T02:17:11.004Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/32/29ea5e27400ee86d2cc2b4e80aa059df04eaf78b4f0c18576ae077aeff68/regex-2026.2.28-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:4390c365fd2d45278f45afd4673cb90f7285f5701607e3ad4274df08e36140ae", size = 849278, upload-time = "2026-02-28T02:17:12.693Z" },
+    { url = "https://files.pythonhosted.org/packages/1d/91/3233d03b5f865111cd517e1c95ee8b43e8b428d61fa73764a80c9bb6f537/regex-2026.2.28-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:cb3b1db8ff6c7b8bf838ab05583ea15230cb2f678e569ab0e3a24d1e8320940b", size = 790068, upload-time = "2026-02-28T02:17:14.9Z" },
+    { url = "https://files.pythonhosted.org/packages/76/92/abc706c1fb03b4580a09645b206a3fc032f5a9f457bc1a8038ac555658ab/regex-2026.2.28-cp312-cp312-win32.whl", hash = "sha256:f8ed9a5d4612df9d4de15878f0bc6aa7a268afbe5af21a3fdd97fa19516e978c", size = 266416, upload-time = "2026-02-28T02:17:17.15Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/06/2a6f7dff190e5fa9df9fb4acf2fdf17a1aa0f7f54596cba8de608db56b3a/regex-2026.2.28-cp312-cp312-win_amd64.whl", hash = "sha256:01d65fd24206c8e1e97e2e31b286c59009636c022eb5d003f52760b0f42155d4", size = 277297, upload-time = "2026-02-28T02:17:18.723Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/f0/58a2484851fadf284458fdbd728f580d55c1abac059ae9f048c63b92f427/regex-2026.2.28-cp312-cp312-win_arm64.whl", hash = "sha256:c0b5ccbb8ffb433939d248707d4a8b31993cb76ab1a0187ca886bf50e96df952", size = 270408, upload-time = "2026-02-28T02:17:20.328Z" },
+    { url = "https://files.pythonhosted.org/packages/87/f6/dc9ef48c61b79c8201585bf37fa70cd781977da86e466cd94e8e95d2443b/regex-2026.2.28-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:6d63a07e5ec8ce7184452cb00c41c37b49e67dc4f73b2955b5b8e782ea970784", size = 489311, upload-time = "2026-02-28T02:17:22.591Z" },
+    { url = "https://files.pythonhosted.org/packages/95/c8/c20390f2232d3f7956f420f4ef1852608ad57aa26c3dd78516cb9f3dc913/regex-2026.2.28-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:e59bc8f30414d283ae8ee1617b13d8112e7135cb92830f0ec3688cb29152585a", size = 291285, upload-time = "2026-02-28T02:17:24.355Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/a6/ba1068a631ebd71a230e7d8013fcd284b7c89c35f46f34a7da02082141b1/regex-2026.2.28-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:de0cf053139f96219ccfabb4a8dd2d217c8c82cb206c91d9f109f3f552d6b43d", size = 289051, upload-time = "2026-02-28T02:17:26.722Z" },
+    { url = "https://files.pythonhosted.org/packages/1d/1b/7cc3b7af4c244c204b7a80924bd3d85aecd9ba5bc82b485c5806ee8cda9e/regex-2026.2.28-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:fb4db2f17e6484904f986c5a657cec85574c76b5c5e61c7aae9ffa1bc6224f95", size = 796842, upload-time = "2026-02-28T02:17:29.064Z" },
+    { url = "https://files.pythonhosted.org/packages/24/87/26bd03efc60e0d772ac1e7b60a2e6325af98d974e2358f659c507d3c76db/regex-2026.2.28-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:52b017b35ac2214d0db5f4f90e303634dc44e4aba4bd6235a27f97ecbe5b0472", size = 863083, upload-time = "2026-02-28T02:17:31.363Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/54/aeaf4afb1aa0a65e40de52a61dc2ac5b00a83c6cb081c8a1d0dda74f3010/regex-2026.2.28-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:69fc560ccbf08a09dc9b52ab69cacfae51e0ed80dc5693078bdc97db2f91ae96", size = 909412, upload-time = "2026-02-28T02:17:33.248Z" },
+    { url = "https://files.pythonhosted.org/packages/12/2f/049901def913954e640d199bbc6a7ca2902b6aeda0e5da9d17f114100ec2/regex-2026.2.28-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e61eea47230eba62a31f3e8a0e3164d0f37ef9f40529fb2c79361bc6b53d2a92", size = 802101, upload-time = "2026-02-28T02:17:35.053Z" },
+    { url = "https://files.pythonhosted.org/packages/7d/a5/512fb9ff7f5b15ea204bb1967ebb649059446decacccb201381f9fa6aad4/regex-2026.2.28-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:4f5c0b182ad4269e7381b7c27fdb0408399881f7a92a4624fd5487f2971dfc11", size = 775260, upload-time = "2026-02-28T02:17:37.692Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/a8/9a92935878aba19bd72706b9db5646a6f993d99b3f6ed42c02ec8beb1d61/regex-2026.2.28-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:96f6269a2882fbb0ee76967116b83679dc628e68eaea44e90884b8d53d833881", size = 784311, upload-time = "2026-02-28T02:17:39.855Z" },
+    { url = "https://files.pythonhosted.org/packages/09/d3/fc51a8a738a49a6b6499626580554c9466d3ea561f2b72cfdc72e4149773/regex-2026.2.28-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:b5acd4b6a95f37c3c3828e5d053a7d4edaedb85de551db0153754924cb7c83e3", size = 856876, upload-time = "2026-02-28T02:17:42.317Z" },
+    { url = "https://files.pythonhosted.org/packages/08/b7/2e641f3d084b120ca4c52e8c762a78da0b32bf03ef546330db3e2635dc5f/regex-2026.2.28-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:2234059cfe33d9813a3677ef7667999caea9eeaa83fef98eb6ce15c6cf9e0215", size = 763632, upload-time = "2026-02-28T02:17:45.073Z" },
+    { url = "https://files.pythonhosted.org/packages/fe/6d/0009021d97e79ee99f3d8641f0a8d001eed23479ade4c3125a5480bf3e2d/regex-2026.2.28-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:c15af43c72a7fb0c97cbc66fa36a43546eddc5c06a662b64a0cbf30d6ac40944", size = 849320, upload-time = "2026-02-28T02:17:47.192Z" },
+    { url = "https://files.pythonhosted.org/packages/05/7a/51cfbad5758f8edae430cb21961a9c8d04bce1dae4d2d18d4186eec7cfa1/regex-2026.2.28-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:9185cc63359862a6e80fe97f696e04b0ad9a11c4ac0a4a927f979f611bfe3768", size = 790152, upload-time = "2026-02-28T02:17:49.067Z" },
+    { url = "https://files.pythonhosted.org/packages/90/3d/a83e2b6b3daa142acb8c41d51de3876186307d5cb7490087031747662500/regex-2026.2.28-cp313-cp313-win32.whl", hash = "sha256:fb66e5245db9652abd7196ace599b04d9c0e4aa7c8f0e2803938377835780081", size = 266398, upload-time = "2026-02-28T02:17:50.744Z" },
+    { url = "https://files.pythonhosted.org/packages/85/4f/16e9ebb1fe5425e11b9596c8d57bf8877dcb32391da0bfd33742e3290637/regex-2026.2.28-cp313-cp313-win_amd64.whl", hash = "sha256:71a911098be38c859ceb3f9a9ce43f4ed9f4c6720ad8684a066ea246b76ad9ff", size = 277282, upload-time = "2026-02-28T02:17:53.074Z" },
+    { url = "https://files.pythonhosted.org/packages/07/b4/92851335332810c5a89723bf7a7e35c7209f90b7d4160024501717b28cc9/regex-2026.2.28-cp313-cp313-win_arm64.whl", hash = "sha256:39bb5727650b9a0275c6a6690f9bb3fe693a7e6cc5c3155b1240aedf8926423e", size = 270382, upload-time = "2026-02-28T02:17:54.888Z" },
+    { url = "https://files.pythonhosted.org/packages/24/07/6c7e4cec1e585959e96cbc24299d97e4437a81173217af54f1804994e911/regex-2026.2.28-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:97054c55db06ab020342cc0d35d6f62a465fa7662871190175f1ad6c655c028f", size = 492541, upload-time = "2026-02-28T02:17:56.813Z" },
+    { url = "https://files.pythonhosted.org/packages/7c/13/55eb22ada7f43d4f4bb3815b6132183ebc331c81bd496e2d1f3b8d862e0d/regex-2026.2.28-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:0d25a10811de831c2baa6aef3c0be91622f44dd8d31dd12e69f6398efb15e48b", size = 292984, upload-time = "2026-02-28T02:17:58.538Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/11/c301f8cb29ce9644a5ef85104c59244e6e7e90994a0f458da4d39baa8e17/regex-2026.2.28-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:d6cfe798d8da41bb1862ed6e0cba14003d387c3c0c4a5d45591076ae9f0ce2f8", size = 291509, upload-time = "2026-02-28T02:18:00.208Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/43/aabe384ec1994b91796e903582427bc2ffaed9c4103819ed3c16d8e749f3/regex-2026.2.28-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:fd0ce43e71d825b7c0661f9c54d4d74bd97c56c3fd102a8985bcfea48236bacb", size = 809429, upload-time = "2026-02-28T02:18:02.328Z" },
+    { url = "https://files.pythonhosted.org/packages/04/b8/8d2d987a816720c4f3109cee7c06a4b24ad0e02d4fc74919ab619e543737/regex-2026.2.28-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:00945d007fd74a9084d2ab79b695b595c6b7ba3698972fadd43e23230c6979c1", size = 869422, upload-time = "2026-02-28T02:18:04.23Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/ad/2c004509e763c0c3719f97c03eca26473bffb3868d54c5f280b8cd4f9e3d/regex-2026.2.28-cp313-cp313t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:bec23c11cbbf09a4df32fe50d57cbdd777bc442269b6e39a1775654f1c95dee2", size = 915175, upload-time = "2026-02-28T02:18:06.791Z" },
+    { url = "https://files.pythonhosted.org/packages/55/c2/fd429066da487ef555a9da73bf214894aec77fc8c66a261ee355a69871a8/regex-2026.2.28-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5cdcc17d935c8f9d3f4db5c2ebe2640c332e3822ad5d23c2f8e0228e6947943a", size = 812044, upload-time = "2026-02-28T02:18:08.736Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/ca/feedb7055c62a3f7f659971bf45f0e0a87544b6b0cf462884761453f97c5/regex-2026.2.28-cp313-cp313t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:a448af01e3d8031c89c5d902040b124a5e921a25c4e5e07a861ca591ce429341", size = 782056, upload-time = "2026-02-28T02:18:10.777Z" },
+    { url = "https://files.pythonhosted.org/packages/95/30/1aa959ed0d25c1dd7dd5047ea8ba482ceaef38ce363c401fd32a6b923e60/regex-2026.2.28-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:10d28e19bd4888e4abf43bd3925f3c134c52fdf7259219003588a42e24c2aa25", size = 798743, upload-time = "2026-02-28T02:18:13.025Z" },
+    { url = "https://files.pythonhosted.org/packages/3b/1f/dadb9cf359004784051c897dcf4d5d79895f73a1bbb7b827abaa4814ae80/regex-2026.2.28-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:99985a2c277dcb9ccb63f937451af5d65177af1efdeb8173ac55b61095a0a05c", size = 864633, upload-time = "2026-02-28T02:18:16.84Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/f1/b9a25eb24e1cf79890f09e6ec971ee5b511519f1851de3453bc04f6c902b/regex-2026.2.28-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:e1e7b24cb3ae9953a560c563045d1ba56ee4749fbd05cf21ba571069bd7be81b", size = 770862, upload-time = "2026-02-28T02:18:18.892Z" },
+    { url = "https://files.pythonhosted.org/packages/02/9a/c5cb10b7aa6f182f9247a30cc9527e326601f46f4df864ac6db588d11fcd/regex-2026.2.28-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:d8511a01d0e4ee1992eb3ba19e09bc1866fe03f05129c3aec3fdc4cbc77aad3f", size = 854788, upload-time = "2026-02-28T02:18:21.475Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/50/414ba0731c4bd40b011fa4703b2cc86879ec060c64f2a906e65a56452589/regex-2026.2.28-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:aaffaecffcd2479ce87aa1e74076c221700b7c804e48e98e62500ee748f0f550", size = 800184, upload-time = "2026-02-28T02:18:23.492Z" },
+    { url = "https://files.pythonhosted.org/packages/69/50/0c7290987f97e7e6830b0d853f69dc4dc5852c934aae63e7fdcd76b4c383/regex-2026.2.28-cp313-cp313t-win32.whl", hash = "sha256:ef77bdde9c9eba3f7fa5b58084b29bbcc74bcf55fdbeaa67c102a35b5bd7e7cc", size = 269137, upload-time = "2026-02-28T02:18:25.375Z" },
+    { url = "https://files.pythonhosted.org/packages/68/80/ef26ff90e74ceb4051ad6efcbbb8a4be965184a57e879ebcbdef327d18fa/regex-2026.2.28-cp313-cp313t-win_amd64.whl", hash = "sha256:98adf340100cbe6fbaf8e6dc75e28f2c191b1be50ffefe292fb0e6f6eefdb0d8", size = 280682, upload-time = "2026-02-28T02:18:27.205Z" },
+    { url = "https://files.pythonhosted.org/packages/69/8b/fbad9c52e83ffe8f97e3ed1aa0516e6dff6bb633a41da9e64645bc7efdc5/regex-2026.2.28-cp313-cp313t-win_arm64.whl", hash = "sha256:2fb950ac1d88e6b6a9414381f403797b236f9fa17e1eee07683af72b1634207b", size = 271735, upload-time = "2026-02-28T02:18:29.015Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/03/691015f7a7cb1ed6dacb2ea5de5682e4858e05a4c5506b2839cd533bbcd6/regex-2026.2.28-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:78454178c7df31372ea737996fb7f36b3c2c92cccc641d251e072478afb4babc", size = 489497, upload-time = "2026-02-28T02:18:30.889Z" },
+    { url = "https://files.pythonhosted.org/packages/c6/ba/8db8fd19afcbfa0e1036eaa70c05f20ca8405817d4ad7a38a6b4c2f031ac/regex-2026.2.28-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:5d10303dd18cedfd4d095543998404df656088240bcfd3cd20a8f95b861f74bd", size = 291295, upload-time = "2026-02-28T02:18:33.426Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/79/9aa0caf089e8defef9b857b52fc53801f62ff868e19e5c83d4a96612eba1/regex-2026.2.28-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:19a9c9e0a8f24f39d575a6a854d516b48ffe4cbdcb9de55cb0570a032556ecff", size = 289275, upload-time = "2026-02-28T02:18:35.247Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/26/ee53117066a30ef9c883bf1127eece08308ccf8ccd45c45a966e7a665385/regex-2026.2.28-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:09500be324f49b470d907b3ef8af9afe857f5cca486f853853f7945ddbf75911", size = 797176, upload-time = "2026-02-28T02:18:37.15Z" },
+    { url = "https://files.pythonhosted.org/packages/05/1b/67fb0495a97259925f343ae78b5d24d4a6624356ae138b57f18bd43006e4/regex-2026.2.28-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:fb1c4ff62277d87a7335f2c1ea4e0387b8f2b3ad88a64efd9943906aafad4f33", size = 863813, upload-time = "2026-02-28T02:18:39.478Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/1d/93ac9bbafc53618091c685c7ed40239a90bf9f2a82c983f0baa97cb7ae07/regex-2026.2.28-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:b8b3f1be1738feadc69f62daa250c933e85c6f34fa378f54a7ff43807c1b9117", size = 908678, upload-time = "2026-02-28T02:18:41.619Z" },
+    { url = "https://files.pythonhosted.org/packages/c7/7a/a8f5e0561702b25239846a16349feece59712ae20598ebb205580332a471/regex-2026.2.28-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:dc8ed8c3f41c27acb83f7b6a9eb727a73fc6663441890c5cb3426a5f6a91ce7d", size = 801528, upload-time = "2026-02-28T02:18:43.624Z" },
+    { url = "https://files.pythonhosted.org/packages/96/5d/ed6d4cbde80309854b1b9f42d9062fee38ade15f7eb4909f6ef2440403b5/regex-2026.2.28-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:fa539be029844c0ce1114762d2952ab6cfdd7c7c9bd72e0db26b94c3c36dcc5a", size = 775373, upload-time = "2026-02-28T02:18:46.102Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/e9/6e53c34e8068b9deec3e87210086ecb5b9efebdefca6b0d3fa43d66dcecb/regex-2026.2.28-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:7900157786428a79615a8264dac1f12c9b02957c473c8110c6b1f972dcecaddf", size = 784859, upload-time = "2026-02-28T02:18:48.269Z" },
+    { url = "https://files.pythonhosted.org/packages/48/3c/736e1c7ca7f0dcd2ae33819888fdc69058a349b7e5e84bc3e2f296bbf794/regex-2026.2.28-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:0b1d2b07614d95fa2bf8a63fd1e98bd8fa2b4848dc91b1efbc8ba219fdd73952", size = 857813, upload-time = "2026-02-28T02:18:50.576Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/7c/48c4659ad9da61f58e79dbe8c05223e0006696b603c16eb6b5cbfbb52c27/regex-2026.2.28-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:b389c61aa28a79c2e0527ac36da579869c2e235a5b208a12c5b5318cda2501d8", size = 763705, upload-time = "2026-02-28T02:18:52.59Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/a1/bc1c261789283128165f71b71b4b221dd1b79c77023752a6074c102f18d8/regex-2026.2.28-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:f467cb602f03fbd1ab1908f68b53c649ce393fde056628dc8c7e634dab6bfc07", size = 848734, upload-time = "2026-02-28T02:18:54.595Z" },
+    { url = "https://files.pythonhosted.org/packages/10/d8/979407faf1397036e25a5ae778157366a911c0f382c62501009f4957cf86/regex-2026.2.28-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:e8c8cb2deba42f5ec1ede46374e990f8adc5e6456a57ac1a261b19be6f28e4e6", size = 789871, upload-time = "2026-02-28T02:18:57.34Z" },
+    { url = "https://files.pythonhosted.org/packages/03/23/da716821277115fcb1f4e3de1e5dc5023a1e6533598c486abf5448612579/regex-2026.2.28-cp314-cp314-win32.whl", hash = "sha256:9036b400b20e4858d56d117108d7813ed07bb7803e3eed766675862131135ca6", size = 271825, upload-time = "2026-02-28T02:18:59.202Z" },
+    { url = "https://files.pythonhosted.org/packages/91/ff/90696f535d978d5f16a52a419be2770a8d8a0e7e0cfecdbfc31313df7fab/regex-2026.2.28-cp314-cp314-win_amd64.whl", hash = "sha256:1d367257cd86c1cbb97ea94e77b373a0bbc2224976e247f173d19e8f18b4afa7", size = 280548, upload-time = "2026-02-28T02:19:01.049Z" },
+    { url = "https://files.pythonhosted.org/packages/69/f9/5e1b5652fc0af3fcdf7677e7df3ad2a0d47d669b34ac29a63bb177bb731b/regex-2026.2.28-cp314-cp314-win_arm64.whl", hash = "sha256:5e68192bb3a1d6fb2836da24aa494e413ea65853a21505e142e5b1064a595f3d", size = 273444, upload-time = "2026-02-28T02:19:03.255Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/eb/8389f9e940ac89bcf58d185e230a677b4fd07c5f9b917603ad5c0f8fa8fe/regex-2026.2.28-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:a5dac14d0872eeb35260a8e30bac07ddf22adc1e3a0635b52b02e180d17c9c7e", size = 492546, upload-time = "2026-02-28T02:19:05.378Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/c7/09441d27ce2a6fa6a61ea3150ea4639c1dcda9b31b2ea07b80d6937b24dd/regex-2026.2.28-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:ec0c608b7a7465ffadb344ed7c987ff2f11ee03f6a130b569aa74d8a70e8333c", size = 292986, upload-time = "2026-02-28T02:19:07.24Z" },
+    { url = "https://files.pythonhosted.org/packages/fb/69/4144b60ed7760a6bd235e4087041f487aa4aa62b45618ce018b0c14833ea/regex-2026.2.28-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:c7815afb0ca45456613fdaf60ea9c993715511c8d53a83bc468305cbc0ee23c7", size = 291518, upload-time = "2026-02-28T02:19:09.698Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/be/77e5426cf5948c82f98c53582009ca9e94938c71f73a8918474f2e2990bb/regex-2026.2.28-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b059e71ec363968671693a78c5053bd9cb2fe410f9b8e4657e88377ebd603a2e", size = 809464, upload-time = "2026-02-28T02:19:12.494Z" },
+    { url = "https://files.pythonhosted.org/packages/45/99/2c8c5ac90dc7d05c6e7d8e72c6a3599dc08cd577ac476898e91ca787d7f1/regex-2026.2.28-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:b8cf76f1a29f0e99dcfd7aef1551a9827588aae5a737fe31442021165f1920dc", size = 869553, upload-time = "2026-02-28T02:19:15.151Z" },
+    { url = "https://files.pythonhosted.org/packages/53/34/daa66a342f0271e7737003abf6c3097aa0498d58c668dbd88362ef94eb5d/regex-2026.2.28-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:180e08a435a0319e6a4821c3468da18dc7001987e1c17ae1335488dfe7518dd8", size = 915289, upload-time = "2026-02-28T02:19:17.331Z" },
+    { url = "https://files.pythonhosted.org/packages/c5/c7/e22c2aaf0a12e7e22ab19b004bb78d32ca1ecc7ef245949935463c5567de/regex-2026.2.28-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1e496956106fd59ba6322a8ea17141a27c5040e5ee8f9433ae92d4e5204462a0", size = 812156, upload-time = "2026-02-28T02:19:20.011Z" },
+    { url = "https://files.pythonhosted.org/packages/7f/bb/2dc18c1efd9051cf389cd0d7a3a4d90f6804b9fff3a51b5dc3c85b935f71/regex-2026.2.28-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:bba2b18d70eeb7b79950f12f633beeecd923f7c9ad6f6bae28e59b4cb3ab046b", size = 782215, upload-time = "2026-02-28T02:19:22.047Z" },
+    { url = "https://files.pythonhosted.org/packages/17/1e/9e4ec9b9013931faa32226ec4aa3c71fe664a6d8a2b91ac56442128b332f/regex-2026.2.28-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:6db7bfae0f8a2793ff1f7021468ea55e2699d0790eb58ee6ab36ae43aa00bc5b", size = 798925, upload-time = "2026-02-28T02:19:24.173Z" },
+    { url = "https://files.pythonhosted.org/packages/71/57/a505927e449a9ccb41e2cc8d735e2abe3444b0213d1cf9cb364a8c1f2524/regex-2026.2.28-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:d0b02e8b7e5874b48ae0f077ecca61c1a6a9f9895e9c6dfb191b55b242862033", size = 864701, upload-time = "2026-02-28T02:19:26.376Z" },
+    { url = "https://files.pythonhosted.org/packages/a6/ad/c62cb60cdd93e13eac5b3d9d6bd5d284225ed0e3329426f94d2552dd7cca/regex-2026.2.28-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:25b6eb660c5cf4b8c3407a1ed462abba26a926cc9965e164268a3267bcc06a43", size = 770899, upload-time = "2026-02-28T02:19:29.38Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/5a/874f861f5c3d5ab99633e8030dee1bc113db8e0be299d1f4b07f5b5ec349/regex-2026.2.28-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:5a932ea8ad5d0430351ff9c76c8db34db0d9f53c1d78f06022a21f4e290c5c18", size = 854727, upload-time = "2026-02-28T02:19:31.494Z" },
+    { url = "https://files.pythonhosted.org/packages/6b/ca/d2c03b0efde47e13db895b975b2be6a73ed90b8ba963677927283d43bf74/regex-2026.2.28-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:1c2c95e1a2b0f89d01e821ff4de1be4b5d73d1f4b0bf679fa27c1ad8d2327f1a", size = 800366, upload-time = "2026-02-28T02:19:34.248Z" },
+    { url = "https://files.pythonhosted.org/packages/14/bd/ee13b20b763b8989f7c75d592bfd5de37dc1181814a2a2747fedcf97e3ba/regex-2026.2.28-cp314-cp314t-win32.whl", hash = "sha256:bbb882061f742eb5d46f2f1bd5304055be0a66b783576de3d7eef1bed4778a6e", size = 274936, upload-time = "2026-02-28T02:19:36.313Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/e7/d8020e39414c93af7f0d8688eabcecece44abfd5ce314b21dfda0eebd3d8/regex-2026.2.28-cp314-cp314t-win_amd64.whl", hash = "sha256:6591f281cb44dc13de9585b552cec6fc6cf47fb2fe7a48892295ee9bc4a612f9", size = 284779, upload-time = "2026-02-28T02:19:38.625Z" },
+    { url = "https://files.pythonhosted.org/packages/13/c0/ad225f4a405827486f1955283407cf758b6d2fb966712644c5f5aef33d1b/regex-2026.2.28-cp314-cp314t-win_arm64.whl", hash = "sha256:dee50f1be42222f89767b64b283283ef963189da0dda4a515aa54a5563c62dec", size = 275010, upload-time = "2026-02-28T02:19:40.65Z" },
 ]
 
 [[package]]
@@ -2932,27 +2933,27 @@ wheels = [
 
 [[package]]
 name = "ruff"
-version = "0.15.2"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/06/04/eab13a954e763b0606f460443fcbf6bb5a0faf06890ea3754ff16523dce5/ruff-0.15.2.tar.gz", hash = "sha256:14b965afee0969e68bb871eba625343b8673375f457af4abe98553e8bbb98342", size = 4558148, upload-time = "2026-02-19T22:32:20.271Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/2f/70/3a4dc6d09b13cb3e695f28307e5d889b2e1a66b7af9c5e257e796695b0e6/ruff-0.15.2-py3-none-linux_armv6l.whl", hash = "sha256:120691a6fdae2f16d65435648160f5b81a9625288f75544dc40637436b5d3c0d", size = 10430565, upload-time = "2026-02-19T22:32:41.824Z" },
-    { url = "https://files.pythonhosted.org/packages/71/0b/bb8457b56185ece1305c666dc895832946d24055be90692381c31d57466d/ruff-0.15.2-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:a89056d831256099658b6bba4037ac6dd06f49d194199215befe2bb10457ea5e", size = 10820354, upload-time = "2026-02-19T22:32:07.366Z" },
-    { url = "https://files.pythonhosted.org/packages/2d/c1/e0532d7f9c9e0b14c46f61b14afd563298b8b83f337b6789ddd987e46121/ruff-0.15.2-py3-none-macosx_11_0_arm64.whl", hash = "sha256:e36dee3a64be0ebd23c86ffa3aa3fd3ac9a712ff295e192243f814a830b6bd87", size = 10170767, upload-time = "2026-02-19T22:32:13.188Z" },
-    { url = "https://files.pythonhosted.org/packages/47/e8/da1aa341d3af017a21c7a62fb5ec31d4e7ad0a93ab80e3a508316efbcb23/ruff-0.15.2-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a9fb47b6d9764677f8c0a193c0943ce9a05d6763523f132325af8a858eadc2b9", size = 10529591, upload-time = "2026-02-19T22:32:02.547Z" },
-    { url = "https://files.pythonhosted.org/packages/93/74/184fbf38e9f3510231fbc5e437e808f0b48c42d1df9434b208821efcd8d6/ruff-0.15.2-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:f376990f9d0d6442ea9014b19621d8f2aaf2b8e39fdbfc79220b7f0c596c9b80", size = 10260771, upload-time = "2026-02-19T22:32:36.938Z" },
-    { url = "https://files.pythonhosted.org/packages/05/ac/605c20b8e059a0bc4b42360414baa4892ff278cec1c91fff4be0dceedefd/ruff-0.15.2-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:2dcc987551952d73cbf5c88d9fdee815618d497e4df86cd4c4824cc59d5dd75f", size = 11045791, upload-time = "2026-02-19T22:32:31.642Z" },
-    { url = "https://files.pythonhosted.org/packages/fd/52/db6e419908f45a894924d410ac77d64bdd98ff86901d833364251bd08e22/ruff-0.15.2-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:42a47fd785cbe8c01b9ff45031af875d101b040ad8f4de7bbb716487c74c9a77", size = 11879271, upload-time = "2026-02-19T22:32:29.305Z" },
-    { url = "https://files.pythonhosted.org/packages/3e/d8/7992b18f2008bdc9231d0f10b16df7dda964dbf639e2b8b4c1b4e91b83af/ruff-0.15.2-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:cbe9f49354866e575b4c6943856989f966421870e85cd2ac94dccb0a9dcb2fea", size = 11303707, upload-time = "2026-02-19T22:32:22.492Z" },
-    { url = "https://files.pythonhosted.org/packages/d7/02/849b46184bcfdd4b64cde61752cc9a146c54759ed036edd11857e9b8443b/ruff-0.15.2-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b7a672c82b5f9887576087d97be5ce439f04bbaf548ee987b92d3a7dede41d3a", size = 11149151, upload-time = "2026-02-19T22:32:44.234Z" },
-    { url = "https://files.pythonhosted.org/packages/70/04/f5284e388bab60d1d3b99614a5a9aeb03e0f333847e2429bebd2aaa1feec/ruff-0.15.2-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:72ecc64f46f7019e2bcc3cdc05d4a7da958b629a5ab7033195e11a438403d956", size = 11091132, upload-time = "2026-02-19T22:32:24.691Z" },
-    { url = "https://files.pythonhosted.org/packages/fa/ae/88d844a21110e14d92cf73d57363fab59b727ebeabe78009b9ccb23500af/ruff-0.15.2-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:8dcf243b15b561c655c1ef2f2b0050e5d50db37fe90115507f6ff37d865dc8b4", size = 10504717, upload-time = "2026-02-19T22:32:26.75Z" },
-    { url = "https://files.pythonhosted.org/packages/64/27/867076a6ada7f2b9c8292884ab44d08fd2ba71bd2b5364d4136f3cd537e1/ruff-0.15.2-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:dab6941c862c05739774677c6273166d2510d254dac0695c0e3f5efa1b5585de", size = 10263122, upload-time = "2026-02-19T22:32:10.036Z" },
-    { url = "https://files.pythonhosted.org/packages/e7/ef/faf9321d550f8ebf0c6373696e70d1758e20ccdc3951ad7af00c0956be7c/ruff-0.15.2-py3-none-musllinux_1_2_i686.whl", hash = "sha256:1b9164f57fc36058e9a6806eb92af185b0697c9fe4c7c52caa431c6554521e5c", size = 10735295, upload-time = "2026-02-19T22:32:39.227Z" },
-    { url = "https://files.pythonhosted.org/packages/2f/55/e8089fec62e050ba84d71b70e7834b97709ca9b7aba10c1a0b196e493f97/ruff-0.15.2-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:80d24fcae24d42659db7e335b9e1531697a7102c19185b8dc4a028b952865fd8", size = 11241641, upload-time = "2026-02-19T22:32:34.617Z" },
-    { url = "https://files.pythonhosted.org/packages/23/01/1c30526460f4d23222d0fabd5888868262fd0e2b71a00570ca26483cd993/ruff-0.15.2-py3-none-win32.whl", hash = "sha256:fd5ff9e5f519a7e1bd99cbe8daa324010a74f5e2ebc97c6242c08f26f3714f6f", size = 10507885, upload-time = "2026-02-19T22:32:15.635Z" },
-    { url = "https://files.pythonhosted.org/packages/5c/10/3d18e3bbdf8fc50bbb4ac3cc45970aa5a9753c5cb51bf9ed9a3cd8b79fa3/ruff-0.15.2-py3-none-win_amd64.whl", hash = "sha256:d20014e3dfa400f3ff84830dfb5755ece2de45ab62ecea4af6b7262d0fb4f7c5", size = 11623725, upload-time = "2026-02-19T22:32:04.947Z" },
-    { url = "https://files.pythonhosted.org/packages/6d/78/097c0798b1dab9f8affe73da9642bb4500e098cb27fd8dc9724816ac747b/ruff-0.15.2-py3-none-win_arm64.whl", hash = "sha256:cabddc5822acdc8f7b5527b36ceac55cc51eec7b1946e60181de8fe83ca8876e", size = 10941649, upload-time = "2026-02-19T22:32:18.108Z" },
+version = "0.15.4"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/da/31/d6e536cdebb6568ae75a7f00e4b4819ae0ad2640c3604c305a0428680b0c/ruff-0.15.4.tar.gz", hash = "sha256:3412195319e42d634470cc97aa9803d07e9d5c9223b99bcb1518f0c725f26ae1", size = 4569550, upload-time = "2026-02-26T20:04:14.959Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f2/82/c11a03cfec3a4d26a0ea1e571f0f44be5993b923f905eeddfc397c13d360/ruff-0.15.4-py3-none-linux_armv6l.whl", hash = "sha256:a1810931c41606c686bae8b5b9a8072adac2f611bb433c0ba476acba17a332e0", size = 10453333, upload-time = "2026-02-26T20:04:20.093Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/5d/6a1f271f6e31dffb31855996493641edc3eef8077b883eaf007a2f1c2976/ruff-0.15.4-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:5a1632c66672b8b4d3e1d1782859e98d6e0b4e70829530666644286600a33992", size = 10853356, upload-time = "2026-02-26T20:04:05.808Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/d8/0fab9f8842b83b1a9c2bf81b85063f65e93fb512e60effa95b0be49bfc54/ruff-0.15.4-py3-none-macosx_11_0_arm64.whl", hash = "sha256:a4386ba2cd6c0f4ff75252845906acc7c7c8e1ac567b7bc3d373686ac8c222ba", size = 10187434, upload-time = "2026-02-26T20:03:54.656Z" },
+    { url = "https://files.pythonhosted.org/packages/85/cc/cc220fd9394eff5db8d94dec199eec56dd6c9f3651d8869d024867a91030/ruff-0.15.4-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b2496488bdfd3732747558b6f95ae427ff066d1fcd054daf75f5a50674411e75", size = 10535456, upload-time = "2026-02-26T20:03:52.738Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/0f/bced38fa5cf24373ec767713c8e4cadc90247f3863605fb030e597878661/ruff-0.15.4-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:3f1c4893841ff2d54cbda1b2860fa3260173df5ddd7b95d370186f8a5e66a4ac", size = 10287772, upload-time = "2026-02-26T20:04:08.138Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/90/58a1802d84fed15f8f281925b21ab3cecd813bde52a8ca033a4de8ab0e7a/ruff-0.15.4-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:820b8766bd65503b6c30aaa6331e8ef3a6e564f7999c844e9a547c40179e440a", size = 11049051, upload-time = "2026-02-26T20:04:03.53Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/ac/b7ad36703c35f3866584564dc15f12f91cb1a26a897dc2fd13d7cb3ae1af/ruff-0.15.4-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:c9fb74bab47139c1751f900f857fa503987253c3ef89129b24ed375e72873e85", size = 11890494, upload-time = "2026-02-26T20:04:10.497Z" },
+    { url = "https://files.pythonhosted.org/packages/93/3d/3eb2f47a39a8b0da99faf9c54d3eb24720add1e886a5309d4d1be73a6380/ruff-0.15.4-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f80c98765949c518142b3a50a5db89343aa90f2c2bf7799de9986498ae6176db", size = 11326221, upload-time = "2026-02-26T20:04:12.84Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/90/bf134f4c1e5243e62690e09d63c55df948a74084c8ac3e48a88468314da6/ruff-0.15.4-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:451a2e224151729b3b6c9ffb36aed9091b2996fe4bdbd11f47e27d8f2e8888ec", size = 11168459, upload-time = "2026-02-26T20:04:00.969Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/e5/a64d27688789b06b5d55162aafc32059bb8c989c61a5139a36e1368285eb/ruff-0.15.4-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:a8f157f2e583c513c4f5f896163a93198297371f34c04220daf40d133fdd4f7f", size = 11104366, upload-time = "2026-02-26T20:03:48.099Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/f6/32d1dcb66a2559763fc3027bdd65836cad9eb09d90f2ed6a63d8e9252b02/ruff-0.15.4-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:917cc68503357021f541e69b35361c99387cdbbf99bd0ea4aa6f28ca99ff5338", size = 10510887, upload-time = "2026-02-26T20:03:45.771Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/92/22d1ced50971c5b6433aed166fcef8c9343f567a94cf2b9d9089f6aa80fe/ruff-0.15.4-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:e9737c8161da79fd7cfec19f1e35620375bd8b2a50c3e77fa3d2c16f574105cc", size = 10285939, upload-time = "2026-02-26T20:04:22.42Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/f4/7c20aec3143837641a02509a4668fb146a642fd1211846634edc17eb5563/ruff-0.15.4-py3-none-musllinux_1_2_i686.whl", hash = "sha256:291258c917539e18f6ba40482fe31d6f5ac023994ee11d7bdafd716f2aab8a68", size = 10765471, upload-time = "2026-02-26T20:03:58.924Z" },
+    { url = "https://files.pythonhosted.org/packages/d0/09/6d2f7586f09a16120aebdff8f64d962d7c4348313c77ebb29c566cefc357/ruff-0.15.4-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:3f83c45911da6f2cd5936c436cf86b9f09f09165f033a99dcf7477e34041cbc3", size = 11263382, upload-time = "2026-02-26T20:04:24.424Z" },
+    { url = "https://files.pythonhosted.org/packages/1b/fa/2ef715a1cd329ef47c1a050e10dee91a9054b7ce2fcfdd6a06d139afb7ec/ruff-0.15.4-py3-none-win32.whl", hash = "sha256:65594a2d557d4ee9f02834fcdf0a28daa8b3b9f6cb2cb93846025a36db47ef22", size = 10506664, upload-time = "2026-02-26T20:03:50.56Z" },
+    { url = "https://files.pythonhosted.org/packages/d0/a8/c688ef7e29983976820d18710f955751d9f4d4eb69df658af3d006e2ba3e/ruff-0.15.4-py3-none-win_amd64.whl", hash = "sha256:04196ad44f0df220c2ece5b0e959c2f37c777375ec744397d21d15b50a75264f", size = 11651048, upload-time = "2026-02-26T20:04:17.191Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/0a/9e1be9035b37448ce2e68c978f0591da94389ade5a5abafa4cf99985d1b2/ruff-0.15.4-py3-none-win_arm64.whl", hash = "sha256:60d5177e8cfc70e51b9c5fad936c634872a74209f934c1e79107d11787ad5453", size = 10966776, upload-time = "2026-02-26T20:03:56.908Z" },
 ]
 
 [[package]]
@@ -3362,44 +3363,61 @@ wheels = [
 
 [[package]]
 name = "websockets"
-version = "15.0.1"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/21/e6/26d09fab466b7ca9c7737474c52be4f76a40301b08362eb2dbc19dcc16c1/websockets-15.0.1.tar.gz", hash = "sha256:82544de02076bafba038ce055ee6412d68da13ab47f0c60cab827346de828dee", size = 177016, upload-time = "2025-03-05T20:03:41.606Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/9f/32/18fcd5919c293a398db67443acd33fde142f283853076049824fc58e6f75/websockets-15.0.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:823c248b690b2fd9303ba00c4f66cd5e2d8c3ba4aa968b2779be9532a4dad431", size = 175423, upload-time = "2025-03-05T20:01:56.276Z" },
-    { url = "https://files.pythonhosted.org/packages/76/70/ba1ad96b07869275ef42e2ce21f07a5b0148936688c2baf7e4a1f60d5058/websockets-15.0.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:678999709e68425ae2593acf2e3ebcbcf2e69885a5ee78f9eb80e6e371f1bf57", size = 173082, upload-time = "2025-03-05T20:01:57.563Z" },
-    { url = "https://files.pythonhosted.org/packages/86/f2/10b55821dd40eb696ce4704a87d57774696f9451108cff0d2824c97e0f97/websockets-15.0.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:d50fd1ee42388dcfb2b3676132c78116490976f1300da28eb629272d5d93e905", size = 173330, upload-time = "2025-03-05T20:01:59.063Z" },
-    { url = "https://files.pythonhosted.org/packages/a5/90/1c37ae8b8a113d3daf1065222b6af61cc44102da95388ac0018fcb7d93d9/websockets-15.0.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d99e5546bf73dbad5bf3547174cd6cb8ba7273062a23808ffea025ecb1cf8562", size = 182878, upload-time = "2025-03-05T20:02:00.305Z" },
-    { url = "https://files.pythonhosted.org/packages/8e/8d/96e8e288b2a41dffafb78e8904ea7367ee4f891dafc2ab8d87e2124cb3d3/websockets-15.0.1-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:66dd88c918e3287efc22409d426c8f729688d89a0c587c88971a0faa2c2f3792", size = 181883, upload-time = "2025-03-05T20:02:03.148Z" },
-    { url = "https://files.pythonhosted.org/packages/93/1f/5d6dbf551766308f6f50f8baf8e9860be6182911e8106da7a7f73785f4c4/websockets-15.0.1-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8dd8327c795b3e3f219760fa603dcae1dcc148172290a8ab15158cf85a953413", size = 182252, upload-time = "2025-03-05T20:02:05.29Z" },
-    { url = "https://files.pythonhosted.org/packages/d4/78/2d4fed9123e6620cbf1706c0de8a1632e1a28e7774d94346d7de1bba2ca3/websockets-15.0.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:8fdc51055e6ff4adeb88d58a11042ec9a5eae317a0a53d12c062c8a8865909e8", size = 182521, upload-time = "2025-03-05T20:02:07.458Z" },
-    { url = "https://files.pythonhosted.org/packages/e7/3b/66d4c1b444dd1a9823c4a81f50231b921bab54eee2f69e70319b4e21f1ca/websockets-15.0.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:693f0192126df6c2327cce3baa7c06f2a117575e32ab2308f7f8216c29d9e2e3", size = 181958, upload-time = "2025-03-05T20:02:09.842Z" },
-    { url = "https://files.pythonhosted.org/packages/08/ff/e9eed2ee5fed6f76fdd6032ca5cd38c57ca9661430bb3d5fb2872dc8703c/websockets-15.0.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:54479983bd5fb469c38f2f5c7e3a24f9a4e70594cd68cd1fa6b9340dadaff7cf", size = 181918, upload-time = "2025-03-05T20:02:11.968Z" },
-    { url = "https://files.pythonhosted.org/packages/d8/75/994634a49b7e12532be6a42103597b71098fd25900f7437d6055ed39930a/websockets-15.0.1-cp311-cp311-win32.whl", hash = "sha256:16b6c1b3e57799b9d38427dda63edcbe4926352c47cf88588c0be4ace18dac85", size = 176388, upload-time = "2025-03-05T20:02:13.32Z" },
-    { url = "https://files.pythonhosted.org/packages/98/93/e36c73f78400a65f5e236cd376713c34182e6663f6889cd45a4a04d8f203/websockets-15.0.1-cp311-cp311-win_amd64.whl", hash = "sha256:27ccee0071a0e75d22cb35849b1db43f2ecd3e161041ac1ee9d2352ddf72f065", size = 176828, upload-time = "2025-03-05T20:02:14.585Z" },
-    { url = "https://files.pythonhosted.org/packages/51/6b/4545a0d843594f5d0771e86463606a3988b5a09ca5123136f8a76580dd63/websockets-15.0.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:3e90baa811a5d73f3ca0bcbf32064d663ed81318ab225ee4f427ad4e26e5aff3", size = 175437, upload-time = "2025-03-05T20:02:16.706Z" },
-    { url = "https://files.pythonhosted.org/packages/f4/71/809a0f5f6a06522af902e0f2ea2757f71ead94610010cf570ab5c98e99ed/websockets-15.0.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:592f1a9fe869c778694f0aa806ba0374e97648ab57936f092fd9d87f8bc03665", size = 173096, upload-time = "2025-03-05T20:02:18.832Z" },
-    { url = "https://files.pythonhosted.org/packages/3d/69/1a681dd6f02180916f116894181eab8b2e25b31e484c5d0eae637ec01f7c/websockets-15.0.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:0701bc3cfcb9164d04a14b149fd74be7347a530ad3bbf15ab2c678a2cd3dd9a2", size = 173332, upload-time = "2025-03-05T20:02:20.187Z" },
-    { url = "https://files.pythonhosted.org/packages/a6/02/0073b3952f5bce97eafbb35757f8d0d54812b6174ed8dd952aa08429bcc3/websockets-15.0.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e8b56bdcdb4505c8078cb6c7157d9811a85790f2f2b3632c7d1462ab5783d215", size = 183152, upload-time = "2025-03-05T20:02:22.286Z" },
-    { url = "https://files.pythonhosted.org/packages/74/45/c205c8480eafd114b428284840da0b1be9ffd0e4f87338dc95dc6ff961a1/websockets-15.0.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:0af68c55afbd5f07986df82831c7bff04846928ea8d1fd7f30052638788bc9b5", size = 182096, upload-time = "2025-03-05T20:02:24.368Z" },
-    { url = "https://files.pythonhosted.org/packages/14/8f/aa61f528fba38578ec553c145857a181384c72b98156f858ca5c8e82d9d3/websockets-15.0.1-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:64dee438fed052b52e4f98f76c5790513235efaa1ef7f3f2192c392cd7c91b65", size = 182523, upload-time = "2025-03-05T20:02:25.669Z" },
-    { url = "https://files.pythonhosted.org/packages/ec/6d/0267396610add5bc0d0d3e77f546d4cd287200804fe02323797de77dbce9/websockets-15.0.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:d5f6b181bb38171a8ad1d6aa58a67a6aa9d4b38d0f8c5f496b9e42561dfc62fe", size = 182790, upload-time = "2025-03-05T20:02:26.99Z" },
-    { url = "https://files.pythonhosted.org/packages/02/05/c68c5adbf679cf610ae2f74a9b871ae84564462955d991178f95a1ddb7dd/websockets-15.0.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:5d54b09eba2bada6011aea5375542a157637b91029687eb4fdb2dab11059c1b4", size = 182165, upload-time = "2025-03-05T20:02:30.291Z" },
-    { url = "https://files.pythonhosted.org/packages/29/93/bb672df7b2f5faac89761cb5fa34f5cec45a4026c383a4b5761c6cea5c16/websockets-15.0.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:3be571a8b5afed347da347bfcf27ba12b069d9d7f42cb8c7028b5e98bbb12597", size = 182160, upload-time = "2025-03-05T20:02:31.634Z" },
-    { url = "https://files.pythonhosted.org/packages/ff/83/de1f7709376dc3ca9b7eeb4b9a07b4526b14876b6d372a4dc62312bebee0/websockets-15.0.1-cp312-cp312-win32.whl", hash = "sha256:c338ffa0520bdb12fbc527265235639fb76e7bc7faafbb93f6ba80d9c06578a9", size = 176395, upload-time = "2025-03-05T20:02:33.017Z" },
-    { url = "https://files.pythonhosted.org/packages/7d/71/abf2ebc3bbfa40f391ce1428c7168fb20582d0ff57019b69ea20fa698043/websockets-15.0.1-cp312-cp312-win_amd64.whl", hash = "sha256:fcd5cf9e305d7b8338754470cf69cf81f420459dbae8a3b40cee57417f4614a7", size = 176841, upload-time = "2025-03-05T20:02:34.498Z" },
-    { url = "https://files.pythonhosted.org/packages/cb/9f/51f0cf64471a9d2b4d0fc6c534f323b664e7095640c34562f5182e5a7195/websockets-15.0.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:ee443ef070bb3b6ed74514f5efaa37a252af57c90eb33b956d35c8e9c10a1931", size = 175440, upload-time = "2025-03-05T20:02:36.695Z" },
-    { url = "https://files.pythonhosted.org/packages/8a/05/aa116ec9943c718905997412c5989f7ed671bc0188ee2ba89520e8765d7b/websockets-15.0.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:5a939de6b7b4e18ca683218320fc67ea886038265fd1ed30173f5ce3f8e85675", size = 173098, upload-time = "2025-03-05T20:02:37.985Z" },
-    { url = "https://files.pythonhosted.org/packages/ff/0b/33cef55ff24f2d92924923c99926dcce78e7bd922d649467f0eda8368923/websockets-15.0.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:746ee8dba912cd6fc889a8147168991d50ed70447bf18bcda7039f7d2e3d9151", size = 173329, upload-time = "2025-03-05T20:02:39.298Z" },
-    { url = "https://files.pythonhosted.org/packages/31/1d/063b25dcc01faa8fada1469bdf769de3768b7044eac9d41f734fd7b6ad6d/websockets-15.0.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:595b6c3969023ecf9041b2936ac3827e4623bfa3ccf007575f04c5a6aa318c22", size = 183111, upload-time = "2025-03-05T20:02:40.595Z" },
-    { url = "https://files.pythonhosted.org/packages/93/53/9a87ee494a51bf63e4ec9241c1ccc4f7c2f45fff85d5bde2ff74fcb68b9e/websockets-15.0.1-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:3c714d2fc58b5ca3e285461a4cc0c9a66bd0e24c5da9911e30158286c9b5be7f", size = 182054, upload-time = "2025-03-05T20:02:41.926Z" },
-    { url = "https://files.pythonhosted.org/packages/ff/b2/83a6ddf56cdcbad4e3d841fcc55d6ba7d19aeb89c50f24dd7e859ec0805f/websockets-15.0.1-cp313-cp313-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0f3c1e2ab208db911594ae5b4f79addeb3501604a165019dd221c0bdcabe4db8", size = 182496, upload-time = "2025-03-05T20:02:43.304Z" },
-    { url = "https://files.pythonhosted.org/packages/98/41/e7038944ed0abf34c45aa4635ba28136f06052e08fc2168520bb8b25149f/websockets-15.0.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:229cf1d3ca6c1804400b0a9790dc66528e08a6a1feec0d5040e8b9eb14422375", size = 182829, upload-time = "2025-03-05T20:02:48.812Z" },
-    { url = "https://files.pythonhosted.org/packages/e0/17/de15b6158680c7623c6ef0db361da965ab25d813ae54fcfeae2e5b9ef910/websockets-15.0.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:756c56e867a90fb00177d530dca4b097dd753cde348448a1012ed6c5131f8b7d", size = 182217, upload-time = "2025-03-05T20:02:50.14Z" },
-    { url = "https://files.pythonhosted.org/packages/33/2b/1f168cb6041853eef0362fb9554c3824367c5560cbdaad89ac40f8c2edfc/websockets-15.0.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:558d023b3df0bffe50a04e710bc87742de35060580a293c2a984299ed83bc4e4", size = 182195, upload-time = "2025-03-05T20:02:51.561Z" },
-    { url = "https://files.pythonhosted.org/packages/86/eb/20b6cdf273913d0ad05a6a14aed4b9a85591c18a987a3d47f20fa13dcc47/websockets-15.0.1-cp313-cp313-win32.whl", hash = "sha256:ba9e56e8ceeeedb2e080147ba85ffcd5cd0711b89576b83784d8605a7df455fa", size = 176393, upload-time = "2025-03-05T20:02:53.814Z" },
-    { url = "https://files.pythonhosted.org/packages/1b/6c/c65773d6cab416a64d191d6ee8a8b1c68a09970ea6909d16965d26bfed1e/websockets-15.0.1-cp313-cp313-win_amd64.whl", hash = "sha256:e09473f095a819042ecb2ab9465aee615bd9c2028e4ef7d933600a8401c79561", size = 176837, upload-time = "2025-03-05T20:02:55.237Z" },
-    { url = "https://files.pythonhosted.org/packages/fa/a8/5b41e0da817d64113292ab1f8247140aac61cbf6cfd085d6a0fa77f4984f/websockets-15.0.1-py3-none-any.whl", hash = "sha256:f7a866fbc1e97b5c617ee4116daaa09b722101d4a3c170c787450ba409f9736f", size = 169743, upload-time = "2025-03-05T20:03:39.41Z" },
+version = "16.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/04/24/4b2031d72e840ce4c1ccb255f693b15c334757fc50023e4db9537080b8c4/websockets-16.0.tar.gz", hash = "sha256:5f6261a5e56e8d5c42a4497b364ea24d94d9563e8fbd44e78ac40879c60179b5", size = 179346, upload-time = "2026-01-10T09:23:47.181Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f2/db/de907251b4ff46ae804ad0409809504153b3f30984daf82a1d84a9875830/websockets-16.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:31a52addea25187bde0797a97d6fc3d2f92b6f72a9370792d65a6e84615ac8a8", size = 177340, upload-time = "2026-01-10T09:22:34.539Z" },
+    { url = "https://files.pythonhosted.org/packages/f3/fa/abe89019d8d8815c8781e90d697dec52523fb8ebe308bf11664e8de1877e/websockets-16.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:417b28978cdccab24f46400586d128366313e8a96312e4b9362a4af504f3bbad", size = 175022, upload-time = "2026-01-10T09:22:36.332Z" },
+    { url = "https://files.pythonhosted.org/packages/58/5d/88ea17ed1ded2079358b40d31d48abe90a73c9e5819dbcde1606e991e2ad/websockets-16.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:af80d74d4edfa3cb9ed973a0a5ba2b2a549371f8a741e0800cb07becdd20f23d", size = 175319, upload-time = "2026-01-10T09:22:37.602Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/ae/0ee92b33087a33632f37a635e11e1d99d429d3d323329675a6022312aac2/websockets-16.0-cp311-cp311-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:08d7af67b64d29823fed316505a89b86705f2b7981c07848fb5e3ea3020c1abe", size = 184631, upload-time = "2026-01-10T09:22:38.789Z" },
+    { url = "https://files.pythonhosted.org/packages/c8/c5/27178df583b6c5b31b29f526ba2da5e2f864ecc79c99dae630a85d68c304/websockets-16.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7be95cfb0a4dae143eaed2bcba8ac23f4892d8971311f1b06f3c6b78952ee70b", size = 185870, upload-time = "2026-01-10T09:22:39.893Z" },
+    { url = "https://files.pythonhosted.org/packages/87/05/536652aa84ddc1c018dbb7e2c4cbcd0db884580bf8e95aece7593fde526f/websockets-16.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:d6297ce39ce5c2e6feb13c1a996a2ded3b6832155fcfc920265c76f24c7cceb5", size = 185361, upload-time = "2026-01-10T09:22:41.016Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/e2/d5332c90da12b1e01f06fb1b85c50cfc489783076547415bf9f0a659ec19/websockets-16.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:1c1b30e4f497b0b354057f3467f56244c603a79c0d1dafce1d16c283c25f6e64", size = 184615, upload-time = "2026-01-10T09:22:42.442Z" },
+    { url = "https://files.pythonhosted.org/packages/77/fb/d3f9576691cae9253b51555f841bc6600bf0a983a461c79500ace5a5b364/websockets-16.0-cp311-cp311-win32.whl", hash = "sha256:5f451484aeb5cafee1ccf789b1b66f535409d038c56966d6101740c1614b86c6", size = 178246, upload-time = "2026-01-10T09:22:43.654Z" },
+    { url = "https://files.pythonhosted.org/packages/54/67/eaff76b3dbaf18dcddabc3b8c1dba50b483761cccff67793897945b37408/websockets-16.0-cp311-cp311-win_amd64.whl", hash = "sha256:8d7f0659570eefb578dacde98e24fb60af35350193e4f56e11190787bee77dac", size = 178684, upload-time = "2026-01-10T09:22:44.941Z" },
+    { url = "https://files.pythonhosted.org/packages/84/7b/bac442e6b96c9d25092695578dda82403c77936104b5682307bd4deb1ad4/websockets-16.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:71c989cbf3254fbd5e84d3bff31e4da39c43f884e64f2551d14bb3c186230f00", size = 177365, upload-time = "2026-01-10T09:22:46.787Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/fe/136ccece61bd690d9c1f715baaeefd953bb2360134de73519d5df19d29ca/websockets-16.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:8b6e209ffee39ff1b6d0fa7bfef6de950c60dfb91b8fcead17da4ee539121a79", size = 175038, upload-time = "2026-01-10T09:22:47.999Z" },
+    { url = "https://files.pythonhosted.org/packages/40/1e/9771421ac2286eaab95b8575b0cb701ae3663abf8b5e1f64f1fd90d0a673/websockets-16.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:86890e837d61574c92a97496d590968b23c2ef0aeb8a9bc9421d174cd378ae39", size = 175328, upload-time = "2026-01-10T09:22:49.809Z" },
+    { url = "https://files.pythonhosted.org/packages/18/29/71729b4671f21e1eaa5d6573031ab810ad2936c8175f03f97f3ff164c802/websockets-16.0-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:9b5aca38b67492ef518a8ab76851862488a478602229112c4b0d58d63a7a4d5c", size = 184915, upload-time = "2026-01-10T09:22:51.071Z" },
+    { url = "https://files.pythonhosted.org/packages/97/bb/21c36b7dbbafc85d2d480cd65df02a1dc93bf76d97147605a8e27ff9409d/websockets-16.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e0334872c0a37b606418ac52f6ab9cfd17317ac26365f7f65e203e2d0d0d359f", size = 186152, upload-time = "2026-01-10T09:22:52.224Z" },
+    { url = "https://files.pythonhosted.org/packages/4a/34/9bf8df0c0cf88fa7bfe36678dc7b02970c9a7d5e065a3099292db87b1be2/websockets-16.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:a0b31e0b424cc6b5a04b8838bbaec1688834b2383256688cf47eb97412531da1", size = 185583, upload-time = "2026-01-10T09:22:53.443Z" },
+    { url = "https://files.pythonhosted.org/packages/47/88/4dd516068e1a3d6ab3c7c183288404cd424a9a02d585efbac226cb61ff2d/websockets-16.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:485c49116d0af10ac698623c513c1cc01c9446c058a4e61e3bf6c19dff7335a2", size = 184880, upload-time = "2026-01-10T09:22:55.033Z" },
+    { url = "https://files.pythonhosted.org/packages/91/d6/7d4553ad4bf1c0421e1ebd4b18de5d9098383b5caa1d937b63df8d04b565/websockets-16.0-cp312-cp312-win32.whl", hash = "sha256:eaded469f5e5b7294e2bdca0ab06becb6756ea86894a47806456089298813c89", size = 178261, upload-time = "2026-01-10T09:22:56.251Z" },
+    { url = "https://files.pythonhosted.org/packages/c3/f0/f3a17365441ed1c27f850a80b2bc680a0fa9505d733fe152fdf5e98c1c0b/websockets-16.0-cp312-cp312-win_amd64.whl", hash = "sha256:5569417dc80977fc8c2d43a86f78e0a5a22fee17565d78621b6bb264a115d4ea", size = 178693, upload-time = "2026-01-10T09:22:57.478Z" },
+    { url = "https://files.pythonhosted.org/packages/cc/9c/baa8456050d1c1b08dd0ec7346026668cbc6f145ab4e314d707bb845bf0d/websockets-16.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:878b336ac47938b474c8f982ac2f7266a540adc3fa4ad74ae96fea9823a02cc9", size = 177364, upload-time = "2026-01-10T09:22:59.333Z" },
+    { url = "https://files.pythonhosted.org/packages/7e/0c/8811fc53e9bcff68fe7de2bcbe75116a8d959ac699a3200f4847a8925210/websockets-16.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:52a0fec0e6c8d9a784c2c78276a48a2bdf099e4ccc2a4cad53b27718dbfd0230", size = 175039, upload-time = "2026-01-10T09:23:01.171Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/82/39a5f910cb99ec0b59e482971238c845af9220d3ab9fa76dd9162cda9d62/websockets-16.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:e6578ed5b6981005df1860a56e3617f14a6c307e6a71b4fff8c48fdc50f3ed2c", size = 175323, upload-time = "2026-01-10T09:23:02.341Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/28/0a25ee5342eb5d5f297d992a77e56892ecb65e7854c7898fb7d35e9b33bd/websockets-16.0-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:95724e638f0f9c350bb1c2b0a7ad0e83d9cc0c9259f3ea94e40d7b02a2179ae5", size = 184975, upload-time = "2026-01-10T09:23:03.756Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/66/27ea52741752f5107c2e41fda05e8395a682a1e11c4e592a809a90c6a506/websockets-16.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c0204dc62a89dc9d50d682412c10b3542d748260d743500a85c13cd1ee4bde82", size = 186203, upload-time = "2026-01-10T09:23:05.01Z" },
+    { url = "https://files.pythonhosted.org/packages/37/e5/8e32857371406a757816a2b471939d51c463509be73fa538216ea52b792a/websockets-16.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:52ac480f44d32970d66763115edea932f1c5b1312de36df06d6b219f6741eed8", size = 185653, upload-time = "2026-01-10T09:23:06.301Z" },
+    { url = "https://files.pythonhosted.org/packages/9b/67/f926bac29882894669368dc73f4da900fcdf47955d0a0185d60103df5737/websockets-16.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:6e5a82b677f8f6f59e8dfc34ec06ca6b5b48bc4fcda346acd093694cc2c24d8f", size = 184920, upload-time = "2026-01-10T09:23:07.492Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/a1/3d6ccdcd125b0a42a311bcd15a7f705d688f73b2a22d8cf1c0875d35d34a/websockets-16.0-cp313-cp313-win32.whl", hash = "sha256:abf050a199613f64c886ea10f38b47770a65154dc37181bfaff70c160f45315a", size = 178255, upload-time = "2026-01-10T09:23:09.245Z" },
+    { url = "https://files.pythonhosted.org/packages/6b/ae/90366304d7c2ce80f9b826096a9e9048b4bb760e44d3b873bb272cba696b/websockets-16.0-cp313-cp313-win_amd64.whl", hash = "sha256:3425ac5cf448801335d6fdc7ae1eb22072055417a96cc6b31b3861f455fbc156", size = 178689, upload-time = "2026-01-10T09:23:10.483Z" },
+    { url = "https://files.pythonhosted.org/packages/f3/1d/e88022630271f5bd349ed82417136281931e558d628dd52c4d8621b4a0b2/websockets-16.0-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:8cc451a50f2aee53042ac52d2d053d08bf89bcb31ae799cb4487587661c038a0", size = 177406, upload-time = "2026-01-10T09:23:12.178Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/78/e63be1bf0724eeb4616efb1ae1c9044f7c3953b7957799abb5915bffd38e/websockets-16.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:daa3b6ff70a9241cf6c7fc9e949d41232d9d7d26fd3522b1ad2b4d62487e9904", size = 175085, upload-time = "2026-01-10T09:23:13.511Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/f4/d3c9220d818ee955ae390cf319a7c7a467beceb24f05ee7aaaa2414345ba/websockets-16.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:fd3cb4adb94a2a6e2b7c0d8d05cb94e6f1c81a0cf9dc2694fb65c7e8d94c42e4", size = 175328, upload-time = "2026-01-10T09:23:14.727Z" },
+    { url = "https://files.pythonhosted.org/packages/63/bc/d3e208028de777087e6fb2b122051a6ff7bbcca0d6df9d9c2bf1dd869ae9/websockets-16.0-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:781caf5e8eee67f663126490c2f96f40906594cb86b408a703630f95550a8c3e", size = 185044, upload-time = "2026-01-10T09:23:15.939Z" },
+    { url = "https://files.pythonhosted.org/packages/ad/6e/9a0927ac24bd33a0a9af834d89e0abc7cfd8e13bed17a86407a66773cc0e/websockets-16.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:caab51a72c51973ca21fa8a18bd8165e1a0183f1ac7066a182ff27107b71e1a4", size = 186279, upload-time = "2026-01-10T09:23:17.148Z" },
+    { url = "https://files.pythonhosted.org/packages/b9/ca/bf1c68440d7a868180e11be653c85959502efd3a709323230314fda6e0b3/websockets-16.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:19c4dc84098e523fd63711e563077d39e90ec6702aff4b5d9e344a60cb3c0cb1", size = 185711, upload-time = "2026-01-10T09:23:18.372Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/f8/fdc34643a989561f217bb477cbc47a3a07212cbda91c0e4389c43c296ebf/websockets-16.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:a5e18a238a2b2249c9a9235466b90e96ae4795672598a58772dd806edc7ac6d3", size = 184982, upload-time = "2026-01-10T09:23:19.652Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/d1/574fa27e233764dbac9c52730d63fcf2823b16f0856b3329fc6268d6ae4f/websockets-16.0-cp314-cp314-win32.whl", hash = "sha256:a069d734c4a043182729edd3e9f247c3b2a4035415a9172fd0f1b71658a320a8", size = 177915, upload-time = "2026-01-10T09:23:21.458Z" },
+    { url = "https://files.pythonhosted.org/packages/8a/f1/ae6b937bf3126b5134ce1f482365fde31a357c784ac51852978768b5eff4/websockets-16.0-cp314-cp314-win_amd64.whl", hash = "sha256:c0ee0e63f23914732c6d7e0cce24915c48f3f1512ec1d079ed01fc629dab269d", size = 178381, upload-time = "2026-01-10T09:23:22.715Z" },
+    { url = "https://files.pythonhosted.org/packages/06/9b/f791d1db48403e1f0a27577a6beb37afae94254a8c6f08be4a23e4930bc0/websockets-16.0-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:a35539cacc3febb22b8f4d4a99cc79b104226a756aa7400adc722e83b0d03244", size = 177737, upload-time = "2026-01-10T09:23:24.523Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/40/53ad02341fa33b3ce489023f635367a4ac98b73570102ad2cdd770dacc9a/websockets-16.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:b784ca5de850f4ce93ec85d3269d24d4c82f22b7212023c974c401d4980ebc5e", size = 175268, upload-time = "2026-01-10T09:23:25.781Z" },
+    { url = "https://files.pythonhosted.org/packages/74/9b/6158d4e459b984f949dcbbb0c5d270154c7618e11c01029b9bbd1bb4c4f9/websockets-16.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:569d01a4e7fba956c5ae4fc988f0d4e187900f5497ce46339c996dbf24f17641", size = 175486, upload-time = "2026-01-10T09:23:27.033Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/2d/7583b30208b639c8090206f95073646c2c9ffd66f44df967981a64f849ad/websockets-16.0-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:50f23cdd8343b984957e4077839841146f67a3d31ab0d00e6b824e74c5b2f6e8", size = 185331, upload-time = "2026-01-10T09:23:28.259Z" },
+    { url = "https://files.pythonhosted.org/packages/45/b0/cce3784eb519b7b5ad680d14b9673a31ab8dcb7aad8b64d81709d2430aa8/websockets-16.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:152284a83a00c59b759697b7f9e9cddf4e3c7861dd0d964b472b70f78f89e80e", size = 186501, upload-time = "2026-01-10T09:23:29.449Z" },
+    { url = "https://files.pythonhosted.org/packages/19/60/b8ebe4c7e89fb5f6cdf080623c9d92789a53636950f7abacfc33fe2b3135/websockets-16.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:bc59589ab64b0022385f429b94697348a6a234e8ce22544e3681b2e9331b5944", size = 186062, upload-time = "2026-01-10T09:23:31.368Z" },
+    { url = "https://files.pythonhosted.org/packages/88/a8/a080593f89b0138b6cba1b28f8df5673b5506f72879322288b031337c0b8/websockets-16.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:32da954ffa2814258030e5a57bc73a3635463238e797c7375dc8091327434206", size = 185356, upload-time = "2026-01-10T09:23:32.627Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/b6/b9afed2afadddaf5ebb2afa801abf4b0868f42f8539bfe4b071b5266c9fe/websockets-16.0-cp314-cp314t-win32.whl", hash = "sha256:5a4b4cc550cb665dd8a47f868c8d04c8230f857363ad3c9caf7a0c3bf8c61ca6", size = 178085, upload-time = "2026-01-10T09:23:33.816Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/3e/28135a24e384493fa804216b79a6a6759a38cc4ff59118787b9fb693df93/websockets-16.0-cp314-cp314t-win_amd64.whl", hash = "sha256:b14dc141ed6d2dde437cddb216004bcac6a1df0935d79656387bd41632ba0bbd", size = 178531, upload-time = "2026-01-10T09:23:35.016Z" },
+    { url = "https://files.pythonhosted.org/packages/72/07/c98a68571dcf256e74f1f816b8cc5eae6eb2d3d5cfa44d37f801619d9166/websockets-16.0-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:349f83cd6c9a415428ee1005cadb5c2c56f4389bc06a9af16103c3bc3dcc8b7d", size = 174947, upload-time = "2026-01-10T09:23:36.166Z" },
+    { url = "https://files.pythonhosted.org/packages/7e/52/93e166a81e0305b33fe416338be92ae863563fe7bce446b0f687b9df5aea/websockets-16.0-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:4a1aba3340a8dca8db6eb5a7986157f52eb9e436b74813764241981ca4888f03", size = 175260, upload-time = "2026-01-10T09:23:37.409Z" },
+    { url = "https://files.pythonhosted.org/packages/56/0c/2dbf513bafd24889d33de2ff0368190a0e69f37bcfa19009ef819fe4d507/websockets-16.0-pp311-pypy311_pp73-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:f4a32d1bd841d4bcbffdcb3d2ce50c09c3909fbead375ab28d0181af89fd04da", size = 176071, upload-time = "2026-01-10T09:23:39.158Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/8f/aea9c71cc92bf9b6cc0f7f70df8f0b420636b6c96ef4feee1e16f80f75dd/websockets-16.0-pp311-pypy311_pp73-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0298d07ee155e2e9fda5be8a9042200dd2e3bb0b8a38482156576f863a9d457c", size = 176968, upload-time = "2026-01-10T09:23:41.031Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/3f/f70e03f40ffc9a30d817eef7da1be72ee4956ba8d7255c399a01b135902a/websockets-16.0-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:a653aea902e0324b52f1613332ddf50b00c06fdaf7e92624fbf8c77c78fa5767", size = 178735, upload-time = "2026-01-10T09:23:42.259Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/28/258ebab549c2bf3e64d2b0217b973467394a9cea8c42f70418ca2c5d0d2e/websockets-16.0-py3-none-any.whl", hash = "sha256:1637db62fad1dc833276dded54215f2c7fa46912301a24bd94d45d46a011ceec", size = 171598, upload-time = "2026-01-10T09:23:45.395Z" },
 ]
 
 [[package]]