diff --git a/.claude/CLAUDE.md b/.claude/CLAUDE.md
index 4933885..31479f5 100644
--- a/.claude/CLAUDE.md
+++ b/.claude/CLAUDE.md
@@ -3,7 +3,10 @@
 ## Workflow
 
 - v1 is a single-file Python app (`bterminal.py`). Changes are localized.
-- v2 planning docs are in `docs/`. Architecture decisions are in `docs/task_plan.md`.
+- v2 docs are in `docs/`. Architecture decisions are in `docs/task_plan.md`.
+- v2 Phases 1-7 + multi-machine (A-D) + profiles/skills complete. Extras: SSH, ctx, themes, detached mode, auto-updater, shiki, copy/paste, session resume, drag-resize, session groups, Deno sidecar, Claude profiles, skill discovery.
+- v3 Mission Control (All Phases 1-10 + Production Readiness Complete): project groups, workspace store, 15+ Workspace components, session continuity, multi-provider adapter pattern, worktree isolation, session anchors, Memora adapter, SOLID refactoring, multi-agent orchestration (btmsg/bttask, 4 Tier 1 roles, role-specific tabs), dashboard metrics, auto-wake scheduler, reviewer agent. Production: sidecar supervisor (auto-restart, exponential backoff), FTS5 search (3 virtual tables, Spotlight overlay), plugin system (sandboxed new Function(), permission-gated), Landlock sandbox (kernel 6.2+), secrets management (system keyring), OS+in-app notifications, keyboard-first UX (18+ palette commands, vi-nav), agent health monitoring (heartbeats, dead letter queue), audit logging, error classification (6 types), optimistic locking (bttask). Hardening: TLS relay, WAL checkpoint (5min), subagent delegation fix, plugin sandbox tests (35). 444 vitest + 151 cargo + 109 E2E.
+- v3 docs: `docs/v3-task_plan.md`, `docs/v3-findings.md`, `docs/v3-progress.md`.
 - Consult Memora (tag: `bterminal`) before making architectural changes.
 
 ## Documentation References
@@ -12,21 +15,81 @@
 - Implementation phases: [docs/phases.md](../docs/phases.md)
 - Research findings: [docs/findings.md](../docs/findings.md)
 - Progress log: [docs/progress.md](../docs/progress.md)
+- v3 architecture: [docs/v3-task_plan.md](../docs/v3-task_plan.md)
+- v3 findings: [docs/v3-findings.md](../docs/v3-findings.md)
+- v3 progress: [docs/v3-progress.md](../docs/v3-progress.md)
 
 ## Rules
 
 - Do not modify v1 code (`bterminal.py`) unless explicitly asked — it is production-stable.
-- v2 work goes on a feature branch (`v2-mission-control`), not master.
-- All v2 architecture decisions must reference `docs/task_plan.md` Decisions Log.
+- v2/v3 work goes on the `v2-mission-control` branch, not master.
+- v2 architecture decisions must reference `docs/task_plan.md` Decisions Log.
+- v3 architecture decisions must reference `docs/v3-task_plan.md` Decisions Log.
 - When adding new decisions, append to the Decisions Log table with date.
 - Update `docs/progress.md` after each significant work session.
 
 ## Key Technical Constraints
 
 - WebKit2GTK has no WebGL — xterm.js must use Canvas addon explicitly.
-- Claude Agent SDK is 0.2.x (pre-1.0) — all SDK interactions go through the adapter layer (`src/lib/adapters/sdk-messages.ts`).
-- Node.js sidecar communicates via stdio NDJSON, not sockets.
-- Maximum 4 active xterm.js instances to avoid WebKit2GTK memory issues.
+- Agent sessions use `@anthropic-ai/claude-agent-sdk` query() function (migrated from raw CLI spawning due to piped stdio hang bug). SDK handles subprocess management internally. All output goes through the adapter layer (`src/lib/adapters/claude-messages.ts` via `message-adapters.ts` registry) — SDK message format matches CLI stream-json. Multi-provider support: message-adapters.ts routes by ProviderId to provider-specific parsers (claude-messages.ts, codex-messages.ts, ollama-messages.ts — all 3 registered).
+- Sidecar uses per-provider runner bundles (`sidecar/dist/{provider}-runner.mjs`). Currently only `claude-runner.mjs` exists. SidecarManager.resolve_sidecar_for_provider(provider) finds the right runner file. Deno preferred (faster startup), Node.js fallback. Communicates with Rust via stdio NDJSON. Claude CLI auto-detected at startup via `findClaudeCli()` — checks ~/.local/bin/claude, ~/.claude/local/claude, /usr/local/bin/claude, /usr/bin/claude, then `which claude`. Path passed to SDK via `pathToClaudeCodeExecutable` option. Agents error immediately if CLI not found. Provider env var stripping: strip_provider_env_var() strips CLAUDE*/CODEX*/OLLAMA* vars (whitelists CLAUDE_CODE_EXPERIMENTAL_*). Dual-layer: (1) Rust env_clear() + clean_env, (2) JS runner SDK `env` option. Session stop uses AbortController.abort(). `agent-runner-deno.ts` exists as standalone alternative runner but is NOT used by SidecarManager.
+- AgentPane does NOT stop agents in onDestroy — onDestroy fires on layout remounts, not just explicit close. Stop-on-close is handled externally (was TilingGrid in v2, now workspace teardown in v3).
+- Agent dispatcher (`src/lib/agent-dispatcher.ts`) is a thin coordinator (260 lines) routing sidecar events to the agent store. Delegates to extracted modules: `utils/session-persistence.ts` (session-project maps, persistSessionForProject), `utils/subagent-router.ts` (spawn + route subagent panes), `utils/auto-anchoring.ts` (triggerAutoAnchor on compaction), `utils/worktree-detection.ts` (detectWorktreeFromCwd pure function). Provider-aware via message-adapters.ts.
+- AgentQueryOptions supports `provider` field (defaults to 'claude', flows Rust -> sidecar), `provider_config` blob (Rust passes through as serde_json::Value), `permission_mode` (defaults to 'bypassPermissions'), `setting_sources` (defaults to ['user', 'project']), `system_prompt`, `model`, `claude_config_dir` (for multi-account), `additional_directories`, `worktree_name` (when set, passed as `extraArgs: { worktree: name }` to SDK → `--worktree <name>` CLI flag), `extra_env` (HashMap<String,String>, injected into sidecar process env; used for BTMSG_AGENT_ID).
+- Multi-agent orchestration: Tier 1 (management agents: Manager, Architect, Tester, Reviewer) defined in groups.json `agents[]`, converted to ProjectConfig via `agentToProject()`, rendered as full ProjectBoxes. Tier 2 (project agents) are regular ProjectConfig entries. Both tiers get system prompts. Tier 1 prompt built by `generateAgentPrompt()` (utils/agent-prompts.ts): 7 sections (Identity, Environment, Team, btmsg docs, bttask docs, Custom context, Workflow). Tier 2 gets optional `project.systemPrompt` as custom context. BTMSG_AGENT_ID env var injected for Tier 1 agents only (enables btmsg/bttask CLI usage). Periodic re-injection: AgentSession runs 1-hour timer, sends context refresh prompt when agent is idle (autoPrompt → AgentPane → startQuery with resume=true).
+- bttask kanban: Rust bttask.rs module reads/writes tasks table in shared btmsg.db (~/.local/share/bterminal/btmsg.db). 7 operations: list_tasks, create_task, update_task_status, delete_task, add_comment, task_comments, review_queue_count. Frontend: TaskBoardTab.svelte (kanban 5 columns, 5s poll). CLI `bttask` tool gives agents direct access; Manager has full CRUD, Reviewer has read + status + comments, other roles have read-only + comments. On task→review transition, auto-posts to #review-queue btmsg channel (ensure_review_channels creates #review-queue + #review-log idempotently). Reviewer agent gets Tasks tab in ProjectBox (reuses TaskBoardTab). reviewQueueDepth in AttentionInput: 10pts per review task, capped at 50 (priority between file_conflict 70 and context_high 40). ProjectBox polls review_queue_count every 10s for reviewer agents → setReviewQueueDepth() in health store.
+- btmsg/bttask SQLite conventions: Both btmsg.rs and bttask.rs open shared btmsg.db with WAL mode + 5s busy_timeout (concurrent access from Python CLIs + Rust backend). All queries use named column access (`row.get("column_name")`) — never positional indices. Rust structs use `#[serde(rename_all = "camelCase")]`; TypeScript interfaces MUST match camelCase wire format. TestingTab uses `convertFileSrc()` for Tauri 2.x asset URLs (not `asset://localhost/`).
+- ArchitectureTab: PlantUML diagram viewer/editor. Stores .puml files in `.architecture/` project dir. Renders via plantuml.com server using ~h hex encoding (no Java dependency). 4 templates: Class, Sequence, State, Component. Editor + SVG preview toggle.
+- TestingTab: Dual-mode component (mode='selenium'|'tests'). Selenium: watches `.selenium/screenshots/` for PNG/JPG, displays in gallery with session log, 3s poll. Tests: discovers files in standard dirs (tests/, test/, spec/, __tests__/, e2e/), shows content.
+- Worktree isolation (S-1 Phase 3): Per-project `useWorktrees` toggle in SettingsTab. When enabled, AgentPane passes `worktree_name=sessionId` in queryAgent(). Agent runs in `<repo>/.claude/worktrees/<sessionId>/`. CWD-based detection: `utils/worktree-detection.ts` `detectWorktreeFromCwd()` matches `.claude/worktrees/`, `.codex/worktrees/`, `.cursor/worktrees/` patterns on init events → calls `setSessionWorktree()` for conflict suppression. Dual detection: CWD-based (primary, from init event) + tool_call-based `extractWorktreePath()` (subagent fallback).
+- Claude profiles: claude_list_profiles() reads ~/.config/switcher/profiles/ with profile.toml metadata. Profile set per-project in Settings (project.profile field), passed through AgentSession -> AgentPane `profile` prop -> resolved to config_dir for SDK. Profile name shown as info-only in ProjectHeader.
+- ProjectBox has project-level tab bar: Model | Docs | Context | Files | SSH | Memory + role-specific tabs. Three mount strategies: PERSISTED-EAGER (Model, Docs, Context — always mounted, display:flex/none), PERSISTED-LAZY (Files, SSH, Memory, Metrics, Tasks, Architecture, Selenium, Tests — mount on first activation via {#if everActivated} + display:flex/none). Tab type: `'model' | 'docs' | 'context' | 'files' | 'ssh' | 'memories' | 'metrics' | 'tasks' | 'architecture' | 'selenium' | 'tests'`. Role-specific tabs: Manager gets Tasks (kanban), Architect gets Arch (PlantUML), Tester gets Selenium+Tests. Metrics tab (all projects): MetricsPanel.svelte — Live view (fleet aggregates, project health grid, task board summary, attention queue) + History view (SVG sparklines for cost/tokens/turns/tools/duration, stats row, session table from session_metrics_load). Conditional on `isAgent && agentRole`. Model tab = AgentSession+TeamAgentsPanel. Docs tab = ProjectFiles (markdown viewer). Context tab = ContextTab.svelte (LLM context window visualization: stats bar, segmented token meter, file references, turn breakdown; reads from agent store via sessionId prop; replaced old ContextPane ctx database viewer). Files tab = FilesTab.svelte (VSCode-style directory tree + CodeMirror 6 editor with 15 language modes, dirty tracking, Ctrl+S save, save-on-blur setting, image display via convertFileSrc, 10MB gate; CodeEditor.svelte wrapper; PdfViewer.svelte for PDF files via pdfjs-dist with canvas multi-page rendering + zoom 0.5x–3x; CsvTable.svelte for CSV with RFC 4180 parser, delimiter auto-detect, sortable columns). SSH tab = SshTab.svelte (CRUD for SSH connections, launch spawns terminal tab in Model tab). Memory tab = MemoriesTab.svelte (pluggable via MemoryAdapter interface in memory-adapter.ts; MemoraAdapter registered at startup, reads ~/.local/share/memora/memories.db via Rust memora.rs). Tasks tab = TaskBoardTab.svelte (kanban board, 5 columns, 5s poll, Manager only). Arch tab = ArchitectureTab.svelte (PlantUML viewer/editor, .architecture/ dir, plantuml.com ~h hex encoding, Architect only). Selenium tab = TestingTab.svelte mode=selenium (screenshot gallery, session log, 3s poll, Tester only). Tests tab = TestingTab.svelte mode=tests (test file discovery, content viewer, Tester only). Rust backend: list_directory_children + read_file_content + write_file_content (FileContent tagged union: Text/Binary/TooLarge). Frontend bridge: files-bridge.ts.
+- ProjectHeader shows CWD (ellipsized from START via `direction: rtl`) + profile name as info-only text on right side. AgentPane no longer has DIR/ACC toolbar — CWD and profile are props from parent.
+- Skill discovery: claude_list_skills() reads ~/.claude/skills/ (dirs with SKILL.md or .md files). claude_read_skill() reads content. AgentPane `/` prefix triggers autocomplete menu. Skill content injected as prompt via expandSkillPrompt().
+- claude-bridge.ts adapter wraps profile/skill Tauri commands (ClaudeProfile, ClaudeSkill interfaces). provider-bridge.ts wraps claude-bridge as generic provider bridge (delegates by ProviderId).
+- Provider adapter pattern: ProviderId = 'claude' | 'codex' | 'ollama'. ProviderCapabilities flags gate UI (hasProfiles, hasSkills, hasModelSelection, hasSandbox, supportsSubagents, supportsCost, supportsResume). ProviderMeta registered via registerProvider() in App.svelte onMount. AgentPane receives provider + capabilities props. SettingsTab has Providers section with collapsible per-provider config panels. ProjectConfig.provider field for per-project selection. Settings persisted as `provider_settings` JSON blob.
+- Sidecar build: `npm run build:sidecar` builds all 3 runners via esbuild (claude-runner.mjs, codex-runner.mjs, ollama-runner.mjs). Each is a standalone ESM bundle. Codex runner dynamically imports @openai/codex-sdk (graceful failure if not installed). Ollama runner uses native fetch (zero deps).
+- Agent preview terminal: `AgentPreviewPane.svelte` is a read-only xterm.js terminal (disableStdin:true) that subscribes to an agent session's messages via `$derived(getAgentSession(sessionId))` and renders tool calls/results in real-time. Bash commands shown as cyan `❯ cmd`, file ops as yellow `[Read] path`, results as plain text (80-line truncation), errors in red. Spawned via 👁 button in TerminalTabs (appears when agentSessionId prop is set). TerminalTab type: `'agent-preview'` with `agentSessionId` field. Deduplicates — won't create two previews for the same session. ProjectBox passes mainSessionId to TerminalTabs.
+- Maximum 4 active xterm.js instances to avoid WebKit2GTK memory issues. Agent preview uses disableStdin and no PTY so is lighter, but still counts.
+- Store files using Svelte 5 runes (`$state`, `$derived`) MUST have `.svelte.ts` extension (not `.ts`). Import with `.svelte` suffix. Plain `.ts` compiles but fails at runtime with "rune_outside_svelte".
+- Session persistence uses rusqlite (bundled) with WAL mode. Data dir: `dirs::data_dir()/bterminal/sessions.db`.
+- Layout store persists to SQLite on every addPane/removePane/setPreset/setPaneGroup change (fire-and-forget). Restores on app startup via `restoreFromDb()`.
+- Session groups: Pane.group? field in layout store, group_name column in sessions table, collapsible group headers in sidebar. Right-click pane to set group.
+- File watcher uses notify crate v6, watches parent directory (NonRecursive), emits `file-changed` Tauri events.
+- Settings use key-value `settings` table in SQLite (session/settings.rs). Frontend: `settings-bridge.ts` adapter. v3 uses SettingsTab.svelte rendered in sidebar drawer panel (v2 SettingsDialog.svelte deleted in P10). SettingsTab has two sections: Global (single-column layout, split into Appearance [theme dropdown, UI font dropdown with sans-serif options + size stepper, Terminal font dropdown with monospace options + size stepper] and Defaults [shell, CWD] — all custom themed dropdowns, no native `<select>`, all persisted via settings-bridge with keys: theme, ui_font_family, ui_font_size, term_font_family, term_font_size, default_shell, default_cwd) and Group/Project CRUD.
+- Notifications use ephemeral toast system: `notifications.svelte.ts` store (max 5, 4s auto-dismiss), `ToastContainer.svelte` display. Agent dispatcher emits toasts on agent complete/error/crash.
+- StatusBar → Mission Control bar: running/idle/stalled agent counts (color-coded), total $/hr burn rate, "needs attention" dropdown priority queue (up to 5 cards sorted by urgency score, click-to-focus), total tokens + cost. Uses health.svelte.ts store (not workspace store for health signals).
+- health.svelte.ts store: per-project health tracking via ProjectTracker map. ActivityState = inactive|running|idle|stalled (configurable per-project via stallThresholdMin in ProjectConfig, default 15 min, range 5–60 min step 5, synced via setStallThreshold() API). Burn rate from 5-min EMA costSnapshots. Context pressure = tokens/model limit. File conflict count from conflicts.svelte.ts. Attention scoring: stalled=100, error=90, ctx>90%=80, file_conflict=70, ctx>75%=40. 5-second tick timer (auto-stop/start). API: trackProject(), recordActivity(), recordToolDone(), recordTokenSnapshot(), getProjectHealth(), getAttentionQueue(), getHealthAggregates().
+- conflicts.svelte.ts store: per-project file overlap + external write detection. Records Write/Edit/Bash-write tool_call file paths per session. Detects when 2+ sessions in same worktree write same file. S-1 Phase 2: inotify-based external write detection via fs_watcher.rs — uses 2s timing heuristic (AGENT_WRITE_GRACE_MS) to distinguish agent writes from external. EXTERNAL_SESSION_ID='__external__' sentinel. Worktree-aware. Dismissible. recordExternalWrite() for inotify events. FileConflict.isExternal flag, ProjectConflicts.externalConflictCount. Session-scoped, no persistence.
+- tool-files.ts utility: shared extractFilePaths(tc) → ToolFileRef[], extractWritePaths(tc) → string[], extractWorktreePath(tc) → string|null. Bash write detection via regex (>, >>, sed -i, tee, cp, mv). Used by ContextTab (all ops) and agent-dispatcher (writes + worktree tracking for conflict detection).
+- ProjectHeader shows status dot (green pulse=running, gray=idle, orange pulse=stalled, dim=inactive) + external write badge (orange ⚡ clickable, shown when externalConflictCount > 0) + agent conflict badge (red ⚠ clickable with ✕) + context pressure badge (>90% red, >75% orange, >50% yellow) + burn rate badge ($/hr). Health prop from ProjectBox via getProjectHealth(). ProjectBox starts/stops fs watcher per project CWD via $effect.
+- wake-scheduler.svelte.ts store: Manager auto-wake with 3 user-selectable strategies (persistent=resume prompt, on-demand=fresh session, smart=threshold-gated on-demand). Configurable via SettingsTab (strategy segmented button + threshold slider for smart). 6 wake signals from tribunal S-3 hybrid: AttentionSpike(1.0), ContextPressureCluster(0.9), BurnRateAnomaly(0.8), TaskQueuePressure(0.7), ReviewBacklog(0.6), PeriodicFloor(0.1). Pure scorer in wake-scorer.ts (24 tests). Types in types/wake.ts. GroupAgentConfig: wakeStrategy, wakeThreshold fields. ProjectBox registers managers via $effect. AgentSession polls wake events every 5s. Cleared on group switch via clearWakeScheduler().
+- session_metrics SQLite table: per-project historical session data (project_id, session_id, timestamps, peak_tokens, turn_count, tool_call_count, cost_usd, model, status, error_message). 100-row retention per project. Tauri commands: session_metric_save, session_metrics_load. Persisted on agent completion via agent-dispatcher.
+- Session anchors (S-2): Preserves important turns through compaction chains. Types: auto (on first compaction, 3 turns, observation-masked — reasoning preserved in full, only tool outputs compacted), pinned (user-created via pin button in AgentPane), promoted (user-promoted from pinned, re-injectable). Configurable budget via AnchorBudgetScale ('small'=2K|'medium'=6K|'large'=12K|'full'=20K) — per-project slider in SettingsTab, stored as ProjectConfig.anchorBudgetScale in groups.json. Re-injection: anchors.svelte.ts → AgentPane.startQuery() → system_prompt field → sidecar → SDK. ContextTab shows anchor section with budget meter (derived from scale) + promote/demote. SQLite: session_anchors table. Files: types/anchors.ts, adapters/anchors-bridge.ts, stores/anchors.svelte.ts, utils/anchor-serializer.ts.
+- Agent tree (AgentTree.svelte) uses SVG with recursive layout. Tree data built by `agent-tree.ts` utility from agent messages.
+- ctx integration opens `~/.claude-context/context.db` as SQLITE_OPEN_READ_ONLY — never writes. CtxDb uses Option<Connection> for graceful absence if DB doesn't exist.
+- SSH sessions spawn TerminalPane with shell=/usr/bin/ssh and args array. No SSH library needed — PTY handles it natively.
+- Theme system: 17 themes in 3 groups — 4 Catppuccin + 7 Editor (VSCode Dark+, Atom One Dark, Monokai, Dracula, Nord, Solarized Dark, GitHub Dark) + 6 Deep Dark (Tokyo Night, Gruvbox Dark, Ayu Dark, Poimandres, Vesper, Midnight). All map to same 26 --ctp-* CSS custom properties — zero component changes needed. ThemeId replaces CatppuccinFlavor. getCurrentTheme()/setTheme() are primary API (deprecated wrappers exist). THEME_LIST has ThemeMeta with group metadata for custom dropdown UI. Open terminals hot-swap via onThemeChange() callback registry in theme.svelte.ts. Typography uses --ui-font-family/--ui-font-size (UI elements, sans-serif fallback) and --term-font-family/--term-font-size (terminal, monospace fallback) CSS custom properties (defined in catppuccin.css). initTheme() restores all 4 font settings (ui_font_family, ui_font_size, term_font_family, term_font_size) from SQLite on startup.
+- Detached pane mode: App.svelte checks URL param `?detached=1` and renders a single pane without sidebar/grid chrome. Used for pop-out windows.
+- Shiki syntax highlighting uses lazy singleton pattern (avoid repeated WASM init). 13 languages preloaded. Used in MarkdownPane and AgentPane text messages.
+- Cargo workspace at v2/ level: members = [src-tauri, bterminal-core, bterminal-relay]. Cargo.lock is at workspace root (v2/), not in src-tauri/.
+- EventSink trait (bterminal-core/src/event.rs) abstracts event emission. PtyManager and SidecarManager are in bterminal-core, not src-tauri. src-tauri has thin re-exports.
+- RemoteManager (src-tauri/src/remote.rs) manages WebSocket client connections to bterminal-relay instances. 12 Tauri commands prefixed with `remote_`.
+- remote-bridge.ts adapter wraps remote machine management IPC. machines.svelte.ts store tracks remote machine state.
+- Pane.remoteMachineId?: string routes operations through RemoteManager instead of local managers. Bridge adapters (pty-bridge, agent-bridge) check this field.
+- bterminal-relay binary (v2/bterminal-relay/) is a standalone WebSocket server with token auth, rate limiting, and per-connection isolated managers. Commands return structured responses (pty_created, pong, error) with commandId for correlation via send_error() helper.
+- RemoteManager reconnection: exponential backoff (1s-30s cap) on disconnect, attempt_tcp_probe() (TCP-only, no WS upgrade), emits remote-machine-reconnecting and remote-machine-reconnect-ready events. Frontend listeners in remote-bridge.ts; machines store auto-reconnects on ready.
+- v3 workspace store (`workspace.svelte.ts`) replaces layout store for v3. Groups loaded from `~/.config/bterminal/groups.json` via `groups-bridge.ts`. State: groups, activeGroupId, activeTab, focusedProjectId. Derived: activeGroup, activeProjects.
+- v3 groups backend (`groups.rs`): load_groups(), save_groups(), default_groups(). Tauri commands: groups_load, groups_save.
+- Telemetry (`telemetry.rs`): tracing + optional OTLP export to Tempo. `BTERMINAL_OTLP_ENDPOINT` env var controls (absent = console-only). TelemetryGuard in AppState with Drop-based shutdown. Frontend events route through `frontend_log` Tauri command → Rust tracing (no browser OTEL SDK — WebKit2GTK incompatible). `telemetry-bridge.ts` provides `tel.info/warn/error()` convenience API. Docker stack at `docker/tempo/` (Grafana port 9715).
+- E2E test mode (`BTERMINAL_TEST=1`): watcher.rs and fs_watcher.rs skip file watchers, wake-scheduler disabled via `disableWakeScheduler()`, `is_test_mode` Tauri command bridges to frontend. Data/config dirs overridable via `BTERMINAL_TEST_DATA_DIR`/`BTERMINAL_TEST_CONFIG_DIR`. E2E uses WebDriverIO + tauri-driver, single session, TCP readiness probe. Phase A: 7 data-testid-based scenarios in `agent-scenarios.test.ts` (deterministic assertions). Phase B: 6 scenarios in `phase-b.test.ts` (multi-project grid, independent tab switching, status bar fleet state, LLM-judged agent responses/code generation, context tab verification). LLM judge (`llm-judge.ts`): raw fetch to Anthropic API using claude-haiku-4-5, structured verdict (pass/fail + reasoning + confidence), `assertWithJudge()` with configurable threshold, skips when `ANTHROPIC_API_KEY` absent. CI workflow (`.github/workflows/e2e.yml`): unit + cargo + e2e jobs, xvfb-run, path-filtered triggers, LLM tests gated on secret. Test fixtures in `fixtures.ts` create isolated temp environments. Results tracked via JSON store in `results-db.ts`.
+- v3 SQLite additions: agent_messages table (per-project message persistence), project_agent_state table (sdkSessionId, cost, status per project), sessions.project_id column.
+- v3 App.svelte: VSCode-style sidebar layout. Horizontal: left icon rail (GlobalTabBar, 2.75rem, single Settings gear icon) + expandable drawer panel (Settings only, content-driven width, max 50%) + main workspace (ProjectGrid always visible) + StatusBar. Sidebar has Settings only — Sessions/Docs/Context are project-specific (in ProjectBox tabs). Keyboard: Ctrl+B (toggle sidebar), Ctrl+, (settings), Escape (close).
+- v3 component tree: App -> GlobalTabBar (settings icon) + sidebar-panel? (SettingsTab) + workspace (ProjectGrid) + StatusBar. See `docs/v3-task_plan.md` for full tree.
+- MarkdownPane reactively watches filePath changes via $effect (not onMount-only). Uses sans-serif font (Inter, system-ui), all --ctp-* theme vars. Styled blockquotes with translucent backgrounds, table row hover, link hover underlines. Inner `.markdown-pane-scroll` wrapper with `container-type: inline-size` for responsive padding via `--bterminal-pane-padding-inline`.
+- AgentPane UI (redesigned 2026-03-09): sans-serif root font (`system-ui, -apple-system, sans-serif`), monospace only on code/tool names. Tool calls paired with results in collapsible `<details>` groups via `$derived.by` toolResultMap (cache-guarded by tool_result count). Hook messages collapsed into compact `<details>` with gear icon. Context window meter inline in status strip. Cost bar minimal (no background, subtle border-top). Session summary with translucent surface background. Two-phase scroll anchoring (`$effect.pre` + `$effect`). Tool-aware output truncation (Bash 500 lines, Read/Write 50, Glob/Grep 20, default 30). Colors softened via `color-mix()`. Inner `.agent-pane-scroll` wrapper with `container-type: inline-size` for responsive padding via shared `--bterminal-pane-padding-inline` variable.
+- ProjectBox uses CSS `style:display` (flex/none) instead of `{#if}` for tab content panes — keeps AgentSession mounted across tab switches (prevents session ID reset and message loss). Terminal section also uses `style:display`. Grid rows: auto auto 1fr auto.
+- Svelte 5 event syntax: use `onclick` not `on:click`. Svelte 5 requires lowercase event handler attributes (no colon syntax).
 
 ## Memora Tags
 
@@ -58,3 +121,7 @@ All operational rules live in `.claude/rules/`. Every `.md` file in that directo
 | 15 | `memora.md` | Persistent memory across sessions |
 | 16 | `sub-agents.md` | When to use sub-agents and team agents |
 | 17 | `document-imports.md` | Resolve @ imports in CLAUDE.md before acting |
+| 18 | `relative-units.md` | Use rem/em for layout, px only for icons/borders |
+| 20 | `testing-gate.md` | Run full test suite after major changes |
+| 51 | `theme-integration.md` | All colors via --ctp-* CSS vars, never hardcode |
+| 52 | `no-implicit-push.md` | Never push unless explicitly asked |
diff --git a/.claude/rules/06-testing.md b/.claude/rules/06-testing.md
index 3b47254..3efe72e 100644
--- a/.claude/rules/06-testing.md
+++ b/.claude/rules/06-testing.md
@@ -18,6 +18,21 @@ Assume nothing about correctness — prove it with tests.
 
 - Critical user journeys only (~10% of suite). Test API endpoints with integration tests, not E2E.
 
+## Browser Automation
+
+Choose the right tool for the job:
+
+| Tool | Use When |
+|------|----------|
+| **Claude in Chrome** | Authenticated sites, user's logged-in session needed |
+| **Playwright MCP** | Cross-browser testing, E2E test suites, CI-style validation |
+| **Puppeteer MCP** | Quick DOM scripting, page scraping, lightweight checks |
+| **Chrome DevTools MCP** | Deep debugging (performance traces, network waterfall, memory) |
+
+- Prefer Playwright for repeatable E2E tests (deterministic, headless-capable).
+- Use Claude in Chrome when the test requires an existing authenticated session.
+- Use DevTools MCP for performance profiling and network analysis, not functional tests.
+
 ## After Every Change
 
 - Run the test suite, report results, fix failures before continuing.
diff --git a/.claude/rules/18-preexisting-issues.md b/.claude/rules/18-preexisting-issues.md
new file mode 100644
index 0000000..f92363f
--- /dev/null
+++ b/.claude/rules/18-preexisting-issues.md
@@ -0,0 +1,12 @@
+# Preexisting Issues
+
+Never ignore problems you encounter in the codebase, even if they are outside the current task scope.
+
+## Rules
+
+- When you encounter a bug, lint error, type error, broken test, or code smell while working on a task, do not skip it.
+- If the fix is straightforward (under ~15 minutes of work), fix it in a separate commit with a clear message explaining what was wrong.
+- If the fix is complex (large refactor, architectural change, risk of regression), stop and inform the user: describe the issue, its severity, where it lives, and propose a plan to fix it. Do not attempt complex fixes without approval.
+- Never suppress warnings, disable lint rules, or add `// @ts-ignore` to hide preexisting issues. Surface them.
+- When fixing a preexisting issue, add a test that would have caught it if one does not already exist.
+- Track issues you cannot fix immediately: flag them to the user and, if Memora is available, create an issue memory.
diff --git a/.claude/rules/51-theme-integration.md b/.claude/rules/51-theme-integration.md
new file mode 100644
index 0000000..1869e5d
--- /dev/null
+++ b/.claude/rules/51-theme-integration.md
@@ -0,0 +1,17 @@
+# Theme Integration (CSS)
+
+All UI components MUST use the project's CSS custom properties for colors. Never hardcode color values.
+
+## Rules
+
+- **Backgrounds**: Use `var(--ctp-base)`, `var(--ctp-mantle)`, `var(--ctp-crust)`, `var(--ctp-surface0)`, `var(--ctp-surface1)`, `var(--ctp-surface2)`.
+- **Text**: Use `var(--ctp-text)`, `var(--ctp-subtext0)`, `var(--ctp-subtext1)`.
+- **Muted/overlay text**: Use `var(--ctp-overlay0)`, `var(--ctp-overlay1)`, `var(--ctp-overlay2)`.
+- **Accents**: Use `var(--ctp-blue)`, `var(--ctp-green)`, `var(--ctp-mauve)`, `var(--ctp-peach)`, `var(--ctp-pink)`, `var(--ctp-red)`, `var(--ctp-yellow)`, `var(--ctp-teal)`, `var(--ctp-sapphire)`, `var(--ctp-lavender)`, `var(--ctp-flamingo)`, `var(--ctp-rosewater)`, `var(--ctp-maroon)`, `var(--ctp-sky)`.
+- **Per-project accent**: Use `var(--accent)` which is set per ProjectBox slot.
+- **Borders**: Use `var(--ctp-surface0)` or `var(--ctp-surface1)`.
+- Never use raw hex/rgb/hsl color values in component CSS. All colors must go through `--ctp-*` variables.
+- Hover states: typically lighten by stepping up one surface level (e.g., surface0 -> surface1) or change text from subtext0 to text.
+- Active/selected states: use `var(--accent)` or a specific accent color with `var(--ctp-base)` background distinction.
+- Disabled states: reduce opacity (0.4-0.5) rather than introducing gray colors.
+- Use `color-mix()` for semi-transparent overlays: `color-mix(in srgb, var(--ctp-blue) 10%, transparent)`.
diff --git a/.claude/rules/52-no-implicit-push.md b/.claude/rules/52-no-implicit-push.md
new file mode 100644
index 0000000..3bc1ba9
--- /dev/null
+++ b/.claude/rules/52-no-implicit-push.md
@@ -0,0 +1,10 @@
+# No Implicit Push
+
+Never push to a remote repository unless the user explicitly asks for it.
+
+## Rules
+
+- Commits are local-only by default. Do not follow a commit with `git push`.
+- Only push when the user says "push", "push it", "push to remote", or similar explicit instruction.
+- When the user asks to "commit and push" in the same request, both are explicitly authorized.
+- Creating a PR (via `gh pr create`) implies pushing — that is acceptable.
diff --git a/.claude/rules/53-relative-units.md b/.claude/rules/53-relative-units.md
new file mode 100644
index 0000000..648dd35
--- /dev/null
+++ b/.claude/rules/53-relative-units.md
@@ -0,0 +1,17 @@
+# Relative Units (CSS)
+
+Use relative units (`em`, `rem`, `%`, `vh`, `vw`) for layout and spacing. Pixels are acceptable only for:
+
+- Icon sizes (`width`/`height` on `<svg>` or icon containers)
+- Borders and outlines (`1px solid ...`)
+- Box shadows
+
+## Rules
+
+- **Layout dimensions** (width, height, max-width, min-width): use `em`, `rem`, `%`, or viewport units.
+- **Padding and margin**: use `em` or `rem`.
+- **Font sizes**: use `rem` or `em`, never `px`.
+- **Gap, border-radius**: use `em` or `rem`.
+- **Media queries**: use `em`.
+- When existing code uses `px` for layout elements, convert to relative units as part of the change.
+- CSS custom properties for typography (`--ui-font-size`, `--term-font-size`) store `px` values because they feed into JS APIs (xterm.js) that require pixels. This is the only exception beyond icons/borders.
diff --git a/.claude/rules/54-testing-gate.md b/.claude/rules/54-testing-gate.md
new file mode 100644
index 0000000..c155759
--- /dev/null
+++ b/.claude/rules/54-testing-gate.md
@@ -0,0 +1,32 @@
+# Testing Gate (Post-Implementation)
+
+Run the full test suite after every major change before considering work complete.
+
+## What Counts as a Major Change
+
+- New feature or component
+- Refactoring that touches 3+ files
+- Store, adapter, or bridge modifications
+- Rust backend changes (commands, SQLite, sidecar)
+- Build or CI configuration changes
+
+## Required Command
+
+```bash
+cd v2 && npm run test:all
+```
+
+This runs vitest (frontend) + cargo test (backend). For changes touching E2E-relevant UI or interaction flows, also run:
+
+```bash
+cd v2 && npm run test:all:e2e
+```
+
+## Rules
+
+- Do NOT skip tests to save time. A broken test suite is a blocking issue.
+- If tests fail, fix them before moving on. Do not defer test fixes to a follow-up.
+- If a change breaks existing tests, that's signal — investigate whether the change or the test is wrong.
+- When adding new logic, add tests in the same commit (TDD preferred, see rule 06).
+- After fixing test failures, re-run the full suite to confirm no cascading breakage.
+- Report test results to the user: pass count, fail count, skip count.
diff --git a/.github/workflows/e2e.yml b/.github/workflows/e2e.yml
new file mode 100644
index 0000000..806e193
--- /dev/null
+++ b/.github/workflows/e2e.yml
@@ -0,0 +1,175 @@
+name: E2E Tests
+
+on:
+  push:
+    branches: [v2-mission-control]
+    paths:
+      - 'v2/src/**'
+      - 'v2/src-tauri/**'
+      - 'v2/bterminal-core/**'
+      - 'v2/tests/e2e/**'
+      - '.github/workflows/e2e.yml'
+  pull_request:
+    branches: [master, v2-mission-control]
+    paths:
+      - 'v2/src/**'
+      - 'v2/src-tauri/**'
+      - 'v2/bterminal-core/**'
+      - 'v2/tests/e2e/**'
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+env:
+  CARGO_TERM_COLOR: always
+
+jobs:
+  unit-tests:
+    runs-on: ubuntu-22.04
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: 20
+          cache: npm
+          cache-dependency-path: v2/package-lock.json
+
+      - name: Install npm dependencies
+        working-directory: v2
+        run: npm ci --legacy-peer-deps
+
+      - name: Run Vitest
+        working-directory: v2
+        run: npm run test
+
+  cargo-tests:
+    runs-on: ubuntu-22.04
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install system dependencies
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y \
+            libwebkit2gtk-4.1-dev \
+            libgtk-3-dev \
+            libayatana-appindicator3-dev \
+            librsvg2-dev \
+            libssl-dev \
+            build-essential \
+            pkg-config
+
+      - name: Setup Rust
+        uses: dtolnay/rust-toolchain@stable
+
+      - name: Cache Rust dependencies
+        uses: actions/cache@v4
+        with:
+          path: |
+            ~/.cargo/registry
+            ~/.cargo/git
+            v2/target
+          key: ${{ runner.os }}-cargo-test-${{ hashFiles('v2/Cargo.lock') }}
+          restore-keys: |
+            ${{ runner.os }}-cargo-test-
+
+      - name: Run cargo tests
+        working-directory: v2/src-tauri
+        run: cargo test
+
+  e2e-tests:
+    runs-on: ubuntu-22.04
+    needs: [unit-tests, cargo-tests]
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install system dependencies
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y \
+            libwebkit2gtk-4.1-dev \
+            libgtk-3-dev \
+            libayatana-appindicator3-dev \
+            librsvg2-dev \
+            libssl-dev \
+            build-essential \
+            pkg-config \
+            xvfb
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: 20
+          cache: npm
+          cache-dependency-path: v2/package-lock.json
+
+      - name: Setup Rust
+        uses: dtolnay/rust-toolchain@stable
+
+      - name: Cache Rust dependencies
+        uses: actions/cache@v4
+        with:
+          path: |
+            ~/.cargo/registry
+            ~/.cargo/git
+            v2/target
+          key: ${{ runner.os }}-cargo-e2e-${{ hashFiles('v2/Cargo.lock') }}
+          restore-keys: |
+            ${{ runner.os }}-cargo-e2e-
+
+      - name: Install tauri-driver
+        run: cargo install tauri-driver
+
+      - name: Install npm dependencies
+        working-directory: v2
+        run: npm ci --legacy-peer-deps
+
+      - name: Build debug binary
+        working-directory: v2
+        run: npx tauri build --debug --no-bundle
+
+      - name: Run E2E tests (Phase A — deterministic)
+        working-directory: v2
+        env:
+          BTERMINAL_TEST: '1'
+          SKIP_BUILD: '1'
+        run: |
+          xvfb-run --auto-servernum --server-args="-screen 0 1920x1080x24" \
+            npx wdio tests/e2e/wdio.conf.js \
+            --spec tests/e2e/specs/bterminal.test.ts \
+            --spec tests/e2e/specs/agent-scenarios.test.ts
+
+      - name: Run E2E tests (Phase B — multi-project)
+        if: success()
+        working-directory: v2
+        env:
+          BTERMINAL_TEST: '1'
+          SKIP_BUILD: '1'
+        run: |
+          xvfb-run --auto-servernum --server-args="-screen 0 1920x1080x24" \
+            npx wdio tests/e2e/wdio.conf.js \
+            --spec tests/e2e/specs/phase-b.test.ts
+
+      # LLM-judged tests only run when API key is available (manual/dispatch)
+      - name: Run E2E tests (Phase B — LLM-judged)
+        if: success() && env.ANTHROPIC_API_KEY != ''
+        working-directory: v2
+        env:
+          BTERMINAL_TEST: '1'
+          SKIP_BUILD: '1'
+          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
+        run: |
+          xvfb-run --auto-servernum --server-args="-screen 0 1920x1080x24" \
+            npx wdio tests/e2e/wdio.conf.js \
+            --spec tests/e2e/specs/phase-b.test.ts
+
+      - name: Upload test results
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: e2e-results
+          path: v2/test-results/
+          if-no-files-found: ignore
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
new file mode 100644
index 0000000..9541971
--- /dev/null
+++ b/.github/workflows/release.yml
@@ -0,0 +1,143 @@
+name: Release
+
+on:
+  push:
+    tags:
+      - "v*"
+
+permissions:
+  contents: write
+
+env:
+  CARGO_TERM_COLOR: always
+
+jobs:
+  build-linux:
+    runs-on: ubuntu-22.04
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install system dependencies
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y \
+            libwebkit2gtk-4.1-dev \
+            libgtk-3-dev \
+            libayatana-appindicator3-dev \
+            librsvg2-dev \
+            libssl-dev \
+            build-essential \
+            pkg-config \
+            curl \
+            wget \
+            libfuse2
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: 20
+          cache: npm
+          cache-dependency-path: v2/package-lock.json
+
+      - name: Setup Rust
+        uses: dtolnay/rust-toolchain@stable
+
+      - name: Cache Rust dependencies
+        uses: actions/cache@v4
+        with:
+          path: |
+            ~/.cargo/registry
+            ~/.cargo/git
+            v2/src-tauri/target
+          key: ${{ runner.os }}-cargo-${{ hashFiles('v2/src-tauri/Cargo.lock') }}
+          restore-keys: |
+            ${{ runner.os }}-cargo-
+
+      - name: Install npm dependencies
+        working-directory: v2
+        run: npm ci --legacy-peer-deps
+
+      - name: Build Tauri app
+        working-directory: v2
+        env:
+          TAURI_SIGNING_PRIVATE_KEY: ${{ secrets.TAURI_SIGNING_PRIVATE_KEY }}
+          TAURI_SIGNING_PRIVATE_KEY_PASSWORD: ${{ secrets.TAURI_SIGNING_PRIVATE_KEY_PASSWORD }}
+        run: npx tauri build
+
+      - name: List build artifacts
+        run: |
+          find v2/src-tauri/target/release/bundle -type f \( -name "*.deb" -o -name "*.AppImage" -o -name "*.sig" \) | head -20
+
+      - name: Generate updater latest.json
+        run: |
+          VERSION="${GITHUB_REF_NAME#v}"
+          DEB_NAME=$(basename v2/src-tauri/target/release/bundle/deb/*.deb)
+          APPIMAGE_NAME=$(basename v2/src-tauri/target/release/bundle/appimage/*.AppImage)
+          SIG=""
+          if [ -f "v2/src-tauri/target/release/bundle/appimage/${APPIMAGE_NAME}.sig" ]; then
+            SIG=$(cat "v2/src-tauri/target/release/bundle/appimage/${APPIMAGE_NAME}.sig")
+          fi
+          cat > latest.json << EOF
+          {
+            "version": "${VERSION}",
+            "notes": "Release ${VERSION}",
+            "pub_date": "$(date -u +%Y-%m-%dT%H:%M:%SZ)",
+            "platforms": {
+              "linux-x86_64": {
+                "signature": "${SIG}",
+                "url": "https://github.com/DexterFromLab/BTerminal/releases/download/${GITHUB_REF_NAME}/${APPIMAGE_NAME}"
+              }
+            }
+          }
+          EOF
+
+      - name: Upload .deb
+        uses: actions/upload-artifact@v4
+        with:
+          name: bterminal-deb
+          path: v2/src-tauri/target/release/bundle/deb/*.deb
+
+      - name: Upload AppImage
+        uses: actions/upload-artifact@v4
+        with:
+          name: bterminal-appimage
+          path: v2/src-tauri/target/release/bundle/appimage/*.AppImage
+
+      - name: Upload latest.json
+        uses: actions/upload-artifact@v4
+        with:
+          name: updater-json
+          path: latest.json
+
+  release:
+    needs: build-linux
+    runs-on: ubuntu-22.04
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Download .deb
+        uses: actions/download-artifact@v4
+        with:
+          name: bterminal-deb
+          path: artifacts/
+
+      - name: Download AppImage
+        uses: actions/download-artifact@v4
+        with:
+          name: bterminal-appimage
+          path: artifacts/
+
+      - name: Download latest.json
+        uses: actions/download-artifact@v4
+        with:
+          name: updater-json
+          path: artifacts/
+
+      - name: Create GitHub Release
+        uses: softprops/action-gh-release@v2
+        with:
+          generate_release_notes: true
+          files: |
+            artifacts/*.deb
+            artifacts/*.AppImage
+            artifacts/latest.json
diff --git a/.gitignore b/.gitignore
index 3b00cd9..cf49d61 100644
--- a/.gitignore
+++ b/.gitignore
@@ -2,3 +2,13 @@ __pycache__/
 *.pyc
 *.pyo
 /CLAUDE.md
+v2/target/
+debug/
+/plugins/
+/v2/plugins/
+projects/
+.playwright-mcp/
+.audit/
+.tribunal/
+.vscode/
+.local/
diff --git a/.gitmodules b/.gitmodules
new file mode 100644
index 0000000..ba2822f
--- /dev/null
+++ b/.gitmodules
@@ -0,0 +1,3 @@
+[submodule "agent-orchestrator"]
+	path = agent-orchestrator
+	url = git@github.com:DexterFromLab/agent-orchestrator.git
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 8955c0f..f873760 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -8,10 +8,493 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ## [Unreleased]
 
 ### Added
+- **Sidecar crash recovery/supervision** — `bterminal-core/src/supervisor.rs`: SidecarSupervisor wraps SidecarManager with auto-restart, exponential backoff (1s base, 30s cap, 5 retries), SidecarHealth enum (Healthy/Degraded/Failed), 5min stability window. 17 tests
+- **Notification system** — OS desktop notifications via `notify-rust` + in-app NotificationCenter.svelte (bell icon, unread badge, history max 100, 6 notification types). Agent dispatcher emits on complete/error/crash. notifications-bridge.ts adapter
+- **Secrets management** — `keyring` crate with linux-native (libsecret). SecretsManager in secrets.rs: store/get/delete/list with `__bterminal_keys__` metadata tracking. SettingsTab Secrets section. secrets-bridge.ts adapter. No plaintext fallback
+- **Keyboard-first UX** — Alt+1-5 project jump, Ctrl+H/L vi-nav, Ctrl+Shift+1-9 tab switch, Ctrl+J terminal toggle, Ctrl+Shift+K focus agent, Ctrl+Shift+F search overlay. `isEditing()` guard prevents conflicts. CommandPalette rewritten: 18+ commands, 6 categories, fuzzy filter, arrow nav, keyboard shortcuts overlay
+- **Agent health monitoring** — heartbeats table + dead_letter_queue table in btmsg.db. 15s heartbeat polling in ProjectBox. Stale detection (5min threshold). ProjectHeader heart indicator (green/yellow/red). StatusBar health badge
+- **FTS5 full-text search** — rusqlite upgraded to `bundled-full`. SearchDb with 3 FTS5 virtual tables (search_messages, search_tasks, search_btmsg). SearchOverlay.svelte: Spotlight-style Ctrl+Shift+F overlay, 300ms debounce, grouped results with FTS5 highlight snippets
+- **Plugin system** — `~/.config/bterminal/plugins/` with plugin.json manifest. plugins.rs: discovery, path-traversal-safe file reading, permission validation. plugin-host.ts: sandboxed `new Function()` execution, permission-gated API (palette, btmsg:read, bttask:read, events). plugins.svelte.ts store. SettingsTab plugins section. Example hello plugin
+- **Landlock sandbox** — `bterminal-core/src/sandbox.rs`: SandboxConfig with RW/RO paths, applied via `pre_exec()` in sidecar child process. Requires kernel 6.2+ (graceful fallback). Per-project toggle in SettingsTab
+- **Error classification** — `error-classifier.ts`: classifyApiError() with 6 types (rate_limit, auth, quota, overloaded, network, unknown), actionable messages, retry delays. 20 tests
+- **Audit log** — audit_log table in btmsg.db. AuditLogTab.svelte: Manager-only tab, filter by type+agent, 5s auto-refresh. audit-bridge.ts adapter. Events: agent_start/stop/error, task changes, wake events, prompt injection
+- **Usage meter** — UsageMeter.svelte: compact inline cost/token meter with color thresholds (50/75/90%), hover tooltip. Integrated in AgentPane cost bar
+- **Team agent orchestration** — install_cli_tools() copies btmsg/bttask to ~/.local/bin on startup. register_agents_from_groups() with bidirectional contacts. ensure_review_channels_for_group() creates #review-queue/#review-log per group
+- **Optimistic locking for bttask** — `version` column in tasks table. `WHERE id=? AND version=?` in update_task_status(). Conflict detection in TaskBoardTab. Both Rust + Python CLI updated
+- **Unified test runner** — `v2/scripts/test-all.sh` runs vitest + cargo tests with optional E2E (`--e2e` flag). npm scripts: `test:all`, `test:all:e2e`, `test:cargo`. Summary output with color-coded pass/fail
+- **Testing gate rule** — `.claude/rules/20-testing-gate.md` requires running full test suite after every major change (new features, refactors touching 3+ files, store/adapter/bridge/backend changes)
+- **E2E test mode infrastructure** — `BTERMINAL_TEST=1` env var disables file watchers (watcher.rs, fs_watcher.rs), wake scheduler, and allows data/config dir overrides via `BTERMINAL_TEST_DATA_DIR`/`BTERMINAL_TEST_CONFIG_DIR`. New `is_test_mode` Tauri command bridges test state to frontend
+- **E2E data-testid attributes** — Stable test selectors on 7 key Svelte components: AgentPane (agent-pane, data-agent-status, agent-messages, agent-stop, agent-prompt, agent-submit), ProjectBox (project-box, data-project-id, project-tabs, terminal-toggle), StatusBar, AgentSession, GlobalTabBar, CommandPalette, TerminalTabs
+- **E2E Phase A scenarios** — 7 human-authored test scenarios (22 tests) in `agent-scenarios.test.ts`: app structural integrity, settings panel, agent pane initial state, terminal tab management, command palette, project focus/tab switching, agent prompt submission (graceful Claude CLI skip)
+- **E2E test fixtures** — `tests/e2e/fixtures.ts`: creates isolated temp environments with data/config dirs, git repos, and groups.json. `createTestFixture()`, `createMultiProjectFixture()`, `destroyTestFixture()`
+- **E2E results store** — `tests/e2e/results-db.ts`: JSON-based test run/step tracking (pivoted from better-sqlite3 due to Node 25 native compile failure)
+- **E2E Phase B scenarios** — 6 multi-project + LLM-judged test scenarios in `phase-b.test.ts`: multi-project grid rendering, independent tab switching, status bar fleet state, LLM-judged agent response quality, LLM-judged code generation, context tab verification
+- **LLM judge helper** — `tests/e2e/llm-judge.ts`: dual-mode judge (CLI first, API fallback). CLI backend spawns `claude` with `--output-format text` (unsets CLAUDECODE). API backend uses raw fetch to Anthropic. Backend selectable via `LLM_JUDGE_BACKEND` env var. Structured verdicts (pass/fail + reasoning + confidence), `assertWithJudge()` with configurable min confidence threshold
+- **E2E testing documentation** — `docs/e2e-testing.md`: comprehensive guide covering all 3 pillars (test fixtures, test mode, LLM judge), spec phases A-C, CI integration, WebKit2GTK pitfalls, troubleshooting
+- **E2E CI workflow** — `.github/workflows/e2e.yml`: 3 jobs (vitest, cargo, e2e), xvfb-run for headless WebKit2GTK, path-filtered triggers on v2 source changes, LLM-judged tests gated on `ANTHROPIC_API_KEY` secret availability
+
+### Fixed
+- **E2E fixture env propagation** — `tauri:options.env` does not reliably set process-level env vars for Rust `std::env::var()`. Added `process.env` injection at module scope in wdio.conf.js so fixture groups.json is loaded instead of real user config
+- **LLM judge CLI context pollution** — Claude CLI loaded project CLAUDE.md files causing model to refuse JSON output. Fixed by running judge from `cwd: /tmp` with `--setting-sources user` and `--system-prompt` flags
+- **E2E mocha timeout** — Increased global mocha timeout from 60s to 180s. Agent-running tests (B4/B5) need 120s+ for Claude CLI round-trip
+- **E2E test suite — 27 failures fixed** across 3 spec files: bterminal.test.ts (22 — stale v2 CSS selectors, v3 tab order/count, JS-dispatched KeyboardEvent for Ctrl+K, idempotent palette open/close, backdrop click close, scrollIntoView for below-fold settings, scoped theme dropdown selectors), agent-scenarios.test.ts (3 — JS click for settings button, programmatic focus check, graceful 40s agent timeout with skip), phase-b.test.ts (2 — waitUntil for project box render, conditional null handling for burn-rate/cost elements). 82 E2E passing, 0 failing, 4 skipped
+- **AgentPane.svelte missing closing `>`** — div tag with data-testid attributes was missing closing angle bracket, causing template parse issues
+
+### Changed
+- **WebDriverIO config** — TCP readiness probe replaces blind 2s sleep for tauri-driver startup (200ms interval, 10s deadline). Added BTERMINAL_TEST=1 passthrough in capabilities
+
+### Security
+- `claude_read_skill` path traversal: added `canonicalize()` + `starts_with()` validation to prevent reading arbitrary files via crafted skill paths (commands/claude.rs)
+- **Sidecar env allowlist hardening** — added `ANTHROPIC_*` to Rust-level `strip_provider_env_var()` as defense-in-depth (Claude CLI uses credentials file, not env for auth). Dual-layer stripping documented: Rust layer (first checkpoint) + JS runner layer (per-provider)
+- **Plugin sandbox hardening** — 13 shadowed globals in `new Function()` sandbox (window, document, fetch, globalThis, self, XMLHttpRequest, WebSocket, Function, importScripts, require, process, Deno, __TAURI__, __TAURI_INTERNALS__). `this` bound to undefined via `.call()`. 35 tests covering all shadows, permissions, and lifecycle. Known escape vectors documented in JSDoc
+- **WAL checkpoint** — periodic `PRAGMA wal_checkpoint(TRUNCATE)` every 5 minutes on sessions.db + btmsg.db to prevent unbounded WAL growth under sustained multi-agent load. 2 tests
+- **TLS support for bterminal-relay** — optional `--tls-cert` and `--tls-key` CLI args. Server wraps TCP streams with native-tls. Client already supports `wss://` URLs. Generic handler refactor avoids code duplication
+- **Landlock fallback logging** — improved warning message with kernel version requirement (6.2+) and documented 3 enforcement states
+
+### Fixed
+- **btmsg.rs column index mismatch** — `get_agents()` used `SELECT a.*` with positional index 7 for `status`, but column 7 is actually `system_prompt`. Converted all query functions in btmsg.rs and bttask.rs from positional to named column access (`row.get("column_name")`). Added SQL aliases for JOIN columns
+- **btmsg-bridge.ts camelCase mismatch** — `BtmsgAgent` and `BtmsgMessage` TypeScript interfaces used snake_case fields (`group_id`, `unread_count`, `from_agent`) but Rust `#[serde(rename_all = "camelCase")]` sends camelCase. Fixed interfaces + all consumers (CommsTab.svelte)
+- **GroupAgentsPanel event propagation** — toggleAgent button click propagated to parent card click handler (`setActiveProject`). Added `e.stopPropagation()`
+- **ArchitectureTab PlantUML encoding** — `rawDeflate()` was a no-op, `encode64()` did hex encoding. Collapsed into single `plantumlEncode()` using PlantUML's `~h` hex encoding
+- **TestingTab Tauri 2.x asset URL** — used `asset://localhost/` (Tauri 1.x). Fixed to `convertFileSrc()` from `@tauri-apps/api/core`
+- **Reconnect loop race in RemoteManager** — orphaned reconnect tasks continued running after `remove_machine()` or `disconnect()`. Added `cancelled: Arc<AtomicBool>` flag to `RemoteMachine`; set on removal/disconnect, checked each reconnect iteration. `connect()` resets flag for new connections (remote.rs)
+- **Subagent delegation not triggering** — Manager system prompt had no documentation of Agent tool / delegation capability. Added "Multi-Agent Delegation" section with usage examples and guidelines. Also inject `CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1` env var for Manager agents
+- **Gitignore ignoring source code** — root `.gitignore` `plugins/` rule matched `v2/src/lib/plugins/` (source code). Narrowed to `/plugins/` and `/v2/plugins/` (runtime dirs only)
+
+### Added
+- **Reviewer agent role** — Tier 1 specialist with reviewer workflow in `agent-prompts.ts` (8-step process: inbox → review-queue → analyze → verdict → status update → review-log → report). Rust `bttask.rs` auto-posts to `#review-queue` btmsg channel on task→review transition via `notify_review_channel()` + `ensure_review_channels()` (idempotent). `reviewQueueDepth` in `attention-scorer.ts` (10pts/task, cap 50). `review_queue_count()` Rust function + Tauri command + `reviewQueueCount()` IPC bridge. ProjectBox: 'Tasks' tab for reviewer (reuses TaskBoardTab), 10s review queue polling → `setReviewQueueDepth()` in health store. 7 new vitest + 4 new cargo tests. 388 vitest + 76 cargo total
+- **Auto-wake Manager scheduler** — `wake-scheduler.svelte.ts` + `wake-scorer.ts` with 3 user-selectable strategies: persistent (Manager stays running, resume prompt with fleet context), on-demand (fresh session per wake), smart (threshold-gated on-demand, default). 6 wake signals from tribunal S-3 hybrid: AttentionSpike(1.0), ContextPressureCluster(0.9), BurnRateAnomaly(0.8), TaskQueuePressure(0.7), ReviewBacklog(0.6), PeriodicFloor(0.1). Settings UI: strategy segmented button + threshold slider in Manager agent cards. `GroupAgentConfig` extended with `wakeStrategy` + `wakeThreshold` fields. 24 tests in wake-scorer.test.ts. 381 vitest + 72 cargo total
+- **Dashboard metrics panel** — `MetricsPanel.svelte` new ProjectBox tab ('metrics', PERSISTED-LAZY, all projects). Live view: fleet aggregates (running/idle/stalled + burn rate), project health grid (status, burn rate, context %, idle, tokens, cost, turns, model, conflicts, attention), task board summary (5 kanban columns polled every 10s), cross-project attention queue. History view: 5 switchable SVG sparkline charts (cost/tokens/turns/tools/duration) with area fill, stats row (last/avg/max/min), recent sessions table. 25 tests in MetricsPanel.test.ts. 357 vitest + 72 cargo total
+
+### Changed
+- **Branded types for GroupId/AgentId (SOLID Phase 3b)** — Extended `types/ids.ts` with GroupId and AgentId branded types. Applied to ~40 sites: groups.ts interfaces (ProjectConfig.id, GroupConfig.id, GroupAgentConfig.id, GroupsFile.activeGroupId), btmsg-bridge.ts (5 interfaces, 15 function params), bttask-bridge.ts (Task/TaskComment, 6 params), groups-bridge.ts (AgentMessageRecord, ProjectAgentState, SessionMetric), 3 Svelte components (GroupAgentsPanel, TaskBoardTab, SettingsTab). agentToProject() uses `as unknown as ProjectId` cast for domain crossing. 12 tests in ids.test.ts. 332 vitest + 72 cargo total
+- **Branded types for SessionId/ProjectId (SOLID Phase 3)** — `types/ids.ts` with compile-time branded types (`string & { __brand }`) and factory functions. Applied to ~140 sites across 11 files: Map/Set keys in conflicts.svelte.ts (4 maps), health.svelte.ts (2 maps), session-persistence.ts (3 maps), function signatures across 6 files, boundary branding at sidecar entry in agent-dispatcher.ts, Svelte component call sites in AgentSession/ProjectBox/ProjectHeader. 293 vitest + 49 cargo total
+- **agent-dispatcher.ts split (SOLID Phase 2)** — 496→260 lines. Extracted 4 modules: `utils/worktree-detection.ts` (pure function), `utils/session-persistence.ts` (session maps + persist), `utils/auto-anchoring.ts` (compaction anchor), `utils/subagent-router.ts` (spawn + route). Dispatcher is now a thin coordinator
+- **session.rs split (SOLID Phase 2)** — 1008-line monolith split into 7 sub-modules under `session/` directory: mod.rs (struct + migrate), sessions.rs, layout.rs, settings.rs, ssh.rs, agents.rs, metrics.rs, anchors.rs. `pub(in crate::session)` conn visibility. 21 new cargo tests
+- **lib.rs command module split** — 976-line monolith with 48 Tauri commands split into 11 domain modules under `src-tauri/src/commands/` (pty, agent, watcher, session, persistence, knowledge, claude, groups, files, remote, misc). lib.rs reduced to ~170 lines (AppState + setup + handler registration)
+- **Attention scorer extraction** — `scoreAttention()` pure function extracted from inline health store code to `utils/attention-scorer.ts` with 14 tests. Priority chain: stalled > error > context critical > file conflict > context high
+- **Shared type guards** — deduplicated `str()`/`num()` runtime guards from claude-messages.ts, codex-messages.ts, ollama-messages.ts into shared `utils/type-guards.ts`
+- **btmsg/bttask WAL mode** — added SQLite WAL journal mode + 5s busy_timeout to both `btmsg.rs` and `bttask.rs` `open_db()` for safe concurrent access from Python CLIs + Rust backend
+
+### Added
+- **Regression tests for btmsg/bttask bug fixes** — 49 new tests: btmsg.rs (8, in-memory SQLite with named column access regression for status vs system_prompt), bttask.rs (7, named column access + serde camelCase), sidecar strip_provider_env_var (8, all prefix combinations), btmsg-bridge.test.ts (17, camelCase fields + IPC commands), bttask-bridge.test.ts (10, camelCase + IPC), plantuml-encode.test.ts (7, hex encoding algorithm). Total: 327 vitest + 72 cargo
+- **Configurable stall threshold** — per-project range slider (5–60 min, step 5) in SettingsTab. `stallThresholdMin` in `ProjectConfig` (groups.json), `setStallThreshold()` API in health store with `stallThresholds` Map and `DEFAULT_STALL_THRESHOLD_MS` fallback. ProjectBox `$effect` syncs config → store on mount/change
+- **Memora adapter** — `MemoraAdapter` (memora-bridge.ts) implements `MemoryAdapter` interface, bridging to Memora's SQLite database (`~/.local/share/memora/memories.db`) via read-only Rust backend (`memora.rs`). FTS5 text search, tag filtering via `json_each()`. 4 Tauri commands (memora_available, memora_list, memora_search, memora_get). Registered in App.svelte onMount. 16 vitest + 7 cargo tests. MemoriesTab now shows Memora memories on startup
+- **Codex provider runner** — `sidecar/codex-runner.ts` wraps `@openai/codex-sdk` (dynamic import, graceful failure if not installed). Maps Codex ThreadEvents (agent_message, reasoning, command_execution, file_change, mcp_tool_call, web_search) to common AgentMessage format via `codex-messages.ts` adapter. Sandbox/approval mode mapping from BTerminal permission modes. Session resume via thread ID. `providers/codex.ts` ProviderMeta (gpt-5.4 default, hasSandbox, supportsResume). 19 adapter tests
+- **Ollama provider runner** — `sidecar/ollama-runner.ts` uses direct HTTP to `localhost:11434/api/chat` with NDJSON streaming (zero external dependencies). Health check before session start. Configurable host/model/num_ctx/think via providerConfig. Supports Qwen3 extended thinking. `ollama-messages.ts` adapter maps streaming chunks to AgentMessage (text, thinking, cost with token counts). `providers/ollama.ts` ProviderMeta (qwen3:8b default, modelSelection only). 11 adapter tests
+- All 3 providers registered in App.svelte onMount + message-adapters.ts. `build:sidecar` builds all 3 runners
+- **S-1 Phase 3: Worktree isolation per project** — per-project `useWorktrees` toggle in SettingsTab. When enabled, agents run in git worktrees at `<repo>/.claude/worktrees/<sessionId>/` via SDK `extraArgs: { worktree: sessionId }`. CWD-based worktree detection in agent-dispatcher (`detectWorktreeFromCwd()`) matches `.claude/`, `.codex/`, `.cursor/` worktree patterns on init events. Dual detection: CWD-based (primary) + tool_call-based (subagent fallback). 8 files, +125 lines, 7 new tests. 226 vitest + 42 cargo tests
+- **S-2 Session Anchors** — preserves important conversation turns through context compaction chains. Auto-anchors first 3 turns with observation masking (reasoning preserved in full per research). Manual pin button on AgentPane text messages. Three anchor types: auto (re-injectable), pinned (display-only), promoted (user-promoted, re-injectable). Re-injection via `system_prompt` field. ContextTab anchor section with budget meter bar, per-anchor promote/demote/remove actions. SQLite `session_anchors` table with 5 CRUD commands. 5 new files, 7 modified. 219 vitest + 42 cargo tests
+- **Configurable anchor budget scale** — `AnchorBudgetScale` type with 4 presets: Small (2K), Medium (6K, default), Large (12K), Full (20K). Per-project 4-stop range slider in SettingsTab. `ProjectConfig.anchorBudgetScale` persisted in groups.json. ContextTab budget meter derives from project setting. agent-dispatcher resolves scale on auto-anchor
+- **Agent provider adapter pattern** — full implementation (3 phases complete): core abstraction layer (provider types/registry/capabilities, message adapter registry, 4 file renames), Settings UI (collapsible per-provider config panels, per-project provider dropdown, settings persistence), sidecar routing (provider-based runner selection, env var stripping for CLAUDE*/CODEX*/OLLAMA*). 5 new files, 4 renames, 20+ modified. 6 architecture decisions (PA-1–PA-6). Docs at `docs/provider-adapter/`
+- **PDF viewer** in Files tab: `PdfViewer.svelte` using pdfjs-dist (v5.5.207). Canvas-based multi-page rendering, zoom controls (0.5x–3x, 25% steps), HiDPI-aware via devicePixelRatio. Reads PDF via `convertFileSrc()` — no new Rust commands needed
+- **CSV table view** in Files tab: `CsvTable.svelte` with RFC 4180 CSV parser (no external dependency). Auto-detects delimiter (comma, semicolon, tab). Sortable columns (numeric-aware), sticky header, row numbers, text truncation at 20rem
+- FilesTab routing update: Binary+pdf → PdfViewer, Text+csv → CsvTable. Updated file icons (📕 PDF, 📊 CSV)
+- **S-1 Phase 2: Filesystem write detection** — inotify-based real-time file change detection via `ProjectFsWatcher` (fs_watcher.rs). Watches project CWDs recursively, filters .git/node_modules/target, debounces 100ms per-file (fs_watcher.rs, lib.rs)
+- External write conflict detection: timing heuristic (2s grace window) distinguishes agent writes from external edits. `EXTERNAL_SESSION_ID` sentinel, `recordExternalWrite()`, `getExternalConflictCount()`, `FileConflict.isExternal` flag (conflicts.svelte.ts)
+- Separate external write badge (orange ⚡) and agent conflict badge (red ⚠) in ProjectHeader (ProjectHeader.svelte)
+- `externalConflictCount` in ProjectHealth interface with attention scoring integration (health.svelte.ts)
+- Frontend bridge for filesystem watcher: `fsWatchProject()`, `fsUnwatchProject()`, `onFsWriteDetected()`, `fsWatcherStatus()` (fs-watcher-bridge.ts)
+- Inotify watch limit sensing: `FsWatcherStatus` reads `/proc/sys/fs/inotify/max_user_watches`, counts watched directories per project, warns at >75% usage with shell command to increase limit (fs_watcher.rs, lib.rs, ProjectBox.svelte)
+- Delayed scanning toast: "Scanning project directories…" info toast shown only when inotify status check takes >300ms, auto-dismissed on completion (ProjectBox.svelte)
+- `notify()` returns toast ID (was void) to enable dismissing specific toasts via `dismissNotification(id)` (notifications.svelte.ts)
+- ProjectBox `$effect` starts/stops fs watcher per project CWD on mount/unmount with toast on new external conflict + inotify capacity check (ProjectBox.svelte)
+- Collapsible text messages in AgentPane: model responses wrapped in `<details open>` (open by default, user-collapsible with first-line preview) (AgentPane.svelte)
+- Collapsible cost summary in AgentPane: `cost.result` wrapped in `<details>` (collapsed by default, expandable with 80-char preview) (AgentPane.svelte)
+- Project max aspect ratio setting: `project_max_aspect` (float 0.3–3.0, default 1.0) limits project box width via CSS `max-width: calc(100vh * var(--project-max-aspect))` (SettingsTab.svelte, ProjectGrid.svelte, App.svelte)
+- No-implicit-push rule: `.claude/rules/52-no-implicit-push.md` — never push unless user explicitly asks
+- `StartupWMClass=bterminal` in install-v2.sh .desktop template for GNOME auto-move extension compatibility
+- MarkdownPane link navigation: relative file links open in Files tab, external URLs open in system browser via `xdg-open`, anchor links scroll in-page (MarkdownPane.svelte, ProjectFiles.svelte, lib.rs)
+- `open_url` Tauri command for opening http/https URLs in system browser (lib.rs)
+- Tab system overhaul: renamed Claude→Model, Files→Docs, added 3 new tabs (Files, SSH, Memory) with PERSISTED-EAGER/LAZY mount strategies (ProjectBox.svelte)
+- FilesTab: VSCode-style directory tree sidebar + tabbed content viewer with shiki syntax highlighting, word wrap, image display via convertFileSrc, 10MB file size gate, collapsible/resizable sidebar, preview vs pinned tabs (FilesTab.svelte)
+- CodeEditor: CodeMirror 6 editor component with Catppuccin theme (reads --ctp-* CSS vars), 15 lazy-loaded language modes, auto-close brackets, bracket matching, code folding, line numbers, search, line wrapping, Ctrl+S save binding, blur event (CodeEditor.svelte)
+- FilesTab editor mode: files are now editable with dirty dot indicator on tabs, (unsaved) label in path bar, Ctrl+S save, auto-save dirty tabs on close (FilesTab.svelte)
+- Rust `write_file_content` command: writes content to existing files only — safety check prevents creating new files (lib.rs)
+- Save-on-blur setting: `files_save_on_blur` toggle in Settings → Defaults → Editor, auto-saves files when editor loses focus (SettingsTab.svelte, FilesTab.svelte)
+- SshTab: SSH connection CRUD panel with launch-to-terminal button, reuses existing ssh-bridge.ts model (SshTab.svelte)
+- MemoriesTab: pluggable knowledge explorer with MemoryAdapter interface, adapter registry, search, tag display, expandable cards (MemoriesTab.svelte, memory-adapter.ts)
+- Rust `list_directory_children` command: lazy tree expansion, hidden files skipped, dirs-first alphabetical sort (lib.rs)
+- Rust `read_file_content` command: FileContent tagged union (Text/Binary/TooLarge), 30+ language mappings (lib.rs)
+- Frontend `files-bridge.ts` adapter: DirEntry and FileContent TypeScript types + IPC wrappers
+- ContextTab: LLM context window visualization with stats bar (tokens, cost, turns, duration), segmented token meter (color-coded by message type), file references tree (extracted from tool calls), and collapsible turn breakdown — replaces old ContextPane ctx database viewer (ContextTab.svelte)
+- ContextTab AST view: per-turn SVG conversation trees showing hierarchical message flow (Turn → Thinking/Response/Tool Calls → File operations), with bezier edges, color-coded nodes, token counts, and detail tooltips (ContextTab.svelte)
+- ContextTab Graph view: bipartite tool→file DAG with tools on left (color-coded by type) and files on right, curved SVG edges showing which tools touched which files, count badges on both sides (ContextTab.svelte)
+- Compaction event detection: `compact_boundary` SDK messages adapted to `CompactionContent` type in sdk-messages.ts, ContextTab shows yellow compaction count pill in stats bar and red boundary nodes in AST view
+- Project health store: per-project activity state (running/idle/stalled), burn rate ($/hr EMA), context pressure (% of model limit), attention scoring with urgency weights (health.svelte.ts)
+- Mission Control status bar: running/idle/stalled agent counts, total $/hr burn rate, "needs attention" dropdown priority queue with click-to-focus cards (StatusBar.svelte)
+- ProjectHeader health indicators: color-coded status dot (green=running, orange=stalled), context pressure badge, burn rate badge (ProjectHeader.svelte)
+- Session metrics SQLite table: per-project historical metrics with 100-row retention, `session_metric_save` and `session_metrics_load` Tauri commands (session.rs, lib.rs)
+- Session metric persistence on agent completion: records peak tokens, turn count, tool call count, cost, model, status (agent-dispatcher.ts)
+- File overlap conflict detection store: per-project tracking of Write/Edit tool file paths across agent sessions, detects when 2+ sessions write same file, SCORE_FILE_CONFLICT=70 attention signal (conflicts.svelte.ts)
+- Shared tool-files utility: extractFilePaths() and extractWritePaths() extracted from ContextTab to reusable module (tool-files.ts)
+- File conflict indicators: red "⚠ N conflicts" badge in ProjectHeader, conflict count in StatusBar, toast notification on new conflict, conflict cards in attention queue (ProjectHeader.svelte, StatusBar.svelte)
+- Health tick auto-stop/auto-start: tick timer self-stops when no running/starting sessions, auto-restarts on recordActivity() (health.svelte.ts)
+- Bash write detection in tool-files.ts: BASH_WRITE_PATTERNS regex array covering >, >>, sed -i, tee, cp, mv, chmod/chown — conflict detection now catches shell-based file writes (tool-files.ts)
+- Worktree-aware conflict suppression: sessions in different git worktrees don't trigger conflicts, sessionWorktrees tracking map, setSessionWorktree() API, extractWorktreePath() detects Agent/Task isolation:"worktree" and EnterWorktree tool calls (conflicts.svelte.ts, tool-files.ts, agent-dispatcher.ts)
+- Acknowledge/dismiss conflicts: acknowledgeConflicts(projectId) suppresses badge until new session writes, acknowledgedFiles state map, auto-clear on new session write to acknowledged file (conflicts.svelte.ts)
+- Clickable conflict badge in ProjectHeader: red button with ✕ calls acknowledgeConflicts() on click with stopPropagation, hover darkens background (ProjectHeader.svelte)
+- `useWorktrees` optional boolean field on ProjectConfig for future per-project worktree spawning setting (groups.ts)
+
+### Changed
+- Anchor observation masking no longer truncates assistant reasoning text (was 500 chars) — reasoning is preserved in full per research consensus (JetBrains NeurIPS 2025, SWE-agent, OpenDev ACC); only tool outputs are compacted (anchor-serializer.ts)
+- `getAnchorSettings()` now accepts optional `AnchorBudgetScale` parameter to resolve budget from per-project scale setting (anchors.svelte.ts)
+- ContextTab now derives anchor budget from `anchorBudgetScale` prop via `ANCHOR_BUDGET_SCALE_MAP` instead of hardcoded `DEFAULT_ANCHOR_SETTINGS` (ContextTab.svelte)
+- Renamed `sdk-messages.ts` → `claude-messages.ts`, `agent-runner.ts` → `claude-runner.ts`, `ClaudeSession.svelte` → `AgentSession.svelte` — provider-neutral naming for multi-provider support
+- `agent-dispatcher.ts` now uses `adaptMessage(provider, event)` from message-adapters.ts registry instead of directly calling `adaptSDKMessage` — enables per-provider message parsing
+- Rust `AgentQueryOptions` gained `provider` (String, defaults "claude") and `provider_config` (serde_json::Value) fields with serde defaults for backward compatibility
+- Rust `SidecarManager.resolve_sidecar_for_provider(provider)` looks for `{provider}-runner.mjs` instead of hardcoded `claude-runner.mjs`
+- Rust `strip_provider_env_var()` strips CLAUDE*/CODEX*/OLLAMA* env vars (whitelists CLAUDE_CODE_EXPERIMENTAL_*)
+- SettingsTab: added Providers section with collapsible per-provider config panels (enabled toggle, default model, capabilities display) and per-project provider dropdown
+- AgentPane: capability-driven rendering via ProviderCapabilities props (hasProfiles, hasSkills, supportsResume gates)
+- AgentPane UI redesign: sans-serif root font (system-ui), tool calls paired with results in collapsible `<details>` groups, hook messages collapsed into compact labels, context window usage meter in status strip, cost bar made minimal (no background), session summary with translucent background, two-phase scroll anchoring, tool-aware output truncation (Bash 500/Read 50/Glob 20 lines), colors softened via `color-mix()`, responsive margins via container queries (AgentPane.svelte)
+- MarkdownPane: added inner scroll wrapper with `container-type: inline-size`, responsive padding via shared `--bterminal-pane-padding-inline` variable (MarkdownPane.svelte)
+- Added `--bterminal-pane-padding-inline: clamp(0.75rem, 3.5cqi, 2rem)` shared CSS variable for responsive pane padding (catppuccin.css)
+
+### Fixed
+- FilesTab invalid HTML nesting: file tab bar used `<button>` inside `<button>` which Svelte/browser rejects — changed outer element to `<div role="tab">` (FilesTab.svelte)
+- FilesTab file content not rendering: after inserting a FileTab into the `$state` array, the local plain-object reference lost Svelte 5 proxy reactivity — content mutations were invisible. Fixed by looking up from the reactive array before setting content (FilesTab.svelte)
+- ClaudeSession type errors: cast `last_session_id` to UUID template literal type, add missing `timestamp` field (from `created_at`) to restored AgentMessage records (ClaudeSession.svelte)
+- Cost bar shows only last turn's cost instead of cumulative session total: `updateAgentCost()` changed from assignment to accumulation (`+=`) so continued sessions properly sum costs across all turns (agents.svelte.ts)
+- ProjectBox tab switch destroys running agent sessions: changed `{#if activeTab}` conditional rendering to CSS `style:display` (flex/none) for all three content panes and terminal section — ClaudeSession now stays mounted across tab switches, preserving session ID, message history, and running agents (ProjectBox.svelte)
+- Sidecar env var stripping now whitelists `CLAUDE_CODE_EXPERIMENTAL_*` vars (both Rust sidecar.rs and JS agent-runner.ts) — previously all `CLAUDE*` vars were stripped, blocking feature flags like agent teams from reaching the SDK (sidecar.rs, agent-runner.ts)
+- E2E terminal tab tests: scoped selectors to `.tab-bar .tab-title` (was `.tab-title` which matched project tabs), used `browser.execute()` for DOM text reads to avoid stale element issues (bterminal.test.ts)
+- E2E wdio.conf.js: added `wdio:enforceWebDriverClassic: true` to disable BiDi negotiation (wdio v9 injects `webSocketUrl:true` which tauri-driver rejects), removed unnecessary `browserName: 'wry'`, fixed binary path to Cargo workspace target dir (`v2/target/debug/` not `v2/src-tauri/target/debug/`)
+- E2E consolidated to single spec file: Tauri creates one app session per spec file; multiple files caused "invalid session id" on 2nd+ file (wdio.conf.js, bterminal.test.ts)
+- E2E WebDriver clicks on Svelte 5 components: `element.click()` doesn't reliably trigger onclick handlers inside complex components via WebKit2GTK/tauri-driver; replaced with `browser.execute()` JS-level clicks for .ptab, .dropdown-trigger, .panel-close (bterminal.test.ts)
+- Removed `tauri-plugin-log` entirely — `telemetry::init()` already registers tracing-subscriber which bridges the `log` crate; adding plugin-log after panics with "attempted to set a logger after the logging system was already initialized" (lib.rs, Cargo.toml)
+
+### Changed
+- E2E tests expanded from 6 smoke tests to 48 tests across 8 describe blocks: Smoke (6), Workspace & Projects (8), Settings Panel (6), Keyboard Shortcuts (5), Command Palette (5), Terminal Tabs (7), Theme Switching (3), Settings Interaction (8) — all in single bterminal.test.ts file
+- wdio.conf.js: added SKIP_BUILD env var to skip cargo tauri build when debug binary already exists
+
+### Removed
+- Ollama-specific warning toast from AgentPane when injecting anchors — replaced by generic configurable budget scale slider (AgentPane.svelte)
+- Unused `notify` import from AgentPane (AgentPane.svelte)
+- `tauri-plugin-log` dependency from Cargo.toml — redundant with telemetry::init() tracing-subscriber setup
+- Individual E2E spec files (smoke.test.ts, keyboard.test.ts, settings.test.ts, workspace.test.ts) — consolidated into bterminal.test.ts
+- Workspace teardown race: `switchGroup()` now awaits `waitForPendingPersistence()` before clearing agent state, preventing data loss when agents complete during group switch (agent-dispatcher.ts, workspace.svelte.ts)
+- SettingsTab switchGroup click handler made async with await to properly handle the async switchGroup() flow (SettingsTab.svelte)
+- Re-entrant sidecar exit handler race condition: added `restarting` guard flag preventing double-restart on rapid disconnect/reconnect (agent-dispatcher.ts)
+- Memory leak: `toolUseToChildPane` and `sessionProjectMap` maps now cleared in `stopAgentDispatcher()` (agent-dispatcher.ts)
+- Listener leak: 5 Tauri event listeners in machines store now tracked via `UnlistenFn[]` array with `destroyMachineListeners()` cleanup function (machines.svelte.ts)
+- Fragile abort detection: replaced `errMsg.includes('aborted')` with `controller.signal.aborted` for authoritative abort state check (agent-runner.ts)
+- Unhandled rejection: `handleMessage` made async with `.catch()` on `rl.on('line')` handler preventing sidecar crash on malformed input (agent-runner.ts)
+- Remote machine `add_machine`/`list_machines`/`remove_machine` converted from `try_lock()` (silent failure on contention) to async `.lock().await` (remote.rs)
+- `remove_machine` now aborts `WsConnection` tasks before removal, preventing resource leak (remote.rs)
+- `save_agent_messages` wrapped in `unchecked_transaction()` for atomic DELETE+INSERT, preventing partial writes on crash (session.rs)
+- Non-null assertion `msg.event!` replaced with safe check `if (msg.event)` in agent bridge event handler (agent-bridge.ts)
+- Runtime type guards (`str()`, `num()`) replace bare `as` casts on untrusted SDK wire format in sdk-messages.ts
+- ANTHROPIC_* environment variables now stripped alongside CLAUDE* in sidecar agent-runner.ts
+- Frontend persistence timestamps use `Math.floor(Date.now() / 1000)` matching Rust seconds convention (agent-dispatcher.ts)
+- Remote disconnect handler converted from `try_lock()` to async `.lock().await` (remote.rs)
+- `save_layout` pane_ids serialization error now propagated instead of silent fallback (session.rs)
+- ctx.rs Mutex::lock() returns Err instead of panicking on poisoned lock (5 occurrences)
+- ctx CLI: `int()` limit argument validated with try/except (ctx)
+- ctx CLI: FTS5 MATCH query wrapped in try/except for syntax errors (ctx)
+- File watcher: explicit error for root-level path instead of silent fallback (watcher.rs)
+- Agent bridge payload validated before cast to SidecarMessage (agent-bridge.ts)
+- Profile.toml and resource_dir failures now log::warn instead of silent empty fallback (lib.rs)
+
+### Changed
+- All ~100 px layout values converted to rem across 10 components per rule 18: AgentPane, ToastContainer, CommandPalette, SettingsTab, TeamAgentsPanel, AgentCard, StatusBar, AgentTree, TerminalPane, AgentPreviewPane (1rem = 16px base, icon/dot dimensions kept as px)
+
+### Added
+- E2E testing infrastructure: WebdriverIO v9.24 + tauri-driver setup with `wdio.conf.js` (lifecycle hooks for tauri-driver spawn/kill, debug binary build), 6 smoke tests (`smoke.test.ts`), TypeScript config, `test:e2e` npm script, 4 new devDeps (@wdio/cli, @wdio/local-runner, @wdio/mocha-framework, @wdio/spec-reporter)
+- `waitForPendingPersistence()` export in agent-dispatcher.ts: counter-based fence that resolves when all in-flight `persistSessionForProject()` calls complete
+- OpenTelemetry instrumentation: `telemetry.rs` module with TelemetryGuard (Drop-based shutdown), tracing + optional OTLP/HTTP export to Tempo, controlled by `BTERMINAL_OTLP_ENDPOINT` env var (absent = console-only fallback)
+- `#[tracing::instrument]` on 10 key Tauri commands: pty_spawn, pty_kill, agent_query, agent_stop, agent_restart, remote_connect, remote_disconnect, remote_agent_query, remote_agent_stop, remote_pty_spawn
+- `frontend_log` Tauri command: routes frontend telemetry events (level + message + context JSON) to Rust tracing layer with `source="frontend"` field
+- `telemetry-bridge.ts` adapter: `tel.info/warn/error/debug/trace()` convenience wrappers for frontend → Rust tracing bridge via IPC
+- Agent dispatcher telemetry: structured events for agent_started, agent_stopped, agent_error, sidecar_crashed, and agent_cost (with full metrics: costUsd, tokens, turns, duration)
+- Docker Tempo + Grafana stack (`docker/tempo/`): Tempo (OTLP gRPC 4317, HTTP 4318, query 3200) + Grafana (port 9715) with auto-provisioned Tempo datasource
+- 6 new Rust dependencies: tracing 0.1, tracing-subscriber 0.3, opentelemetry 0.28, opentelemetry_sdk 0.28, opentelemetry-otlp 0.28, tracing-opentelemetry 0.29
+- `ctx_register_project` Tauri command and `ctxRegisterProject()` bridge function: registers a project in the ctx database via `INSERT OR IGNORE` into sessions table; opens DB read-write briefly then closes
+- Agent preview terminal (`AgentPreviewPane.svelte`): read-only xterm.js terminal that subscribes to agent session messages in real-time; renders Bash commands as cyan `❯ command`, file operations as yellow `[Read/Write/Edit] path`, tool results (80-line truncation), text summaries, errors in red, session start/complete with cost; uses `disableStdin: true`, Canvas addon, theme hot-swap; spawned via 👁 button in TerminalTabs tab bar (appears when agent session is active); deduplicates — only one preview per session
+- `TerminalTab.type` extended with `'agent-preview'` variant and `agentSessionId?: string` field in workspace store
+- `ProjectBox` passes `mainSessionId` to `TerminalTabs` for agent preview tab creation
+- SettingsTab project settings card redesign: each project rendered as a polished card with icon picker (Svelte state-driven emoji grid popup), inline-editable name input, CWD with left-ellipsis (`direction: rtl`), account/profile dropdown (via `listProfiles()` from claude-bridge.ts), custom toggle switch (green track/thumb), and subtle remove footer with trash icon
+- Account/profile dropdown per project in SettingsTab: uses `listProfiles()` to fetch Claude profiles, displays display_name + email in dropdown, blue badge styling; falls back to static label when single profile
+- ProjectHeader profile badge: account name styled as blue pill with translucent background (`color-mix(in srgb, var(--ctp-blue) 10%, transparent)`), font-weight 600, expanded max-width to 8rem
+- Theme integration rule (`.claude/rules/51-theme-integration.md`): mandates all colors via `--ctp-*` CSS custom properties, never hardcode hex/rgb/hsl values
+- AgentPane VSCode-style prompt: unified input always at bottom with auto-resizing textarea, send icon button (arrow SVG) inside rounded container, welcome state with chat icon when no session
+- AgentPane session controls: New Session and Continue buttons shown after session completes, enabling explicit session management
+- ClaudeSession `handleNewSession()`: resets sessionId for fresh agent sessions, wired via `onExit` prop to AgentPane
+- ContextPane "Initialize Database" button: when ctx database doesn't exist, shows a prominent button to create `~/.claude-context/context.db` with full schema (sessions, contexts, shared, summaries + FTS5 + sync triggers) directly from the UI; replaces old "run ctx init" hint text; auto-loads data after successful init
+- Project-level tab bar in ProjectBox: Claude | Files | Context tabs switch the content area between ClaudeSession, ProjectFiles, and ContextPane
+- ProjectFiles.svelte: project-scoped markdown file viewer (file picker sidebar + MarkdownPane), accepts cwd/projectName props
+- ProjectHeader info bar: CWD path (ellipsized from start via `direction: rtl`) + profile name displayed as read-only info alongside project icon/name
+- Emoji icon picker in SettingsTab: 24 project-relevant emoji in 8-column grid popup, replaces plain text icon input
+- Native directory picker for CWD fields: custom `pick_directory` Tauri command using `rfd` crate with `set_parent(&window)` for modal behavior on Linux; browse buttons added to Default CWD, existing project CWD, and Add Project path inputs in SettingsTab
+- `rfd = { version = "0.16", default-features = false, features = ["gtk3"] }` direct dependency for modal file dialogs (zero extra compile — already built transitively via tauri-plugin-dialog)
+- CSS relative units rule (`.claude/rules/18-relative-units.md`): enforces rem/em for layout CSS, px only for icons/borders/shadows
+
+### Changed
+- ContextPane redesigned as project-scoped: now receives `projectName` + `projectCwd` props from ProjectBox; auto-registers project in ctx database on mount (`INSERT OR IGNORE`); removed project selector list — directly shows context entries, shared context, and session summaries for the current project; empty state shows `ctx set <project> <key> <value>` usage hint; all CSS converted to rem; header shows project name in accent color
+- Sidebar simplified to Settings-only: removed Sessions, Docs, Context icons from GlobalTabBar (project-specific tabs already in ProjectBox); removed DocsTab/ContextTab imports from App.svelte; removed Alt+1..4 keyboard shortcuts; drawer always renders SettingsTab
+- MarkdownPane file switching: replaced onMount-only `watchFile()` with reactive `$effect` that unwatches previous file and watches new one when `filePath` prop changes; added `highlighterReady` gate to prevent premature watches
+- MarkdownPane premium typography overhaul: font changed from `var(--ui-font-family)` (resolved to JetBrains Mono) to hardcoded `'Inter', system-ui, sans-serif` for proper prose rendering; added `text-rendering: optimizeLegibility`, `-webkit-font-smoothing: antialiased`, `font-feature-settings: 'cv01', 'cv02', 'cv03', 'cv04', 'ss01'` (Inter alternates); body color softened from `--ctp-text` to `--ctp-subtext1` for reduced dark-mode contrast; Tailwind-prose-inspired spacing (1.15-1.75em paragraph/heading margins); heading line-height tightened to 1.2-1.4 with negative letter-spacing on h1/h2; gradient HR (`linear-gradient` fading to transparent edges); link underlines use `text-decoration-color` transition (30% opacity → full on hover, VitePress pattern); blockquotes now italic with translucent bg; code blocks have inset `box-shadow` for depth; added h5 (uppercase small) and h6 styles; all colors via `--ctp-*` vars for 17-theme compatibility
+- ProjectBox terminal area: only visible on Claude tab, now collapsible — collapsed shows a status bar with chevron toggle, "Terminal" label, and tab count badge; expanded shows full 16rem TerminalTabs area. Default: collapsed. Grid rows: `auto auto 1fr auto`
+- SettingsTab project settings: flat row layout replaced with stacked card layout; icon picker rewritten from DOM `classList.toggle('visible')` to Svelte `$state` (iconPickerOpenFor); checkbox replaced with custom toggle switch component
+- SettingsTab CSS: all remaining px values in project section converted to rem; add-project form uses dashed border container
+- AgentPane prompt: replaced separate initial prompt + follow-up input with single unified prompt area; removed `followUpPrompt` state, `handleSubmit` function; follow-up handled via `isResume` detection in `handleUnifiedSubmit()`
+- AgentPane CSS: migrated all legacy CSS vars (`--bg-primary`, `--bg-surface`, `--text-primary`, `--text-secondary`, `--text-muted`, `--border`, `--accent`, `--font-mono`, `--border-radius`) to `--ctp-*` theme vars + rem units
+- ContextPane CSS: same legacy-to-theme var migration as AgentPane
+- ProjectBox tab CSS: polished with `margin-bottom: -1px` active tab trick (merges with content), `scrollbar-width: none`, `focus-visible` outline, hover with `var(--ctp-surface0)` background
+- ProjectBox layout: CSS grid with 4 rows (`auto auto 1fr auto`) — header | tab bar | content | terminal; content area switches by tab
+- AgentPane: removed DIR/ACC toolbar entirely — CWD and profile now passed as props from parent (set in Settings, shown in ProjectHeader); clean chat window with prompt + send button only
+- AgentPane prompt area: anchored to bottom (`justify-content: flex-end`) instead of vertical center, removed `max-width: 600px` constraint — uses full panel width
+- ClaudeSession passes `project.profile` to AgentPane for automatic profile resolution
+- ProjectGrid.svelte CSS converted from px to rem: gap 0.25rem, padding 0.25rem, min-width 30rem
+- TerminalTabs.svelte CSS converted from px to rem: tab bar, tabs, close/add buttons, empty state
+
+### Removed
+- Dead ctx code: `ContextTab.svelte` wrapper component, `CtxProject` struct (Rust), `list_projects()` method, `ctx_list_projects` Tauri command, `ctxListProjects()` bridge function, `CtxProject` TypeScript interface — all unused after ContextPane project-scoped redesign
+- Unused Python imports in `ctx` CLI: `os`, `datetime`/`timezone` modules
+- AgentPane session toolbar (DIR/ACC inputs) — CWD and profile are now props, not interactive inputs
+- Nerd Font codepoints for project icons — replaced with emoji (`📁` default) for cross-platform compatibility
+- Nerd Font `font-family` declarations from ProjectHeader and TerminalTabs
+- Stub `pick_directory` Tauri command (replaced by `tauri-plugin-dialog` frontend API)
+
+### Fixed
+- `ctx init` fails when `~/.claude-context/` directory doesn't exist: `get_db()` called `sqlite3.connect()` without creating the parent directory; added `DB_PATH.parent.mkdir(parents=True, exist_ok=True)` before connect
+- Terminal tabs cannot be closed and all named "Shell 1": `$state<Map<string, TerminalTab[]>>` in workspace store didn't trigger reactive updates for `$derived` consumers when `Map.set()` was called; changed `projectTerminals` from `Map` to `Record<string, TerminalTab[]>` (plain object property access is Svelte 5's strongest reactivity path)
+- SettingsTab icon picker not opening: replaced broken DOM `classList.toggle('visible')` approach with Svelte `$state` (`iconPickerOpenFor` keyed by project ID); icon picker now reliably opens/closes and dismisses on click-outside or Escape
+- SettingsTab CWD path truncated from right: added `direction: rtl; text-align: left; unicode-bidi: plaintext` on CWD input so path shows the end (project directory) instead of the beginning when truncated
+- Project icons showing "?" — Nerd Font codepoint `\uf120` not rendering without font installed; switched to emoji
+- Native directory picker not opening: added missing `"dialog:default"` permission to `v2/src-tauri/capabilities/default.json` — Tauri's IPC security layer silently blocked `invoke()` calls without this capability
+- Native directory picker not modal on Linux: replaced `@tauri-apps/plugin-dialog` `open()` with custom `pick_directory` Tauri command using `rfd::AsyncFileDialog::set_parent(&window)` — the plugin skips `set_parent` on Linux via `cfg(any(windows, target_os = "macos"))` gate
+- Native directory picker not dark-themed: set `GTK_THEME=Adwaita:dark` via `std::env::set_var` at Tauri startup to force dark theme on native GTK dialogs
+- Sidebar drawer not scaling to content width: removed leftover v2 grid layout on `#app` in `app.css` (`display: grid; grid-template-columns: var(--sidebar-width) 1fr` + media queries) that constrained `.app-shell` to 260px first column; v3 `.app-shell` manages its own flexbox layout internally
+- ContextPane.svelte CSS converted from px to rem: font-size, padding, margin, gap; added `white-space: nowrap` on `.ctx-header`/`.ctx-error` for intrinsic width measurement
+
+### Changed
+- GlobalTabBar.svelte CSS converted from px to rem: rail width 2.75rem, button 2rem, gap 0.25rem, padding 0.5rem 0.375rem, border-radius 0.375rem; rail-btn color changed from --ctp-overlay1 to --ctp-subtext0 for better contrast
+- App.svelte sidebar header CSS converted from px to rem: padding 0.5rem 0.75rem, close button 1.375rem, border-radius 0.25rem
+- App.svelte sidebar drawer: JS `$effect` measures content width via `requestAnimationFrame` + `querySelectorAll` for nowrap elements, headings, inputs, and tab-specific selectors; `panelWidth` state drives inline `style:width` on `aside.sidebar-panel`
+- Sidebar panel changed from fixed width (28em) to content-driven sizing with `min-width: 16em` and `max-width: 50%`; each tab component defines its own `min-width: 22em`
+- Sidebar panel and panel-content overflow changed from `hidden` to `overflow-y: auto` to allow content to drive parent width
+- SettingsTab.svelte padding converted from px to rem (0.75rem 1rem)
+- DocsTab.svelte converted from px to rem: file-picker 14em, picker-title/file-btn/empty padding in rem
+- ContextTab.svelte, DocsTab.svelte, SettingsTab.svelte all now set `min-width: 22em` for content-driven drawer sizing
+- UI redesigned from top tab bar + right-side settings drawer to VSCode-style left sidebar: vertical icon rail (GlobalTabBar, 2.75rem, 4 SVG icons) + expandable drawer panel (content-driven width) + always-visible main workspace (ProjectGrid)
+- GlobalTabBar rewritten from horizontal text tabs + gear icon to vertical icon rail with SVG icons for Sessions, Docs, Context, Settings; Props: `expanded`/`ontoggle` (was `settingsOpen`/`ontoggleSettings`)
+- Settings is now a regular sidebar tab (not a special right-side drawer); `WorkspaceTab` type: `'sessions' | 'docs' | 'context' | 'settings'`
+- App.svelte layout: `.main-row` flex container with icon rail + optional sidebar panel + workspace; state renamed `settingsOpen` -> `drawerOpen`
+- Keyboard shortcuts: Alt+1..4 (switch tabs + open drawer), Ctrl+B (toggle sidebar), Ctrl+, (toggle settings), Escape (close drawer)
+- SettingsTab CSS: `height: 100%` (was `flex: 1`) for sidebar panel context
+
+### Added
+- SettingsTab split font controls: separate UI font (sans-serif options: System Sans-Serif, Inter, Roboto, Open Sans, Lato, Noto Sans, Source Sans 3, IBM Plex Sans, Ubuntu) and Terminal font (monospace options: JetBrains Mono, Fira Code, Cascadia Code, Source Code Pro, IBM Plex Mono, Hack, Inconsolata, Ubuntu Mono, monospace), each with custom themed dropdown + size stepper (8-24px), font previews in own typeface
+- `--term-font-family` and `--term-font-size` CSS custom properties in catppuccin.css (defaults: JetBrains Mono fallback chain, 13px)
+- Deep Dark theme group: 6 new themes (Tokyo Night, Gruvbox Dark, Ayu Dark, Poimandres, Vesper, Midnight) — total 17 themes across 3 groups (Catppuccin, Editor, Deep Dark). Midnight is pure OLED black (#000000), Ayu Dark near-black (#0b0e14), Vesper warm dark (#101010)
+- Multi-theme system: 7 new editor themes (VSCode Dark+, Atom One Dark, Monokai, Dracula, Nord, Solarized Dark, GitHub Dark) alongside 4 Catppuccin flavors
+- `ThemeId` union type, `ThemePalette` (26-color interface), `ThemeMeta` (id/label/group/isDark), `THEME_LIST` registry with group metadata, `ALL_THEME_IDS` for validation
+- Theme store `getCurrentTheme()`/`setTheme()` as primary API; deprecated `getCurrentFlavor()`/`setFlavor()` wrappers for backwards compat
+- SettingsTab custom themed dropdown for theme selection: color swatches (base color per theme), 4 accent color dots (red/green/blue/yellow), grouped sections (Catppuccin/Editor/Deep Dark) with styled headers, click-outside and Escape to close
+- SettingsTab global settings section: theme selector, UI font dropdown (sans-serif options), Terminal font dropdown (monospace options), each with size stepper (8-24px), default shell input, default CWD input — all custom themed dropdowns (no native `<select>`), all persisted via settings-bridge
+- Typography CSS custom properties (`--ui-font-family`, `--ui-font-size`, `--term-font-family`, `--term-font-size`) in catppuccin.css with defaults; consumed by app.css body rule
+- `initTheme()` now restores 4 saved font settings (ui_font_family, ui_font_size, term_font_family, term_font_size) from SQLite on startup alongside theme restoration
+- v3 Mission Control (All Phases 1-10 complete): multi-project dashboard with project groups, per-project Claude sessions, team agents panel, terminal tabs, 3 workspace tabs (Sessions/Docs/Context) + settings drawer
+- v3 session continuity (P6): `persistSessionForProject()` saves agent state + messages to SQLite on session complete; `registerSessionProject()` maps session to project; `ClaudeSession.restoreMessagesFromRecords()` restores cached messages on mount
+- v3 workspace teardown (P7): `clearAllAgentSessions()` clears agent sessions on group switch; terminal tabs reset via `switchGroup()`
+- v3 data model: `groups.rs` (Rust structs + load/save `~/.config/bterminal/groups.json`), `groups.ts` (TypeScript interfaces), `groups-bridge.ts` (IPC adapter), `--group` CLI argument
+- v3 workspace store (`workspace.svelte.ts`): replaces `layout.svelte.ts`, manages groups/activeGroupId/activeTab/focusedProjectId with Svelte 5 runes
+- v3 SQLite migrations: `agent_messages` table (per-project message persistence), `project_agent_state` table (sdkSessionId/cost/status per project), `project_id` column on sessions
+- 12 new Workspace components: GlobalTabBar, ProjectGrid, ProjectBox, ProjectHeader, ClaudeSession, TeamAgentsPanel, AgentCard, TerminalTabs, CommandPalette, DocsTab, ContextTab, SettingsTab
+- v3 App.svelte full rewrite: GlobalTabBar + tab content area + StatusBar (no sidebar, no TilingGrid)
+- 24 new vitest tests for workspace store, 7 new cargo tests for groups (total: 138 vitest + 36 cargo)
+- v3 adversarial architecture review: 3 agents (Architect, Devil's Advocate, UX+Performance Specialist), 12 issues identified and resolved
+- v3 Mission Control redesign planning: architecture docs (`docs/v3-task_plan.md`, `docs/v3-findings.md`, `docs/v3-progress.md`), codebase reuse analysis
+- Claude profile/account switching: `claude_list_profiles()` reads `~/.config/switcher/profiles/` directories with `profile.toml` metadata (email, subscription_type, display_name); profile selector dropdown in AgentPane toolbar when multiple profiles available; selected profile's `config_dir` passed as `CLAUDE_CONFIG_DIR` env override to SDK
+- Skill discovery and autocomplete: `claude_list_skills()` reads `~/.claude/skills/` (directories with `SKILL.md` or standalone `.md` files); type `/` in agent prompt textarea to trigger autocomplete menu with arrow key navigation, Tab/Enter selection, Escape dismiss; `expandSkillPrompt()` reads skill content and injects as prompt
+- New frontend adapter `claude-bridge.ts`: `ClaudeProfile` and `ClaudeSkill` interfaces, `listProfiles()`, `listSkills()`, `readSkill()` IPC wrappers
+- AgentPane session toolbar: editable working directory input, profile/account selector (shown when >1 profile), all rendered above prompt form
+- Extended `AgentQueryOptions` with 5 new fields across full stack (Rust struct, sidecar JSON, SDK options): `setting_sources` (defaults to `['user', 'project']`), `system_prompt`, `model`, `claude_config_dir`, `additional_directories`
+- 4 new Tauri commands: `claude_list_profiles`, `claude_list_skills`, `claude_read_skill`, `pick_directory`
+- Claude CLI path auto-detection: `findClaudeCli()` in both sidecar runners checks common paths (~/.local/bin/claude, ~/.claude/local/claude, /usr/local/bin/claude, /usr/bin/claude) then falls back to `which`/`where`; resolved path passed to SDK via `pathToClaudeCodeExecutable` option
+- Early error reporting when Claude CLI is not found — sidecar emits `agent_error` immediately instead of cryptic SDK failure
+
+### Changed
+- SettingsTab global settings restructured to single-column layout with labels above controls, split into "Appearance" (theme, UI font, terminal font) and "Defaults" (shell, CWD) subsections; all native `<select>` replaced with custom themed dropdowns
+- Font setting keys changed from `font_family`/`font_size` to `ui_font_family`/`ui_font_size` + `term_font_family`/`term_font_size`; UI font fallback changed from monospace to sans-serif
+- `app.css` body font-family and font-size now use CSS custom properties (`var(--ui-font-family)`, `var(--ui-font-size)`) instead of hardcoded values
+- Theme system generalized from Catppuccin-only to multi-theme: all 17 themes map to same `--ctp-*` CSS custom properties (26 vars) — zero component-level changes needed
+- `CatppuccinFlavor` type deprecated in favor of `ThemeId`; `CatppuccinPalette` deprecated in favor of `ThemePalette`; `FLAVOR_LABELS` and `ALL_FLAVORS` deprecated in favor of `THEME_LIST` and `ALL_THEME_IDS`
+
+### Fixed
+- SettingsTab theme dropdown sizing: set `min-width: 180px` on trigger container, `min-width: 280px` and `max-height: 400px` on dropdown menu, `white-space: nowrap` on option labels to prevent text truncation
+- SettingsTab input overflow: added `min-width: 0` on `.setting-row` to prevent flex children from overflowing container
+- SettingsTab a11y: project field labels changed from `<div><label>` to wrapping `<label><span class="field-label">` pattern for proper label/input association
+- SettingsTab CSS: removed unused `.project-field label` selector, simplified input selector to `.project-field input:not([type="checkbox"])`
+
+### Removed
+- Dead `update_ssh_session()` method from session.rs and its unit test (method was unused after SSH CRUD refactoring)
+- Stale TilingGrid reference in AgentPane.svelte comment (TilingGrid was deleted in v3 P10)
+
+### Changed
+- StatusBar rewritten for v3 workspace store: shows active group name, project count, agent count instead of pane counts; version label updated to "BTerminal v3"
+- Agent dispatcher subagent routing: project-scoped sessions skip layout pane creation (subagents render in TeamAgentsPanel instead); detached mode still creates layout pane
+- AgentPane `cwd` prop renamed to `initialCwd` — now editable via text input in session toolbar instead of fixed prop
+
+### Removed
+- Dead v2 components deleted in P10 (~1,836 lines): `TilingGrid.svelte` (328), `PaneContainer.svelte` (113), `PaneHeader.svelte` (44), `SessionList.svelte` (374), `SshSessionList.svelte` (263), `SshDialog.svelte` (281), `SettingsDialog.svelte` (433)
+- Empty component directories removed: `Layout/`, `Sidebar/`, `Settings/`, `SSH/`
+- Sidecar runners now pass `settingSources` (defaults to `['user', 'project']`), `systemPrompt`, `model`, and `additionalDirectories` to SDK `query()` options
+- Sidecar runners inject `CLAUDE_CONFIG_DIR` into clean env when `claudeConfigDir` provided in query message (multi-account support)
+
+### Fixed
+- AgentPane Svelte 5 event modifier syntax: `on:click` changed to `onclick` (Svelte 5 requires lowercase event handler attributes, not colon syntax)
+- CLAUDE* env var stripping now applied at Rust level in SidecarManager (bterminal-core/src/sidecar.rs): `env_clear()` + `envs(clean_env)` strips all CLAUDE-prefixed vars before spawning sidecar process, providing primary defense against nesting detection (JS-side stripping retained as defense-in-depth)
+
+### Changed
+- Sidecar resolution unified: single pre-built `agent-runner.mjs` bundle replaces separate `agent-runner-deno.ts` + `agent-runner.ts` lookup; same `.mjs` file runs under both Deno and Node.js
+- `resolve_sidecar_command()` in sidecar.rs now checks deno/node availability upfront before searching paths, improved error message with runtime availability note
+- Removed `agent-runner-deno.ts` from tauri.conf.json bundled resources (only `dist/agent-runner.mjs` shipped)
+
+### Added
+- `@anthropic-ai/claude-agent-sdk` ^0.2.70 npm dependency for sidecar agent session management
+- `build:sidecar` npm script for esbuild bundling of agent-runner.ts (SDK bundled in, no external dependency at runtime)
+- `permission_mode` field in AgentQueryOptions (Rust, TypeScript) — flows from controller through sidecar to SDK, defaults to 'bypassPermissions', supports 'default' mode
+
+### Changed
+- Sidecar agent runners migrated from raw `claude` CLI spawning (`child_process.spawn`/`Deno.Command`) to `@anthropic-ai/claude-agent-sdk` query() function — fixes silent hang when CLI spawned with piped stdio (known bug github.com/anthropics/claude-code/issues/6775)
+- agent-runner.ts: sessions now use `{ query: Query, controller: AbortController }` map instead of `ChildProcess` map; stop uses `controller.abort()` instead of `child.kill()`
+- agent-runner-deno.ts: sessions now use `AbortController` map; uses `npm:@anthropic-ai/claude-agent-sdk` import specifier
+- Deno sidecar permissions expanded: added `--allow-write` and `--allow-net` flags in sidecar.rs (required by SDK)
+- CLAUDE* env var stripping now passes clean env via SDK's `env` option in query() instead of filtering process.env before spawn
+- SDK permissionMode and allowDangerouslySkipPermissions now dynamically set based on permission_mode option (was hardcoded to bypassPermissions)
+- build:sidecar esbuild command no longer uses --external for SDK (SDK bundled into output)
+
+### Fixed
+- AgentPane onDestroy no longer kills running agent sessions on component remount — stopAgent() moved from AgentPane.svelte onDestroy to TilingGrid.svelte onClose handler, ensuring agents only stop on explicit user close action
+
+### Previously Added
+- Exponential backoff reconnection in RemoteManager: on disconnect, spawns async task with 1s/2s/4s/8s/16s/30s-cap backoff, uses attempt_tcp_probe() (TCP-only, no WS upgrade, 5s timeout, default port 9750), emits remote-machine-reconnecting and remote-machine-reconnect-ready events
+- Frontend reconnection listeners: onRemoteMachineReconnecting and onRemoteMachineReconnectReady in remote-bridge.ts; machines store sets status to 'reconnecting' and auto-calls connectMachine() on ready
+- Relay command response propagation: bterminal-relay now sends structured responses (pty_created, pong, error) back to client via shared event channel with commandId correlation
+- send_error() helper in bterminal-relay for consistent error reporting across all command handlers
+- PTY creation confirmation flow: pty_create command returns pty_created event with session ID and commandId; RemoteManager emits remote-pty-created Tauri event
+- bterminal-core shared crate with EventSink trait: extracted PtyManager and SidecarManager into reusable crate at v2/bterminal-core/, EventSink trait abstracts event emission for both Tauri and WebSocket contexts
+- bterminal-relay WebSocket server binary: standalone Rust binary at v2/bterminal-relay/ with token auth (--port, --token, --insecure CLI flags), rate limiting (10 attempts, 5min lockout), per-connection isolated PTY + sidecar managers
+- RemoteManager for multi-machine WebSocket connections: v2/src-tauri/src/remote.rs manages WebSocket client connections to relay instances, 12 new Tauri commands for remote operations, heartbeat ping every 15s
+- Remote machine management UI in settings: SettingsDialog "Remote Machines" section for add/remove/connect/disconnect
+- Auto-grouping of remote panes in sidebar: remote panes auto-grouped by machine label in SessionList
+- remote-bridge.ts adapter for remote machine IPC operations
+- machines.svelte.ts store for remote machine state management (Svelte 5 runes)
+- Pane.remoteMachineId field in layout store for local vs remote routing
+- TauriEventSink (event_sink.rs) implementing EventSink trait for Tauri AppHandle
+- Multi-machine support architecture design (`docs/multi-machine.md`): WebSocket NDJSON protocol, pre-shared token + TLS auth, autonomous relay model
+- Subagent cost aggregation: getTotalCost() recursive helper in agents store aggregates cost across parent + all child sessions; total cost displayed in parent pane done-bar when children present
+- 10 new subagent routing tests in agent-dispatcher.test.ts: spawn, dedup, child message routing, init/cost forwarding, fallbacks (28 total dispatcher tests, 114 vitest tests overall)
+- TAURI_SIGNING_PRIVATE_KEY secret set in GitHub repo for auto-update signing
+- Agent teams/subagent support (Phase 7): auto-detects subagent tool calls ('Agent', 'Task', 'dispatch_agent'), spawns child agent panes with parent/child navigation, routes messages via parentId field
+- Agent store parent/child hierarchy: AgentSession extended with parentSessionId, parentToolUseId, childSessionIds; findChildByToolUseId() and getChildSessions() query functions
+- AgentPane parent link bar: SUB badge with navigate-to-parent button for subagent panes
+- AgentPane children bar: clickable chips per child subagent with status-colored indicators (running/done/error)
+- SessionList subagent icon: subagent panes show '↳' instead of '*' in sidebar
+- Session groups/folders: group_name column in sessions table, setPaneGroup in layout store, collapsible group headers in sidebar with arrow/count, right-click pane to set group
+- Auto-update signing key: generated minisign keypair, pubkey configured in tauri.conf.json updater section
+- Deno-first sidecar: SidecarCommand struct in sidecar.rs, resolve_sidecar_command() prefers Deno (runs TS directly) with Node.js fallback, both runners bundled via tauri.conf.json resources
+- Vitest integration tests: layout.test.ts (30 tests), agent-bridge.test.ts (11 tests), agent-dispatcher.test.ts (28 tests) — total 114 vitest tests passing
+- E2E test scaffold: v2/tests/e2e/README.md documenting WebDriver approach
+- Terminal copy/paste: Ctrl+Shift+C copies selection, Ctrl+Shift+V pastes from clipboard to PTY (TerminalPane.svelte)
+- Terminal theme hot-swap: onThemeChange() callback registry in theme.svelte.ts, open terminals update immediately when flavor changes
+- Agent tree node click: clicking a tree node scrolls to the corresponding message in the agent pane (scrollIntoView smooth)
+- Agent tree subtree cost: cumulative cost displayed in yellow below each tree node label (subtreeCost utility)
+- Agent session resume: follow-up prompt input after session completes or errors, passes resume_session_id to SDK
+- Pane drag-resize handles: splitter overlays in TilingGrid with mouse drag, supports 2-col/3-col/2-row layouts with 10-90% ratio clamping
+- Auto-update CI workflow: release.yml generates latest.json with version, platform URL, and signature from .sig file; uploads as release artifact
+- Deno sidecar proof-of-concept: agent-runner-deno.ts with same NDJSON protocol, compiles to single binary via deno compile
+- Vitest test suite: sdk-messages.test.ts (SDK message adapter) and agent-tree.test.ts (tree builder/cost), vite.config.ts test config, npm run test script
+- Cargo test suite: session.rs tests (SessionDb CRUD for sessions, SSH sessions, settings, layout) and ctx.rs tests (CtxDb error handling with missing database)
+- tempfile dev dependency for Rust test isolation
+
+### Fixed
+- Sidecar env var leak: both agent-runner.ts and agent-runner-deno.ts now strip ALL `CLAUDE*` prefixed env vars before spawning the claude CLI, preventing silent hangs when BTerminal is launched from within a Claude Code terminal session (previously only CLAUDECODE was removed)
+
+### Changed
+- RemoteManager reconnection probe refactored from attempt_ws_connect() (full WS handshake + auth) to attempt_tcp_probe() (TCP-only connect, no resource allocation on relay)
+- bterminal-relay command handlers refactored: all error paths now use send_error() helper instead of log::error!() only; pong response sent via event channel instead of no-op
+- RemoteManager disconnect handler: scoped mutex release before event emission to prevent deadlocks; spawns reconnection task
+- PtyManager and SidecarManager extracted from src-tauri to bterminal-core shared crate (src-tauri now has thin re-export wrappers)
+- Cargo workspace structure at v2/ level: members = [src-tauri, bterminal-core, bterminal-relay], Cargo.lock moved from src-tauri/ to workspace root
+- agent-bridge.ts and pty-bridge.ts extended with remote routing (check remoteMachineId, route to remote_* commands)
+- Agent dispatcher refactored to split messages: parentId-bearing messages routed to child panes via toolUseToChildPane Map, main session messages stay in parent
+- Agent store createAgentSession() now accepts optional parent parameter for registering bidirectional parent/child links
+- Agent store removeAgentSession() cleans up parent's childSessionIds on removal
+- Sidecar manager refactored from Node.js-only to Deno-first with Node.js fallback (SidecarCommand abstraction)
+- Session struct: added group_name field with serde default
+- SessionDb: added update_group method, list/save queries updated for group_name column
+- SessionList sidebar: uses Svelte 5 snippets for grouped pane rendering with collapsible headers
+- Agent tree NODE_H increased from 32 to 40 to accommodate subtree cost display
+- release.yml build step now passes TAURI_SIGNING_PRIVATE_KEY and PASSWORD env vars from secrets
+- release.yml uploads latest.json alongside .deb and .AppImage artifacts
+- vitest ^4.0.18 added as npm dev dependency
+
+### Previously Added
+- SSH session management: SshSession CRUD in SQLite, SshDialog create/edit modal, SshSessionList grouped by folder with color dots, SSH pane type routing to TerminalPane with shell=/usr/bin/ssh (Phase 5)
+- ctx context database integration: read-only CtxDb (Rust, SQLITE_OPEN_READ_ONLY), ContextPane with project selector, tabs for entries/summaries/search, ctx-bridge adapter (Phase 5)
+- Catppuccin theme flavors: all 4 palettes (Latte/Frappe/Macchiato/Mocha) selectable via Settings dialog, theme.svelte.ts reactive store with SQLite persistence, TerminalPane theme-aware (Phase 5)
+- Detached pane mode: pop-out terminal/agent panes into standalone windows via URL params (?detached=1), detach.ts utility, App.svelte conditional rendering (Phase 5)
+- Shiki syntax highlighting: lazy singleton highlighter with catppuccin-mocha theme, 13 preloaded languages, integrated in MarkdownPane and AgentPane text messages (Phase 5)
+- Tauri auto-updater plugin: tauri-plugin-updater (Rust + npm) + updater.ts frontend utility (Phase 6)
+- Markdown rendering in agent text messages with Shiki code highlighting (Phase 5)
+- Build-from-source installer `install-v2.sh` with 6-step dependency checking (Node.js 20+, Rust 1.77+, WebKit2GTK, GTK3, and 8 other system libraries), auto-install via apt, binary install to `~/.local/bin/bterminal-v2` with desktop entry (Phase 6)
+- Tauri bundle configuration for .deb and AppImage targets with category, descriptions, and deb dependencies (Phase 6)
+- GitHub Actions release workflow (`.github/workflows/release.yml`): triggered on `v*` tags, builds on Ubuntu 22.04 with Rust/npm caching, uploads .deb + AppImage as GitHub Release artifacts (Phase 6)
+- Regenerated application icons from `bterminal.svg` as RGBA PNGs (32x32, 128x128, 256x256, 512x512, .ico) (Phase 6)
+- Agent tree visualization: SVG tree of tool calls with horizontal layout, bezier edges, status-colored nodes (AgentTree.svelte + agent-tree.ts) (Phase 5)
+- Global status bar showing terminal/agent pane counts, active agents with pulse animation, total tokens and cost (StatusBar.svelte) (Phase 5)
+- Toast notification system with auto-dismiss (4s), max 5 visible, color-coded by type (notifications.svelte.ts + ToastContainer.svelte) (Phase 5)
+- Agent dispatcher toast integration: notifications on agent complete, error, and sidecar crash (Phase 5)
+- Settings dialog with default shell, working directory, and max panes configuration (SettingsDialog.svelte) (Phase 5)
+- Settings persistence: key-value settings table in SQLite, Tauri commands settings_get/set/list, settings-bridge.ts adapter (Phase 5)
+- Keyboard shortcuts: Ctrl+W close focused pane, Ctrl+, open settings dialog (Phase 5)
+- SQLite session persistence with rusqlite (bundled, WAL mode) — sessions table + layout_state singleton (Phase 4)
+- Session CRUD: save, delete, update_title, touch with 7 Tauri commands (Phase 4)
+- Layout restore on app startup — panes and preset restored from database (Phase 4)
+- File watcher backend using notify crate v6 — watches files, emits Tauri events on change (Phase 4)
+- MarkdownPane component with marked.js rendering, Catppuccin-themed styles, and live reload (Phase 4)
+- Sidebar "M" button for opening markdown/text files via file picker (Phase 4)
+- Session bridge adapter for Tauri IPC (session + layout persistence wrappers) (Phase 4)
+- File bridge adapter for Tauri IPC (watch, unwatch, read, onChange wrappers) (Phase 4)
+- Sidecar crash detection — dispatcher listens for process exit, marks running sessions as error (Phase 3 polish)
+- Sidecar restart UI — "Restart Sidecar" button in AgentPane error bar (Phase 3 polish)
+- Auto-scroll lock — disables auto-scroll when user scrolls up, shows "Scroll to bottom" button (Phase 3 polish)
+- Agent restart Tauri command (agent_restart) (Phase 3 polish)
+- Agent pane with prompt input, structured message rendering, stop button, and cost display (Phase 3)
+
+### Fixed
+- Svelte 5 rune stores (layout, agents, sessions) renamed from `.ts` to `.svelte.ts` — runes only work in `.svelte` and `.svelte.ts` files, plain `.ts` caused "rune_outside_svelte" runtime error (blank screen)
+- Updated all import paths to use `.svelte` suffix for store modules
+- Node.js sidecar manager (Rust) for spawning and communicating with agent-runner via stdio NDJSON (Phase 3)
+- Agent-runner sidecar: spawns `claude` CLI with `--output-format stream-json` for structured agent output (Phase 3)
+- SDK message adapter parsing stream-json into 9 typed message types: init, text, thinking, tool_call, tool_result, status, cost, error, unknown (Phase 3)
+- Agent bridge adapter for Tauri IPC (invoke + event listeners) (Phase 3)
+- Agent dispatcher routing sidecar events to agent session store (Phase 3)
+- Agent session store with message history, cost tracking, and lifecycle management (Phase 3)
+- Keyboard shortcut: Ctrl+Shift+N to open new agent pane (Phase 3)
+- Sidebar button for creating new agent sessions (Phase 3)
+- Rust PTY backend with portable-pty: spawn, write, resize, kill with Tauri event streaming (Phase 2)
+- xterm.js terminal pane with Canvas addon, FitAddon, and Catppuccin Mocha theme (Phase 2)
+- CSS Grid tiling layout with 5 presets: 1-col, 2-col, 3-col, 2x2, master-stack (Phase 2)
+- Layout store with Svelte 5 $state runes and auto-preset selection (Phase 2)
+- Sidebar with session list, layout preset selector, and new terminal button (Phase 2)
+- Keyboard shortcuts: Ctrl+N new terminal, Ctrl+1-4 focus pane (Phase 2)
+- PTY bridge adapter for Tauri IPC (invoke + event listeners) (Phase 2)
+- PaneContainer component with header bar, status indicator, and close button (Phase 2)
+- Terminal resize handling with ResizeObserver and 100ms debounce (Phase 2)
+- v2 project scaffolding: Tauri 2.x + Svelte 5 in `v2/` directory (Phase 1)
+- Rust backend stubs: main.rs, lib.rs, pty.rs, sidecar.rs, watcher.rs, session.rs (Phase 1)
+- Svelte frontend with Catppuccin Mocha CSS variables and component structure (Phase 1)
+- Node.js sidecar scaffold with NDJSON communication pattern (Phase 1)
 - v2 architecture planning: Tauri 2.x + Svelte 5 + Claude Agent SDK via Node.js sidecar
 - Research documentation covering Agent SDK, xterm.js performance, Tauri ecosystem, and ultrawide layout patterns
 - Phased implementation plan (6 phases, MVP = Phases 1-4)
 - Error handling and testing strategy for v2
 - Documentation structure in `docs/` (task_plan, phases, findings, progress)
+- 17 operational rules in `.claude/rules/`
 - TODO.md for tracking active work
 - `.claude/CLAUDE.md` behavioral guide for Claude sessions
+- VS Code workspace configuration with Peacock color
diff --git a/CLAUDE.md b/CLAUDE.md
new file mode 100644
index 0000000..b6552d5
--- /dev/null
+++ b/CLAUDE.md
@@ -0,0 +1,230 @@
+# BTerminal — Project Guide for Claude
+
+## Project Overview
+
+Terminal emulator with SSH and Claude Code session management. v1 (GTK3+VTE Python) is production-stable. v2 redesign (Tauri 2.x + Svelte 5 + Claude Agent SDK) Phases 1-7 + multi-machine (A-D) + profiles/skills complete. Packaging: .deb + AppImage via GitHub Actions CI. v3 Mission Control (All Phases 1-10 Complete + Production Readiness): multi-project dashboard with project groups, per-project Claude sessions with session continuity, team agents panel, terminal tabs, VSCode-style left sidebar, multi-agent orchestration (Tier 1 management agents: Manager/Architect/Tester/Reviewer with role-specific tabs, btmsg inter-agent messaging, bttask kanban task board with optimistic locking). Production features: sidecar crash recovery/supervision, FTS5 full-text search, plugin system (sandboxed, 35 tests), Landlock sandboxing, secrets management (system keyring), OS + in-app notifications, keyboard-first UX (18+ palette commands), agent health monitoring + dead letter queue, audit logging, error classification. Hardening: TLS relay support, WAL checkpoint (5min), subagent delegation fix.
+
+- **Repository:** github.com/DexterFromLab/BTerminal
+- **License:** MIT
+- **Primary target:** Linux x86_64
+
+## Documentation (SOURCE OF TRUTH)
+
+**All project documentation lives in [`docs/`](docs/README.md). This is the single source of truth for this project.** Before making changes, consult the docs. After making changes, update the docs. No exceptions.
+
+## Key Paths
+
+| Path | Description |
+|------|-------------|
+| `bterminal.py` | v1 main application (2092 lines, GTK3+VTE) |
+| `ctx` | Context manager CLI tool (SQLite-based) |
+| `install.sh` | v1 system installer |
+| `install-v2.sh` | v2 build-from-source installer (Node.js 20+, Rust 1.77+, system libs) |
+| `.github/workflows/release.yml` | CI: builds .deb + AppImage on v* tags, uploads to GitHub Releases |
+| `docs/task_plan.md` | v2 architecture decisions and strategies |
+| `docs/phases.md` | v2 implementation phases (1-7 + multi-machine A-D) |
+| `docs/findings.md` | v2 research findings |
+| `docs/progress.md` | Session progress log (recent) |
+| `docs/progress-archive.md` | Archived progress log (2026-03-05 to 2026-03-06 early) |
+| `docs/multi-machine.md` | Multi-machine architecture (implemented, Phases A-D) |
+| `docs/v3-task_plan.md` | v3 Mission Control redesign: architecture decisions and strategies |
+| `docs/v3-findings.md` | v3 research findings and codebase reuse analysis |
+| `docs/v3-progress.md` | v3 session progress log |
+| `docs/e2e-testing.md` | E2E testing facility: fixtures, test mode, LLM judge, spec phases, CI |
+| `v2/Cargo.toml` | Cargo workspace root (members: src-tauri, bterminal-core, bterminal-relay) |
+| `v2/bterminal-core/` | Shared crate: EventSink trait, PtyManager, SidecarManager |
+| `v2/bterminal-relay/` | Standalone relay binary (WebSocket server, token auth, CLI) |
+| `v2/src-tauri/src/pty.rs` | PTY backend (thin re-export from bterminal-core) |
+| `v2/src-tauri/src/groups.rs` | Groups config (load/save ~/.config/bterminal/groups.json) |
+| `v2/src-tauri/src/fs_watcher.rs` | ProjectFsWatcher (inotify per-project recursive file change detection, S-1 Phase 2) |
+| `v2/src-tauri/src/lib.rs` | AppState + setup + handler registration (~170 lines) |
+| `v2/src-tauri/src/commands/` | 16 domain command modules (pty, agent, watcher, session, persistence, knowledge, claude, groups, files, remote, misc, bttask, notifications, plugins, search, secrets) |
+| `v2/src-tauri/src/btmsg.rs` | Agent messaging backend (agents, DMs, channels, contacts ACL, heartbeats, dead_letter_queue, audit_log; SQLite WAL mode, named column access) |
+| `v2/src-tauri/src/bttask.rs` | Task board backend (list, create, update status with optimistic locking, delete, comments, review_queue_count; shared btmsg.db) |
+| `v2/src-tauri/src/search.rs` | FTS5 full-text search (SearchDb, 3 virtual tables: search_messages/tasks/btmsg, index/search/rebuild) |
+| `v2/src-tauri/src/secrets.rs` | SecretsManager (keyring crate, linux-native/libsecret, store/get/delete/list with metadata tracking) |
+| `v2/src-tauri/src/plugins.rs` | Plugin discovery (scan config dir for plugin.json, path-traversal-safe file reading, permission validation) |
+| `v2/src-tauri/src/notifications.rs` | Desktop notifications (notify-rust, graceful fallback if daemon unavailable) |
+| `v2/bterminal-core/src/supervisor.rs` | SidecarSupervisor (auto-restart, exponential backoff 1s-30s, 5 retries, SidecarHealth enum, 17 tests) |
+| `v2/bterminal-core/src/sandbox.rs` | Landlock sandbox (SandboxConfig RW/RO paths, pre_exec() integration, kernel 6.2+ graceful fallback) |
+| `v2/src-tauri/src/sidecar.rs` | SidecarManager (thin re-export from bterminal-core) |
+| `v2/src-tauri/src/event_sink.rs` | TauriEventSink (implements EventSink for AppHandle) |
+| `v2/src-tauri/src/remote.rs` | RemoteManager (WebSocket client connections to relays) |
+| `v2/src-tauri/src/session/` | SessionDb module: mod.rs (struct + migrate), sessions.rs, layout.rs, settings.rs, ssh.rs, agents.rs, metrics.rs, anchors.rs |
+| `v2/src-tauri/src/watcher.rs` | FileWatcherManager (notify crate, file change events) |
+| `v2/src-tauri/src/ctx.rs` | CtxDb (read-only access to ~/.claude-context/context.db) |
+| `v2/src-tauri/src/memora.rs` | MemoraDb (read-only access to ~/.local/share/memora/memories.db, FTS5 search) |
+| `v2/src-tauri/src/telemetry.rs` | OTEL telemetry (TelemetryGuard, tracing + OTLP export, BTERMINAL_OTLP_ENDPOINT) |
+| `v2/src/lib/stores/workspace.svelte.ts` | v3 workspace store (project groups, tabs, focus, replaces layout store) |
+| `v2/src/lib/stores/layout.svelte.ts` | v2 layout store (panes, presets, groups, persistence, Svelte 5 runes) |
+| `v2/src/lib/stores/agents.svelte.ts` | Agent session store (messages, cost, parent/child hierarchy) |
+| `v2/src/lib/components/Terminal/TerminalPane.svelte` | xterm.js terminal pane |
+| `v2/src/lib/components/Terminal/AgentPreviewPane.svelte` | Read-only xterm.js showing agent activity (Bash commands, tool results, errors) |
+| `v2/src/lib/components/Agent/AgentPane.svelte` | Agent session pane (sans-serif font, tool call/result pairing, hook collapsing, context meter, prompt, cost, profile selector, skill autocomplete) |
+| `v2/src/lib/adapters/pty-bridge.ts` | PTY IPC wrapper (Tauri invoke/listen) |
+| `v2/src/lib/adapters/agent-bridge.ts` | Agent IPC wrapper (Tauri invoke/listen) |
+| `v2/src/lib/adapters/claude-messages.ts` | Claude message adapter (stream-json parser, renamed from sdk-messages.ts) |
+| `v2/src/lib/adapters/message-adapters.ts` | Provider message adapter registry (per-provider routing to common AgentMessage) |
+| `v2/src/lib/adapters/provider-bridge.ts` | Generic provider bridge (delegates to provider-specific bridges) |
+| `v2/src/lib/providers/types.ts` | Provider abstraction types (ProviderId, ProviderCapabilities, ProviderMeta, ProviderSettings) |
+| `v2/src/lib/providers/registry.svelte.ts` | Svelte 5 rune-based provider registry (registerProvider, getProviders) |
+| `v2/src/lib/providers/claude.ts` | Claude provider metadata constant (CLAUDE_PROVIDER) |
+| `v2/src/lib/providers/codex.ts` | Codex provider metadata constant (CODEX_PROVIDER, gpt-5.4 default) |
+| `v2/src/lib/providers/ollama.ts` | Ollama provider metadata constant (OLLAMA_PROVIDER, qwen3:8b default) |
+| `v2/src/lib/adapters/codex-messages.ts` | Codex message adapter (ThreadEvent parser) |
+| `v2/src/lib/adapters/ollama-messages.ts` | Ollama message adapter (streaming chunk parser) |
+| `v2/src/lib/agent-dispatcher.ts` | Thin coordinator: routes sidecar events to agent store, delegates to extracted modules |
+| `v2/src/lib/utils/session-persistence.ts` | Session-project maps + persistSessionForProject + waitForPendingPersistence |
+| `v2/src/lib/utils/auto-anchoring.ts` | triggerAutoAnchor on first compaction event |
+| `v2/src/lib/utils/subagent-router.ts` | Subagent pane creation + toolUseToChildPane routing |
+| `v2/src/lib/utils/worktree-detection.ts` | detectWorktreeFromCwd pure function (3 provider patterns) |
+| `v2/src/lib/adapters/file-bridge.ts` | File watcher IPC wrapper |
+| `v2/src/lib/adapters/settings-bridge.ts` | Settings IPC wrapper (get/set/list) |
+| `v2/src/lib/adapters/ctx-bridge.ts` | ctx database IPC wrapper |
+| `v2/src/lib/adapters/ssh-bridge.ts` | SSH session IPC wrapper |
+| `v2/src/lib/adapters/claude-bridge.ts` | Claude profiles + skills IPC wrapper |
+| `v2/src/lib/adapters/groups-bridge.ts` | Groups config IPC wrapper (load/save) |
+| `v2/src/lib/adapters/remote-bridge.ts` | Remote machine management IPC wrapper |
+| `v2/src/lib/adapters/files-bridge.ts` | File browser IPC wrapper (list_directory_children, read_file_content) |
+| `v2/src/lib/adapters/memory-adapter.ts` | Pluggable memory adapter interface (MemoryAdapter, registry) |
+| `v2/src/lib/adapters/memora-bridge.ts` | Memora IPC bridge + MemoraAdapter (read-only SQLite via Tauri commands) |
+| `v2/src/lib/adapters/fs-watcher-bridge.ts` | Filesystem watcher IPC wrapper (project CWD write detection) |
+| `v2/src/lib/adapters/anchors-bridge.ts` | Session anchors IPC wrapper (save, load, delete, clear, updateType) |
+| `v2/src/lib/adapters/bttask-bridge.ts` | Task board IPC adapter (listTasks, createTask, updateTaskStatus, deleteTask, comments) |
+| `v2/src/lib/adapters/telemetry-bridge.ts` | Frontend telemetry bridge (routes events to Rust tracing via IPC) |
+| `v2/src/lib/utils/agent-prompts.ts` | Agent prompt generator (generateAgentPrompt: identity, env, team, btmsg/bttask docs, workflow) |
+| `docker/tempo/` | Docker compose: Tempo + Grafana for trace visualization (port 9715) |
+| `v2/scripts/test-all.sh` | Unified test runner: vitest + cargo + optional E2E (--e2e flag) |
+| `v2/tests/e2e/wdio.conf.js` | WebDriverIO config (tauri-driver lifecycle, TCP probe, test env vars) |
+| `v2/tests/e2e/fixtures.ts` | E2E test fixture generator (isolated temp dirs, git repos, groups.json) |
+| `v2/tests/e2e/results-db.ts` | JSON test results store (run/step tracking, no native deps) |
+| `v2/tests/e2e/specs/bterminal.test.ts` | E2E smoke tests (CSS class selectors, 50+ tests) |
+| `v2/tests/e2e/specs/agent-scenarios.test.ts` | Phase A E2E scenarios (data-testid selectors, 7 scenarios, 22 tests) |
+| `v2/tests/e2e/specs/phase-b.test.ts` | Phase B E2E scenarios (multi-project, LLM-judged assertions, 6 scenarios) |
+| `v2/tests/e2e/llm-judge.ts` | LLM judge helper (Claude API assertions, confidence thresholds) |
+| `.github/workflows/e2e.yml` | CI: unit + cargo + E2E tests (xvfb-run, path-filtered, LLM tests gated on secret) |
+| `v2/src/lib/stores/machines.svelte.ts` | Remote machine state store (Svelte 5 runes) |
+| `v2/src/lib/utils/attention-scorer.ts` | Pure attention scoring function (extracted from health store, 14 tests) |
+| `v2/src/lib/utils/wake-scorer.ts` | Pure wake signal evaluation (6 signals, 24 tests) |
+| `v2/src/lib/types/wake.ts` | WakeStrategy, WakeSignal, WakeEvaluation, WakeContext types |
+| `v2/src/lib/stores/wake-scheduler.svelte.ts` | Manager auto-wake scheduler (3 strategies, per-manager timers) |
+| `v2/src/lib/utils/type-guards.ts` | Shared runtime guards: str(), num() for untyped wire format parsing |
+| `v2/src/lib/utils/agent-tree.ts` | Agent tree builder (hierarchy from messages) |
+| `v2/src/lib/utils/highlight.ts` | Shiki syntax highlighter (lazy singleton, 13 languages) |
+| `v2/src/lib/utils/detach.ts` | Detached pane mode (pop-out windows via URL params) |
+| `v2/src/lib/utils/updater.ts` | Tauri auto-updater utility |
+| `v2/src/lib/stores/notifications.svelte.ts` | Notification store (toast + history, 6 NotificationTypes, unread badge, max 100 history) |
+| `v2/src/lib/stores/plugins.svelte.ts` | Plugin store (command registry, event bus, loadAllPlugins/unloadAllPlugins) |
+| `v2/src/lib/adapters/audit-bridge.ts` | Audit log IPC adapter (logAuditEvent, getAuditLog, AuditEntry, AuditEventType) |
+| `v2/src/lib/adapters/notifications-bridge.ts` | Desktop notification IPC wrapper (sendDesktopNotification) |
+| `v2/src/lib/adapters/plugins-bridge.ts` | Plugin discovery IPC wrapper (discoverPlugins, readPluginFile) |
+| `v2/src/lib/adapters/search-bridge.ts` | FTS5 search IPC wrapper (initSearch, searchAll, rebuildIndex, indexMessage) |
+| `v2/src/lib/adapters/secrets-bridge.ts` | Secrets IPC wrapper (storeSecret, getSecret, deleteSecret, listSecrets, hasKeyring) |
+| `v2/src/lib/utils/error-classifier.ts` | API error classification (6 types: rate_limit/auth/quota/overloaded/network/unknown, retry logic, 20 tests) |
+| `v2/src/lib/plugins/plugin-host.ts` | Sandboxed plugin runtime (new Function(), permission-gated API, load/unload lifecycle) |
+| `v2/src/lib/components/Agent/UsageMeter.svelte` | Compact inline usage meter (color thresholds 50/75/90%, hover tooltip) |
+| `v2/src/lib/components/Notifications/NotificationCenter.svelte` | Bell icon + dropdown notification panel (unread badge, history, mark read/clear) |
+| `v2/src/lib/components/Workspace/AuditLogTab.svelte` | Manager audit log tab (filter by type+agent, 5s auto-refresh, max 200 entries) |
+| `v2/src/lib/components/Workspace/SearchOverlay.svelte` | FTS5 search overlay (Ctrl+Shift+F, Spotlight-style, 300ms debounce, grouped results) |
+| `v2/src/lib/stores/theme.svelte.ts` | Theme store (17 themes: 4 Catppuccin + 7 Editor + 6 Deep Dark, UI + terminal font restoration on startup) |
+| `v2/src/lib/styles/themes.ts` | Theme palette definitions (17 themes), ThemeId/ThemePalette/ThemeMeta types, THEME_LIST |
+| `v2/src/lib/styles/catppuccin.css` | CSS custom properties: 26 --ctp-* color vars + --ui-font-* + --term-font-* |
+| `v2/src/lib/components/Agent/AgentTree.svelte` | SVG agent tree visualization |
+| `v2/src/lib/components/Context/ContextPane.svelte` | ctx database viewer (projects, entries, search) — replaced by ContextTab in ProjectBox |
+| `v2/src/lib/components/Workspace/ContextTab.svelte` | LLM context window visualization (stats, token meter, file refs, turn breakdown) |
+| `v2/src/lib/components/Workspace/CodeEditor.svelte` | CodeMirror 6 wrapper (15 languages, Catppuccin theme, save/blur callbacks) |
+| `v2/src/lib/components/Workspace/PdfViewer.svelte` | PDF viewer (pdfjs-dist, canvas multi-page, zoom 0.5x–3x, HiDPI) |
+| `v2/src/lib/components/Workspace/CsvTable.svelte` | CSV table viewer (RFC 4180 parser, delimiter auto-detect, sortable columns) |
+| `v2/src/lib/components/Workspace/MetricsPanel.svelte` | Dashboard metrics panel (live health + task counts + history sparklines, 25 tests) |
+| `v2/src/lib/stores/health.svelte.ts` | Project health store (activity state, burn rate, context pressure, file conflicts, attention scoring) |
+| `v2/src/lib/stores/conflicts.svelte.ts` | File overlap + external write conflict detection (per-project, session-scoped, worktree-aware, dismissible, inotify-backed) |
+| `v2/src/lib/stores/anchors.svelte.ts` | Session anchor store (per-project anchors, auto-anchor tracking, re-injection support) |
+| `v2/src/lib/types/anchors.ts` | Anchor types (AnchorType, SessionAnchor, AnchorSettings, AnchorBudgetScale, SessionAnchorRecord) |
+| `v2/src/lib/utils/anchor-serializer.ts` | Anchor serialization (turn grouping, observation masking, token estimation) |
+| `v2/src/lib/utils/tool-files.ts` | Shared file path extraction from tool_call inputs (extractFilePaths, extractWritePaths, extractWorktreePath) |
+| `v2/src/lib/components/StatusBar/StatusBar.svelte` | Mission Control bar (agent states, $/hr burn rate, attention queue, cost) |
+| `v2/src/lib/components/Notifications/ToastContainer.svelte` | Toast notification display |
+| `v2/src/lib/components/Workspace/` | v3 components: GlobalTabBar, ProjectGrid, ProjectBox, ProjectHeader, AgentSession, TeamAgentsPanel, AgentCard, TerminalTabs, ProjectFiles, FilesTab, SshTab, MemoriesTab, CommandPalette, DocsTab, SettingsTab, TaskBoardTab, ArchitectureTab, TestingTab |
+| `v2/src/lib/types/groups.ts` | TypeScript interfaces (ProjectConfig, GroupConfig, GroupsFile) |
+| `v2/src/lib/adapters/session-bridge.ts` | Session/layout/group persistence IPC wrapper |
+| `v2/src/lib/components/Markdown/MarkdownPane.svelte` | Markdown file viewer (marked.js + shiki, live reload) |
+| `v2/sidecar/claude-runner.ts` | Claude sidecar source (compiled to .mjs by esbuild, includes findClaudeCli()) |
+| `v2/sidecar/codex-runner.ts` | Codex sidecar source (@openai/codex-sdk dynamic import, sandbox/approval mapping) |
+| `v2/sidecar/ollama-runner.ts` | Ollama sidecar source (direct HTTP to localhost:11434, zero external deps) |
+| `v2/sidecar/agent-runner-deno.ts` | Standalone Deno sidecar runner (not used by SidecarManager, alternative) |
+| `v2/sidecar/dist/claude-runner.mjs` | Bundled Claude sidecar (runs on both Deno and Node.js) |
+| `v2/src/lib/adapters/claude-messages.test.ts` | Vitest tests for Claude message adapter (25 tests) |
+| `v2/src/lib/adapters/codex-messages.test.ts` | Vitest tests for Codex message adapter (19 tests) |
+| `v2/src/lib/adapters/ollama-messages.test.ts` | Vitest tests for Ollama message adapter (11 tests) |
+| `v2/src/lib/adapters/memora-bridge.test.ts` | Vitest tests for Memora bridge + adapter (16 tests) |
+| `v2/src/lib/adapters/btmsg-bridge.test.ts` | Vitest tests for btmsg bridge (17 tests: camelCase, IPC commands) |
+| `v2/src/lib/adapters/bttask-bridge.test.ts` | Vitest tests for bttask bridge (10 tests: camelCase, IPC commands) |
+| `v2/src/lib/adapters/agent-bridge.test.ts` | Vitest tests for agent IPC bridge (11 tests) |
+| `v2/src/lib/agent-dispatcher.test.ts` | Vitest tests for agent dispatcher (29 tests) |
+| `v2/src/lib/stores/conflicts.test.ts` | Vitest tests for conflict detection (28 tests) |
+| `v2/src/lib/utils/tool-files.test.ts` | Vitest tests for tool file extraction (27 tests) |
+| `v2/src/lib/stores/layout.test.ts` | Vitest tests for layout store (30 tests) |
+| `v2/src/lib/utils/agent-tree.test.ts` | Vitest tests for agent tree builder (20 tests) |
+| `v2/src/lib/stores/workspace.test.ts` | Vitest tests for workspace store (24 tests) |
+
+## v1 Stack
+
+- Python 3, GTK3 (PyGObject), VTE 2.91
+- Config: `~/.config/bterminal/` (sessions.json, claude_sessions.json)
+- Context DB: `~/.claude-context/context.db`
+- Theme: Catppuccin Mocha
+
+## v2/v3 Stack (v2 complete, v3 All Phases 1-10 complete, branch: v2-mission-control)
+
+- Tauri 2.x (Rust backend) + Svelte 5 (frontend)
+- Cargo workspace: bterminal-core (shared), bterminal-relay (remote binary), src-tauri (Tauri app)
+- xterm.js with Canvas addon (no WebGL on WebKit2GTK)
+- Agent sessions via `@anthropic-ai/claude-agent-sdk` query() function (migrated from raw CLI spawning)
+- Sidecar uses SDK internally (single .mjs bundle, Deno-first + Node.js fallback, stdio NDJSON to Rust, auto-detects Claude CLI path via findClaudeCli(), supports CLAUDE_CONFIG_DIR override for multi-account)
+- portable-pty for terminal management (in bterminal-core)
+- Multi-machine: bterminal-relay WebSocket server + RemoteManager WebSocket client
+- SQLite session persistence (rusqlite, WAL mode) + layout restore on startup
+- File watcher (notify crate) for live markdown viewer
+- OpenTelemetry: tracing + tracing-subscriber + opentelemetry 0.28 + tracing-opentelemetry 0.29, OTLP/HTTP to Tempo, BTERMINAL_OTLP_ENDPOINT env var
+- Rust deps (src-tauri): tauri, bterminal-core (path), rusqlite (bundled-full, FTS5), dirs, notify, serde, tokio, tokio-tungstenite, futures-util, tracing, tracing-subscriber, opentelemetry, opentelemetry_sdk, opentelemetry-otlp, tracing-opentelemetry, tauri-plugin-updater, tauri-plugin-dialog, notify-rust, keyring (linux-native)
+- Rust deps (bterminal-core): portable-pty, uuid, serde, serde_json, log, landlock
+- Rust deps (bterminal-relay): bterminal-core, tokio, tokio-tungstenite, clap, env_logger, futures-util
+- npm deps: @anthropic-ai/claude-agent-sdk, @xterm/xterm, @xterm/addon-canvas, @xterm/addon-fit, @tauri-apps/api, @tauri-apps/plugin-updater, @tauri-apps/plugin-dialog, marked, shiki, pdfjs-dist, vitest (dev)
+- Source: `v2/` directory
+
+## Build / Run
+
+```bash
+# v1 (current production)
+./install.sh          # Install system-wide
+bterminal             # Run
+
+# v1 Dependencies (Debian/Ubuntu)
+sudo apt install python3-gi gir1.2-gtk-3.0 gir1.2-vte-2.91
+
+# v2 (development, branch v2-mission-control)
+cd v2 && npm install && npm run tauri dev   # Dev mode
+cd v2 && npm run tauri build                # Release build
+
+# v2 tests
+cd v2 && npm run test:all                   # All tests (vitest + cargo)
+cd v2 && npm run test:all:e2e               # All tests + E2E (needs built binary)
+cd v2 && npm run test                       # Vitest only (frontend)
+cd v2 && npm run test:cargo                 # Cargo only (backend)
+cd v2 && npm run test:e2e                   # E2E only (WebDriverIO)
+
+# v2 install from source (builds + installs to ~/.local/bin/bterminal-v2)
+./install-v2.sh
+
+# Telemetry stack (Tempo + Grafana)
+cd docker/tempo && docker compose up -d  # Grafana at http://localhost:9715
+BTERMINAL_OTLP_ENDPOINT=http://localhost:4318 npm run tauri dev  # Enable OTLP export
+```
+
+## Conventions
+
+- 17 themes in 3 groups: 4 Catppuccin (Mocha default) + 7 Editor + 6 Deep Dark (Tokyo Night, Gruvbox Dark, Ayu Dark, Poimandres, Vesper, Midnight)
+- CSS uses rem/em for layout; px only for icons/borders (see `.claude/rules/18-relative-units.md`)
+- Session configs stored as JSON
+- Single-file Python app (v1) — will change to multi-file Rust+Svelte (v2)
+- Polish language in some code comments (v1 legacy)
diff --git a/README.md b/README.md
index 62ae11d..591075f 100644
--- a/README.md
+++ b/README.md
@@ -1,21 +1,28 @@
 # BTerminal
 
-Terminal with session panel (MobaXterm-style), built with GTK 3 + VTE. Catppuccin Mocha theme.
+GTK 3 terminal with SSH & Claude Code session management, macros, and a cross-session context database. Catppuccin Mocha theme.
 
-> **v2 in planning:** Redesign as a multi-session Claude agent dashboard using Tauri 2.x + Svelte 5 + Claude Agent SDK. See [docs/task_plan.md](docs/task_plan.md) for architecture and [docs/phases.md](docs/phases.md) for implementation plan.
+> **v2 complete, v3 all phases complete.** v2: Multi-session Claude agent dashboard using Tauri 2.x + Svelte 5. v3: Multi-project mission control dashboard (All Phases 1-10 complete + sidebar redesign) -- project groups with per-project Claude sessions, session continuity (persist/restore agent messages), team agents panel, terminal tabs, **VSCode-style left sidebar** (vertical icon rail + expandable drawer panel + always-visible workspace), command palette with group switching. Features: **project groups** (up to 5 projects per group, horizontal layout, adaptive viewport count), **per-project Claude sessions** with session continuity, **team agents panel** (compact subagent cards), **terminal tabs** (shell/SSH/agent per project), agent panes with structured output, tree visualization with subtree cost and session resume, **subagent/agent-teams support**, **multi-machine support** (bterminal-relay WebSocket server + RemoteManager), **Claude profile/account switching** (switcher-claude integration), **skill discovery and autocomplete** (type `/` in agent prompt), SSH session management, ctx context database viewer, SQLite session persistence with layout restore, live markdown file viewer with Shiki syntax highlighting, 17 themes in 3 groups (4 Catppuccin + 7 Editor + 6 Deep Dark: Tokyo Night, Gruvbox Dark, Ayu Dark, Poimandres, Vesper, Midnight), **global font controls** (separate UI font [sans-serif] + terminal font [monospace] with live preview), .deb + AppImage packaging, GitHub Actions CI, 138 vitest + 36 cargo tests. Branch `v2-mission-control`. See [docs/v3-task_plan.md](docs/v3-task_plan.md) for v3 architecture.
 
 ![BTerminal](screenshot.png)
 
 ## Features
 
-- **SSH sessions** — saved configs (host, port, user, key, folder, color), CRUD with side panel
-- **Claude Code sessions** — saved Claude Code configs with sudo, resume, skip-permissions and initial prompt
-- **SSH macros** — multi-step macros (text, key, delay) assigned to sessions, run from sidebar
-- **Tabs** — multiple terminals in tabs, Ctrl+T new, Ctrl+Shift+W close, Ctrl+PageUp/Down switch
-- **Sudo askpass** — Claude Code with sudo: password entered once, temporary askpass helper, auto-cleanup
-- **Folder grouping** — SSH and Claude Code sessions can be grouped in folders on the sidebar
-- **ctx — Context manager** — SQLite-based cross-session context database for Claude Code projects
-- **Catppuccin Mocha** — full theme: terminal, sidebar, tabs, session colors
+- **SSH sessions** — saved configs (host, port, user, key, folder, color), one-click connect from sidebar
+- **Claude Code sessions** — saved configs with sudo askpass, resume, skip-permissions and initial prompt
+- **SSH macros** — multi-step automation (text, key press, delay) bound to sessions, runnable from sidebar
+- **Tabs** — multiple terminals in tabs with reordering, auto-close and shell respawn
+- **Folder grouping** — organize both SSH and Claude Code sessions in collapsible sidebar folders
+- **Session colors** — 10 Catppuccin accent colors for quick visual identification
+- **Sudo askpass** — temporary helper for Claude Code sudo mode: password entered once, auto-cleanup on exit
+- **Catppuccin Mocha** — full theme across terminal, sidebar, tabs, dialogs and scrollbars
+
+### Context Manager
+
+- **ctx CLI** — SQLite-based tool for persistent context across Claude Code sessions
+- **Ctx Manager panel** — sidebar tab for browsing, editing and managing all project contexts
+- **Ctx Setup Wizard** — step-by-step project setup with auto-detection from README and CLAUDE.md generation
+- **Import / Export** — selective import and export of projects, entries, summaries and shared context via JSON with checkbox tree UI
 
 ## Installation
 
@@ -30,9 +37,23 @@ The installer will:
 2. Copy files to `~/.local/share/bterminal/`
 3. Create symlinks: `bterminal` and `ctx` in `~/.local/bin/`
 4. Initialize context database at `~/.claude-context/context.db`
-5. Add desktop entry to application menu
+5. Add desktop entry and icon to application menu
 
-### Manual dependency install (Debian/Ubuntu/Pop!_OS)
+### v2 Installation (Tauri — build from source)
+
+Requires Node.js 20+, Rust 1.77+, and system libraries (WebKit2GTK 4.1, GTK3, etc.).
+
+```bash
+git clone https://github.com/DexterFromLab/BTerminal.git
+cd BTerminal
+./install-v2.sh
+```
+
+The installer checks all dependencies, offers to install missing system packages via apt, builds the Tauri app, and installs the binary as `bterminal-v2` in `~/.local/bin/`.
+
+Pre-built .deb and AppImage packages are available from [GitHub Releases](https://github.com/DexterFromLab/BTerminal/releases) (built via CI on version tags).
+
+### v1 Manual dependency install (Debian/Ubuntu/Pop!_OS)
 
 ```bash
 sudo apt install python3-gi gir1.2-gtk-3.0 gir1.2-vte-2.91
@@ -46,23 +67,37 @@ bterminal
 
 ## Context Manager (ctx)
 
-`ctx` is a SQLite-based tool for managing persistent context across Claude Code sessions.
+`ctx` is a SQLite-based tool for managing persistent context across Claude Code sessions. It uses FTS5 full-text search and WAL journal mode.
 
 ```bash
 ctx init myproject "Project description" /path/to/project
-ctx get myproject                    # Load full context (shared + project)
+ctx get myproject                    # Load project context
+ctx get myproject --shared           # Include shared context
 ctx set myproject key "value"        # Save a context entry
-ctx shared set preferences "value"   # Save shared context (available in all projects)
+ctx append myproject key "more"      # Append to existing entry
+ctx shared set preferences "value"   # Save shared context (all projects)
 ctx summary myproject "What was done" # Save session summary
 ctx search "query"                   # Full-text search across everything
 ctx list                             # List all projects
 ctx history myproject                # Show session history
+ctx export                           # Export all data as JSON
+ctx delete myproject [key]           # Delete project or entry
 ctx --help                           # All commands
 ```
 
+### Ctx Manager Panel
+
+The sidebar **Ctx** tab provides a GUI for the context database:
+
+- Browse all projects and their entries in a tree view
+- View entry values and project details in the detail pane
+- Add, edit and delete projects and entries
+- **Export** — select specific projects, entries, summaries and shared context to save as JSON
+- **Import** — load a JSON file, preview contents with checkboxes, optionally overwrite existing entries
+
 ### Integration with Claude Code
 
-Add a `CLAUDE.md` to your project root:
+Add a `CLAUDE.md` to your project root (the Ctx Setup Wizard can generate this automatically):
 
 ```markdown
 On session start, load context:
@@ -80,8 +115,8 @@ Config files in `~/.config/bterminal/`:
 
 | File | Description |
 |------|-------------|
-| `sessions.json` | Saved SSH sessions + macros |
-| `claude_sessions.json` | Saved Claude Code configs |
+| `sessions.json` | SSH sessions and macros |
+| `claude_sessions.json` | Claude Code session configs |
 
 Context database: `~/.claude-context/context.db`
 
@@ -95,14 +130,65 @@ Context database: `~/.claude-context/context.db`
 | `Ctrl+Shift+V` | Paste |
 | `Ctrl+PageUp/Down` | Previous/next tab |
 
+## Multi-Machine Support (v2)
+
+BTerminal v2 can manage agents and terminals running on remote machines via the `bterminal-relay` binary.
+
+### Architecture
+
+```
+BTerminal (Controller) --WebSocket--> bterminal-relay (Remote Machine)
+                                      ├── PtyManager (remote terminals)
+                                      └── SidecarManager (remote agents)
+```
+
+### Running the Relay
+
+On each remote machine:
+
+```bash
+# Build the relay binary
+cd v2 && cargo build --release -p bterminal-relay
+
+# Start with token auth
+./target/release/bterminal-relay --port 9750 --token <secret>
+
+# Dev mode (allow unencrypted ws://)
+./target/release/bterminal-relay --port 9750 --token <secret> --insecure
+```
+
+Add remote machines in BTerminal Settings > Remote Machines (label, URL, token). Remote panes auto-group by machine label in the sidebar. Connections automatically reconnect with exponential backoff (1s-30s cap) on disconnect.
+
+See [docs/multi-machine.md](docs/multi-machine.md) for full architecture details.
+
+## Telemetry (v2)
+
+BTerminal supports OpenTelemetry tracing with optional export to Tempo + Grafana.
+
+```bash
+# Start the tracing stack
+cd docker/tempo && docker compose up -d
+# Grafana at http://localhost:9715
+
+# Run BTerminal with OTLP export enabled
+BTERMINAL_OTLP_ENDPOINT=http://localhost:4318 npm run tauri dev
+```
+
+Without `BTERMINAL_OTLP_ENDPOINT`, telemetry falls back to console-only tracing (no network calls). Key Tauri commands (PTY, agent, remote) are instrumented with `#[tracing::instrument]`. Frontend events (agent lifecycle, errors, cost) route to Rust tracing via IPC bridge.
+
 ## Documentation
 
 | Document | Description |
 |----------|-------------|
 | [docs/task_plan.md](docs/task_plan.md) | v2 architecture decisions, error handling, testing strategy |
-| [docs/phases.md](docs/phases.md) | v2 implementation phases (1-6) with checklists |
+| [docs/phases.md](docs/phases.md) | v2 implementation phases (1-7 + multi-machine A-D) with checklists |
 | [docs/findings.md](docs/findings.md) | Research findings (Agent SDK, Tauri, xterm.js, performance) |
-| [docs/progress.md](docs/progress.md) | Session-by-session progress log |
+| [docs/progress.md](docs/progress.md) | Session-by-session progress log (recent) |
+| [docs/progress-archive.md](docs/progress-archive.md) | Archived progress log (2026-03-05 to 2026-03-06 early) |
+| [docs/multi-machine.md](docs/multi-machine.md) | Multi-machine architecture (implemented, WebSocket relay, reconnection) |
+| [docs/v3-task_plan.md](docs/v3-task_plan.md) | v3 Mission Control redesign: architecture decisions and strategies |
+| [docs/v3-findings.md](docs/v3-findings.md) | v3 research findings and codebase reuse analysis |
+| [docs/v3-progress.md](docs/v3-progress.md) | v3 session progress log (All Phases 1-10 complete) |
 
 ## License
 
diff --git a/TODO.md b/TODO.md
index 86fc4cd..ccdcb9d 100644
--- a/TODO.md
+++ b/TODO.md
@@ -1,14 +1,28 @@
-# BTerminal — TODO
+# BTerminal -- TODO
 
 ## Active
 
-- [ ] **Phase 1: Project Scaffolding** — Create feature branch, init Tauri 2.x + Svelte 5, basic window with Catppuccin theme. See [docs/phases.md](docs/phases.md).
-- [ ] **Phase 2: Terminal Pane + Layout** — CSS Grid tiling, xterm.js with Canvas addon, PTY via portable-pty, SSH/shell/Claude CLI support.
-- [ ] **Phase 3: Agent SDK Integration** — Node.js sidecar, SDK message adapter, structured agent panes with tool call cards.
-- [ ] **Phase 4: Session Management + Markdown** — SQLite persistence, session CRUD, file watcher, markdown rendering. MVP ship after this phase.
-- [ ] **Benchmark Canvas xterm.js** — Verify <50ms latency with 4 panes on target hardware (Phase 2 gate for Electron escape hatch).
-- [ ] **Evaluate Deno as sidecar runtime** — Single binary, better packaging than Node.js. Test SDK compatibility.
+### Migration to agent-orchestrator
+- [ ] **Review Dexter's 13 feature commits** -- hib_changes rebased onto dexter_changes (55ba8d0). Need to review: Aider provider, splash screen, provider/model unification, Tier 2 btmsg access, auto-wake on btmsg. Then push hib_changes and start working from agent-orchestrator repo.
+- [ ] **CLAUDE.md Commit Zero** -- Update agent-orchestrator's CLAUDE.md to reflect rebrand + new features. Update docs/ accordingly.
+- [ ] **Switch primary development to agent-orchestrator** -- After review + CLAUDE.md update, develop on hib_changes in agent-orchestrator. BTerminal repo stays for v1 production only.
+
+### v3.1 Remaining
+- [ ] **Multi-machine real-world testing** -- TLS added to relay. Needs real 2-machine test. Multi-machine UI not surfaced in v3, code exists in bridges/stores only.
+- [ ] **Certificate pinning** -- TLS encryption done (v3.0). Pin cert hash in RemoteManager for v3.1.
+- [ ] **Agent Teams real-world testing** -- Subagent delegation prompt fix done + env var injection. Needs real multi-agent session to verify Manager spawns child agents.
+- [ ] **Plugin sandbox migration** -- `new Function()` has inherent escape vectors (prototype walking, arguments.callee.constructor). Consider Web Worker isolation for v3.2.
+- [ ] **Soak test** -- Run 4-hour soak with 6+ agents across 3+ projects. Monitor memory, SQLite WAL size, xterm.js instances.
+- [ ] **E2E agent tests hang in nested Claude sessions** -- B4/B5 phase-b tests timeout when run from within a Claude Code session (sidecar spawns Claude CLI which hangs in git repo context). Works in CI. Investigate process isolation or session nesting guard.
 
 ## Completed
 
-(none yet)
+- [x] **E2E fixture + judge hardening** -- Fixed fixture env propagation (process.env injection, tauri:options.env unreliable), LLM judge CLI context isolation (--setting-sources user, cwd /tmp, --system-prompt), mocha timeout 180s. Confirmed fixture fakes project list. Agent tests CI-only (nested Claude limitation). | Done: 2026-03-12
+- [x] **LLM judge refactor + E2E docs** -- Refactored llm-judge.ts to dual-mode (CLI first, API fallback), env-configurable via LLM_JUDGE_BACKEND. Wrote comprehensive docs/e2e-testing.md covering fixtures, test mode, LLM judge, all spec phases, CI, troubleshooting. 444 vitest + 151 cargo + 109 E2E. | Done: 2026-03-12
+- [x] **v3 Hardening Sprint** -- Fixed subagent delegation (prompt + env var), added TLS to relay, WAL checkpoint (5min), Landlock logging, plugin sandbox tests (35), gitignore fix. Phase C E2E tests (27 new, 3 pre-existing fixes). 444 vitest + 151 cargo + 109 E2E. | Done: 2026-03-12
+- [x] **v3 Production Readiness — ALL tribunal items** -- Implemented all 13 features from tribunal assessment: sidecar supervisor, notifications, secrets, keyboard UX, agent health, search, plugins, sandbox, error classifier, audit log, team agent orchestration, optimistic locking, usage meter. 409 vitest + 109 cargo. | Done: 2026-03-12
+- [x] **Unified test runner + testing gate rule** -- Created v2/scripts/test-all.sh (vitest + cargo + optional E2E), added npm scripts (test:all, test:all:e2e, test:cargo), added .claude/rules/20-testing-gate.md requiring full suite after major changes. | Done: 2026-03-12
+- [x] **E2E testing — Phase B+ & test fixes** -- Phase B: LLM judge (llm-judge.ts, claude-haiku-4-5), 6 multi-project scenarios, CI workflow (3 jobs). Test fixes: 27 failures across 3 spec files. 388 vitest + 68 cargo + 82 E2E (0 fail, 4 skip). | Done: 2026-03-12
+- [x] **Reviewer agent role** -- Tier 1 specialist with role='reviewer'. Reviewer workflow in agent-prompts.ts (8-step process). #review-queue/#review-log auto-channels. reviewQueueDepth in attention scoring (10pts/task, cap 50). 388 vitest + 76 cargo. | Done: 2026-03-12
+- [x] **Auto-wake Manager** -- wake-scheduler.svelte.ts + wake-scorer.ts (24 tests). 3 strategies: persistent/on-demand/smart. 6 signals. Settings UI. 381 vitest + 72 cargo. | Done: 2026-03-12
+- [x] **Dashboard metrics panel** -- MetricsPanel.svelte: live health + task board summary + SVG sparkline history. 25 tests. 357 vitest + 72 cargo. | Done: 2026-03-12
diff --git a/agent-orchestrator b/agent-orchestrator
new file mode 160000
index 0000000..55ba8d0
--- /dev/null
+++ b/agent-orchestrator
@@ -0,0 +1 @@
+Subproject commit 55ba8d0969b4c9e34e47fe621ea4812528441365
diff --git a/bterminal.py b/bterminal.py
index 3888a3d..91110b4 100755
--- a/bterminal.py
+++ b/bterminal.py
@@ -161,6 +161,36 @@ treeview:hover {{
     background: {CATPPUCCIN['surface2']};
     color: {CATPPUCCIN['red']};
 }}
+stackswitcher {{
+    background: {CATPPUCCIN['crust']};
+    border-bottom: 1px solid {CATPPUCCIN['surface0']};
+}}
+stackswitcher button {{
+    background: {CATPPUCCIN['crust']};
+    color: {CATPPUCCIN['subtext0']};
+    border: none;
+    border-radius: 0;
+    padding: 6px 16px;
+    border-bottom: 2px solid transparent;
+    font-weight: bold;
+    font-size: 12px;
+}}
+stackswitcher button:checked {{
+    background: {CATPPUCCIN['mantle']};
+    color: {CATPPUCCIN['blue']};
+    border-bottom: 2px solid {CATPPUCCIN['blue']};
+}}
+stackswitcher button:hover {{
+    background: {CATPPUCCIN['surface0']};
+}}
+textview.ctx-detail {{
+    font-family: monospace;
+    font-size: 10pt;
+}}
+textview.ctx-detail text {{
+    background-color: {CATPPUCCIN['crust']};
+    color: {CATPPUCCIN['subtext1']};
+}}
 """
 
 
@@ -680,9 +710,8 @@ class ClaudeCodeDialog(Gtk.Dialog):
         dir_box.pack_start(btn_browse, False, False, 0)
         grid.attach(dir_box, 1, 3, 1, 1)
 
-        self.btn_edit_ctx = Gtk.Button(label="Edit ctx entries\u2026")
-        self.btn_edit_ctx.connect("clicked", self._on_edit_ctx)
-        grid.attach(self.btn_edit_ctx, 1, 4, 1, 1)
+        self.lbl_ctx_status = Gtk.Label(xalign=0)
+        grid.attach(self.lbl_ctx_status, 1, 4, 1, 1)
 
         # Separator
         box.pack_start(Gtk.Separator(), False, False, 2)
@@ -728,6 +757,7 @@ class ClaudeCodeDialog(Gtk.Dialog):
                 self.textview.get_buffer().set_text(prompt)
 
         self.show_all()
+        self._update_ctx_status()
 
     def get_data(self):
         buf = self.textview.get_buffer()
@@ -762,16 +792,6 @@ class ClaudeCodeDialog(Gtk.Dialog):
         dlg.run()
         dlg.destroy()
 
-    def _on_edit_ctx(self, button):
-        project_dir = self.entry_project_dir.get_text().strip()
-        if not project_dir:
-            self._show_error("Set project directory first.")
-            return
-        ctx_project = os.path.basename(project_dir.rstrip("/"))
-        dlg = CtxEditDialog(self, ctx_project, project_dir)
-        dlg.run()
-        dlg.destroy()
-
     def _on_browse_dir(self, button):
         dlg = Gtk.FileChooserDialog(
             title="Select project directory",
@@ -801,56 +821,25 @@ class ClaudeCodeDialog(Gtk.Dialog):
                     f"Przed zakończeniem sesji: ctx summary {basename} \"<co zrobiliśmy>\""
                 )
                 buf.set_text(prompt)
+            self._update_ctx_status()
         dlg.destroy()
 
-    @staticmethod
-    def _detect_description(project_dir):
-        for name in ["README.md", "README.rst", "README.txt", "README"]:
-            readme_path = os.path.join(project_dir, name)
-            if os.path.isfile(readme_path):
-                try:
-                    with open(readme_path, "r") as f:
-                        for line in f:
-                            line = line.strip().lstrip("#").strip()
-                            if line:
-                                return line[:100]
-                except (IOError, UnicodeDecodeError):
-                    pass
-        return os.path.basename(project_dir.rstrip("/"))
-
-    def setup_ctx(self):
-        """Auto-initialize ctx project and generate CLAUDE.md if project_dir is set."""
+    def _update_ctx_status(self):
         project_dir = self.entry_project_dir.get_text().strip()
         if not project_dir:
+            self.lbl_ctx_status.set_text("")
             return
-        ctx_project = os.path.basename(project_dir.rstrip("/"))
-        ctx_desc = self._detect_description(project_dir)
-        try:
-            subprocess.run(
-                ["ctx", "init", ctx_project, ctx_desc, project_dir],
-                check=True, capture_output=True, text=True,
+        name = os.path.basename(project_dir.rstrip("/"))
+        if _is_ctx_project_registered(name):
+            self.lbl_ctx_status.set_markup(
+                '<small>\u2713 Ctx project "<b>'
+                + GLib.markup_escape_text(name)
+                + '</b>" is registered</small>'
             )
-        except (subprocess.CalledProcessError, FileNotFoundError):
-            return
-        claude_md = os.path.join(project_dir, "CLAUDE.md")
-        if not os.path.exists(claude_md):
-            claude_content = (
-                f"# {ctx_project}\n\n"
-                f"On session start, load context:\n"
-                f"```bash\n"
-                f"ctx get {ctx_project}\n"
-                f"```\n\n"
-                f"Context manager: `ctx --help`\n\n"
-                f"During work:\n"
-                f"- Save important discoveries: `ctx set {ctx_project} <key> <value>`\n"
-                f"- Append to existing: `ctx append {ctx_project} <key> <value>`\n"
-                f"- Before ending session: `ctx summary {ctx_project} \"<what was done>\"`\n"
+        else:
+            self.lbl_ctx_status.set_markup(
+                "<small>\u2139 New project \u2014 ctx wizard will guide you after save</small>"
             )
-            try:
-                with open(claude_md, "w") as f:
-                    f.write(claude_content)
-            except IOError:
-                pass
 
 
 # ─── CtxEditDialog ────────────────────────────────────────────────────────────
@@ -859,6 +848,377 @@ class ClaudeCodeDialog(Gtk.Dialog):
 CTX_DB = os.path.join(os.path.expanduser("~"), ".claude-context", "context.db")
 
 
+def _detect_project_description(project_dir):
+    """Detect project description from README or directory name."""
+    for name in ["README.md", "README.rst", "README.txt", "README"]:
+        readme_path = os.path.join(project_dir, name)
+        if os.path.isfile(readme_path):
+            try:
+                with open(readme_path, "r") as f:
+                    for line in f:
+                        line = line.strip().lstrip("#").strip()
+                        if line:
+                            return line[:100]
+            except (IOError, UnicodeDecodeError):
+                pass
+    return os.path.basename(project_dir.rstrip("/"))
+
+
+def _is_ctx_project_registered(project_name):
+    """Check if a ctx project is already registered in the database."""
+    if not os.path.exists(CTX_DB):
+        return False
+    import sqlite3
+    try:
+        db = sqlite3.connect(CTX_DB)
+        row = db.execute(
+            "SELECT 1 FROM sessions WHERE name = ?", (project_name,)
+        ).fetchone()
+        db.close()
+        return row is not None
+    except sqlite3.Error:
+        return False
+
+
+def _is_ctx_available():
+    """Check if ctx command is available."""
+    try:
+        subprocess.run(["ctx", "--version"], capture_output=True, timeout=5)
+        return True
+    except (FileNotFoundError, subprocess.TimeoutExpired):
+        return False
+
+
+def _run_ctx_wizard_if_needed(parent, data):
+    """Launch ctx wizard if project_dir is set but ctx not registered. Returns updated data."""
+    project_dir = data.get("project_dir", "")
+    if not project_dir or not _is_ctx_available():
+        return data
+    project_name = os.path.basename(project_dir.rstrip("/"))
+    if _is_ctx_project_registered(project_name):
+        return data
+    wizard = CtxSetupWizard(parent, project_dir)
+    if wizard.run_wizard():
+        if not data["prompt"] or data["prompt"].startswith("Wczytaj kontekst"):
+            data["prompt"] = wizard.result_prompt
+    return data
+
+
+_WIZARD_BACK = 1
+_WIZARD_NEXT = 2
+
+
+class CtxSetupWizard(Gtk.Dialog):
+    """Step-by-step wizard for initial ctx project setup."""
+
+    def __init__(self, parent, project_dir):
+        super().__init__(
+            title="Ctx — New Project Setup",
+            transient_for=parent,
+            modal=True,
+            destroy_with_parent=True,
+        )
+        self.set_default_size(540, -1)
+        self.set_resizable(False)
+        self.project_dir = project_dir
+        self.project_name = os.path.basename(project_dir.rstrip("/"))
+        self.success = False
+        self.result_prompt = ""
+        self._current_page = 0
+
+        box = self.get_content_area()
+        box.set_border_width(16)
+        box.set_spacing(12)
+
+        # Page header
+        self.lbl_header = Gtk.Label(xalign=0)
+        box.pack_start(self.lbl_header, False, False, 0)
+        box.pack_start(Gtk.Separator(), False, False, 0)
+
+        # Stack for pages
+        self.stack = Gtk.Stack()
+        self.stack.set_transition_type(Gtk.StackTransitionType.SLIDE_LEFT_RIGHT)
+        box.pack_start(self.stack, True, True, 0)
+
+        # Status bar (for errors)
+        self.lbl_status = Gtk.Label(xalign=0, wrap=True, max_width_chars=60)
+        box.pack_start(self.lbl_status, False, False, 0)
+
+        self._build_page_project()
+        self._build_page_entry()
+        self._build_page_confirm()
+
+        # Navigation buttons
+        self.btn_cancel = self.add_button("Cancel", Gtk.ResponseType.CANCEL)
+        self.btn_back = self.add_button("\u2190 Back", _WIZARD_BACK)
+        self.btn_next = self.add_button("Next \u2192", _WIZARD_NEXT)
+        self.btn_finish = self.add_button("\u2713 Create", Gtk.ResponseType.OK)
+
+        self._show_page(0)
+        self.show_all()
+
+    def _build_page_project(self):
+        page = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=10)
+
+        info = Gtk.Label(wrap=True, xalign=0, max_width_chars=58)
+        info.set_markup(
+            "Register the project in the ctx database.\n"
+            "The <b>project name</b> is used in all ctx commands "
+            "(e.g. <tt>ctx get MyProject</tt>).\n"
+            "<b>Description</b> helps Claude understand the project purpose."
+        )
+        page.pack_start(info, False, False, 0)
+
+        warn = Gtk.Label(wrap=True, xalign=0, max_width_chars=58)
+        warn.set_markup(
+            '<small>\u26a0 Case matters! "<tt>MyProject</tt>" \u2260 '
+            '"<tt>myproject</tt>". The name must match exactly in all commands.</small>'
+        )
+        page.pack_start(warn, False, False, 4)
+
+        grid = Gtk.Grid(column_spacing=12, row_spacing=8)
+
+        grid.attach(Gtk.Label(label="Directory:", halign=Gtk.Align.END), 0, 0, 1, 1)
+        lbl_dir = Gtk.Label(
+            label=self.project_dir, halign=Gtk.Align.START,
+            selectable=True, ellipsize=Pango.EllipsizeMode.MIDDLE,
+        )
+        grid.attach(lbl_dir, 1, 0, 1, 1)
+
+        grid.attach(Gtk.Label(label="Project name:", halign=Gtk.Align.END), 0, 1, 1, 1)
+        self.w_name = Gtk.Entry(hexpand=True)
+        self.w_name.set_text(self.project_name)
+        grid.attach(self.w_name, 1, 1, 1, 1)
+
+        grid.attach(Gtk.Label(label="Description:", halign=Gtk.Align.END), 0, 2, 1, 1)
+        self.w_desc = Gtk.Entry(hexpand=True)
+        self.w_desc.set_text(_detect_project_description(self.project_dir))
+        grid.attach(self.w_desc, 1, 2, 1, 1)
+
+        page.pack_start(grid, False, False, 0)
+        self.stack.add_named(page, "project")
+
+    def _build_page_entry(self):
+        page = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=10)
+
+        info = Gtk.Label(wrap=True, xalign=0, max_width_chars=58)
+        info.set_markup(
+            "Add the <b>first context entry</b>. Claude reads these at the start "
+            "of each session to understand the project.\n\n"
+            "Examples:\n"
+            '  Key: <tt>repo</tt>  Value: <tt>GitHub: .../MyRepo, branch: main</tt>\n'
+            '  Key: <tt>stack</tt>  Value: <tt>Python 3.12, Flask, PostgreSQL</tt>'
+        )
+        page.pack_start(info, False, False, 0)
+
+        grid = Gtk.Grid(column_spacing=12, row_spacing=8)
+
+        grid.attach(Gtk.Label(label="Key:", halign=Gtk.Align.END), 0, 0, 1, 1)
+        self.w_key = Gtk.Entry(hexpand=True)
+        self.w_key.set_placeholder_text("e.g. repo, stack, architecture")
+        grid.attach(self.w_key, 1, 0, 1, 1)
+
+        grid.attach(
+            Gtk.Label(label="Value:", halign=Gtk.Align.END, valign=Gtk.Align.START),
+            0, 1, 1, 1,
+        )
+        scrolled = Gtk.ScrolledWindow()
+        scrolled.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC)
+        scrolled.set_min_content_height(90)
+        self.w_value = Gtk.TextView(wrap_mode=Gtk.WrapMode.WORD_CHAR)
+        scrolled.add(self.w_value)
+        grid.attach(scrolled, 1, 1, 1, 1)
+
+        page.pack_start(grid, True, True, 0)
+        self.stack.add_named(page, "entry")
+
+    def _build_page_confirm(self):
+        page = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=10)
+
+        info = Gtk.Label(wrap=True, xalign=0, max_width_chars=58)
+        info.set_text("Review and confirm. The following actions will be performed:")
+        page.pack_start(info, False, False, 0)
+
+        self.lbl_summary = Gtk.Label(wrap=True, xalign=0, max_width_chars=58)
+        page.pack_start(self.lbl_summary, False, False, 0)
+
+        page.pack_start(Gtk.Separator(), False, False, 4)
+        self.stack.add_named(page, "confirm")
+
+    def _show_page(self, idx):
+        self._current_page = idx
+        pages = ["project", "entry", "confirm"]
+        self.stack.set_visible_child_name(pages[idx])
+        self.lbl_status.set_text("")
+
+        headers = [
+            "Step 1 of 3: Project registration",
+            "Step 2 of 3: First context entry",
+            "Step 3 of 3: Confirm and create",
+        ]
+        self.lbl_header.set_markup(f"<b>{headers[idx]}</b>")
+
+        if idx == 2:
+            self._update_summary()
+
+    def _update_buttons(self):
+        idx = self._current_page
+        self.btn_back.set_visible(idx > 0)
+        self.btn_next.set_visible(idx < 2)
+        self.btn_finish.set_visible(idx == 2)
+
+    def _update_summary(self):
+        name = self.w_name.get_text().strip()
+        desc = self.w_desc.get_text().strip()
+        key = self.w_key.get_text().strip()
+        buf = self.w_value.get_buffer()
+        s, e = buf.get_bounds()
+        value = buf.get_text(s, e, False).strip()
+        val_preview = value[:150] + ("\u2026" if len(value) > 150 else "")
+
+        self.lbl_summary.set_markup(
+            f"<tt>1.</tt> <tt>ctx init</tt> \u2014 register project "
+            f"<b>{GLib.markup_escape_text(name)}</b>\n"
+            f"     {GLib.markup_escape_text(desc)}\n\n"
+            f"<tt>2.</tt> <tt>ctx set</tt> \u2014 add entry "
+            f"<b>{GLib.markup_escape_text(key)}</b>\n"
+            f"     {GLib.markup_escape_text(val_preview)}\n\n"
+            f"<tt>3.</tt> Create <tt>CLAUDE.md</tt> in project directory\n"
+            f"     (will be skipped if file already exists)"
+        )
+
+    def _validate_page(self, idx):
+        if idx == 0:
+            name = self.w_name.get_text().strip()
+            desc = self.w_desc.get_text().strip()
+            if not name:
+                self.lbl_status.set_markup(
+                    '<span foreground="red">Project name is required.</span>'
+                )
+                self.w_name.grab_focus()
+                return False
+            if not desc:
+                self.lbl_status.set_markup(
+                    '<span foreground="red">Description is required.</span>'
+                )
+                self.w_desc.grab_focus()
+                return False
+        elif idx == 1:
+            key = self.w_key.get_text().strip()
+            buf = self.w_value.get_buffer()
+            s, e = buf.get_bounds()
+            value = buf.get_text(s, e, False).strip()
+            if not key:
+                self.lbl_status.set_markup(
+                    '<span foreground="red">Key is required. '
+                    'E.g. "repo", "stack", "notes".</span>'
+                )
+                self.w_key.grab_focus()
+                return False
+            if not value:
+                self.lbl_status.set_markup(
+                    '<span foreground="red">Value is required. '
+                    "Describe something about the project.</span>"
+                )
+                self.w_value.grab_focus()
+                return False
+        return True
+
+    def _execute(self):
+        """Run ctx init, ctx set, and create CLAUDE.md."""
+        name = self.w_name.get_text().strip()
+        desc = self.w_desc.get_text().strip()
+        key = self.w_key.get_text().strip()
+        buf = self.w_value.get_buffer()
+        s, e = buf.get_bounds()
+        value = buf.get_text(s, e, False).strip()
+
+        # 1. ctx init
+        try:
+            r = subprocess.run(
+                ["ctx", "init", name, desc, self.project_dir],
+                capture_output=True, text=True,
+            )
+            if r.returncode != 0:
+                self.lbl_status.set_markup(
+                    f'<span foreground="red">ctx init failed: '
+                    f"{GLib.markup_escape_text(r.stderr.strip())}</span>"
+                )
+                return False
+        except FileNotFoundError:
+            self.lbl_status.set_markup(
+                '<span foreground="red">ctx command not found.</span>'
+            )
+            return False
+
+        # 2. ctx set
+        try:
+            r = subprocess.run(
+                ["ctx", "set", name, key, value],
+                capture_output=True, text=True,
+            )
+            if r.returncode != 0:
+                self.lbl_status.set_markup(
+                    f'<span foreground="red">ctx set failed: '
+                    f"{GLib.markup_escape_text(r.stderr.strip())}</span>"
+                )
+                return False
+        except FileNotFoundError:
+            return False
+
+        # 3. CLAUDE.md
+        claude_md = os.path.join(self.project_dir, "CLAUDE.md")
+        if not os.path.exists(claude_md):
+            try:
+                with open(claude_md, "w") as f:
+                    f.write(
+                        f"# {name}\n\n"
+                        f"On session start, load context:\n"
+                        f"```bash\n"
+                        f"ctx get {name}\n"
+                        f"```\n\n"
+                        f"Context manager: `ctx --help`\n\n"
+                        f"During work:\n"
+                        f"- Save important discoveries: `ctx set {name} <key> <value>`\n"
+                        f"- Append to existing: `ctx append {name} <key> <value>`\n"
+                        f'- Before ending session: `ctx summary {name} "<what was done>"`\n'
+                    )
+            except IOError as e:
+                self.lbl_status.set_markup(
+                    f'<span foreground="red">CLAUDE.md: {GLib.markup_escape_text(str(e))}</span>'
+                )
+                return False
+
+        self.project_name = name
+        self.result_prompt = (
+            f"Wczytaj kontekst projektu poleceniem: ctx get {name}\n"
+            f"Wykonaj t\u0119 komend\u0119 i zapoznaj si\u0119 z kontekstem zanim zaczniesz prac\u0119.\n"
+            f"Kontekst zarz\u0105dzasz przez: ctx --help\n"
+            f"Wa\u017cne odkrycia zapisuj: ctx set {name} <key> <value>\n"
+            f'Przed zako\u0144czeniem sesji: ctx summary {name} "<co zrobili\u015bmy>"'
+        )
+        self.success = True
+        return True
+
+    def run_wizard(self):
+        """Run the wizard. Returns True if completed successfully."""
+        while True:
+            self._update_buttons()
+            resp = self.run()
+            if resp == _WIZARD_NEXT:
+                if self._validate_page(self._current_page):
+                    self._show_page(self._current_page + 1)
+            elif resp == _WIZARD_BACK:
+                self._show_page(self._current_page - 1)
+            elif resp == Gtk.ResponseType.OK:
+                if self._execute():
+                    self.destroy()
+                    return True
+            else:
+                self.destroy()
+                return False
+
+
 class _CtxEntryDialog(Gtk.Dialog):
     """Small dialog for adding/editing a ctx key-value entry."""
 
@@ -909,6 +1269,78 @@ class _CtxEntryDialog(Gtk.Dialog):
         return key, value
 
 
+class _CtxProjectDialog(Gtk.Dialog):
+    """Dialog for adding/editing a ctx project."""
+
+    def __init__(self, parent, title="New Project", name="", description="", work_dir=""):
+        super().__init__(
+            title=title,
+            transient_for=parent,
+            modal=True,
+            destroy_with_parent=True,
+        )
+        self.add_buttons(
+            Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL,
+            Gtk.STOCK_OK, Gtk.ResponseType.OK,
+        )
+        self.set_default_size(450, -1)
+        self.set_default_response(Gtk.ResponseType.OK)
+
+        box = self.get_content_area()
+        box.set_border_width(12)
+        box.set_spacing(8)
+
+        grid = Gtk.Grid(column_spacing=12, row_spacing=8)
+        box.pack_start(grid, True, True, 0)
+
+        grid.attach(Gtk.Label(label="Name:", halign=Gtk.Align.END), 0, 0, 1, 1)
+        self.entry_name = Gtk.Entry(hexpand=True)
+        self.entry_name.set_text(name)
+        grid.attach(self.entry_name, 1, 0, 1, 1)
+
+        grid.attach(Gtk.Label(label="Description:", halign=Gtk.Align.END), 0, 1, 1, 1)
+        self.entry_desc = Gtk.Entry(hexpand=True)
+        self.entry_desc.set_text(description)
+        grid.attach(self.entry_desc, 1, 1, 1, 1)
+
+        grid.attach(Gtk.Label(label="Directory:", halign=Gtk.Align.END), 0, 2, 1, 1)
+        dir_box = Gtk.Box(spacing=4)
+        self.entry_dir = Gtk.Entry(hexpand=True)
+        self.entry_dir.set_text(work_dir)
+        self.entry_dir.set_placeholder_text("(optional) path to project directory")
+        dir_box.pack_start(self.entry_dir, True, True, 0)
+        btn_browse = Gtk.Button(label="Browse\u2026")
+        btn_browse.connect("clicked", self._on_browse)
+        dir_box.pack_start(btn_browse, False, False, 0)
+        grid.attach(dir_box, 1, 2, 1, 1)
+
+        self.show_all()
+
+    def _on_browse(self, button):
+        dlg = Gtk.FileChooserDialog(
+            title="Select directory",
+            parent=self,
+            action=Gtk.FileChooserAction.SELECT_FOLDER,
+        )
+        dlg.add_buttons(
+            Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL,
+            Gtk.STOCK_OPEN, Gtk.ResponseType.OK,
+        )
+        if dlg.run() == Gtk.ResponseType.OK:
+            path = dlg.get_filename()
+            self.entry_dir.set_text(path)
+            if not self.entry_name.get_text().strip():
+                self.entry_name.set_text(os.path.basename(path.rstrip("/")))
+        dlg.destroy()
+
+    def get_data(self):
+        return (
+            self.entry_name.get_text().strip(),
+            self.entry_desc.get_text().strip(),
+            self.entry_dir.get_text().strip(),
+        )
+
+
 class CtxEditDialog(Gtk.Dialog):
     """Dialog to view and edit ctx project entries."""
 
@@ -1072,7 +1504,7 @@ class TerminalTab(Gtk.Box):
         self.terminal = Vte.Terminal()
         self.terminal.set_font(Pango.FontDescription(FONT))
         self.terminal.set_scrollback_lines(SCROLLBACK_LINES)
-        self.terminal.set_scroll_on_output(True)
+        self.terminal.set_scroll_on_output(False)
         self.terminal.set_scroll_on_keystroke(True)
         self.terminal.set_audible_bell(False)
 
@@ -1301,6 +1733,9 @@ class TerminalTab(Gtk.Box):
             if self.session:
                 # SSH tab: keep session name, show VTE title in window title only
                 self.app.update_tab_title(self, self.session.get("name", "SSH"))
+            elif self.claude_config:
+                # Claude Code tab: keep config name instead of generic VTE title
+                self.app.update_tab_title(self, self.claude_config.get("name", "Claude Code"))
             else:
                 self.app.update_tab_title(self, title)
 
@@ -1329,8 +1764,6 @@ class SessionSidebar(Gtk.Box):
     def __init__(self, app):
         super().__init__(orientation=Gtk.Orientation.VERTICAL)
         self.app = app
-        self.get_style_context().add_class("sidebar")
-        self.set_size_request(250, -1)
 
         # Header
         header = Gtk.Label(label=f"  {APP_NAME} Sessions")
@@ -1658,8 +2091,9 @@ class SessionSidebar(Gtk.Box):
             if resp != Gtk.ResponseType.OK:
                 break
             if dlg.validate():
-                dlg.setup_ctx()
-                self.app.claude_manager.add(dlg.get_data())
+                data = dlg.get_data()
+                data = _run_ctx_wizard_if_needed(dlg, data)
+                self.app.claude_manager.add(data)
                 self.refresh()
                 break
         dlg.destroy()
@@ -1827,8 +2261,8 @@ class SessionSidebar(Gtk.Box):
             if resp != Gtk.ResponseType.OK:
                 break
             if dlg.validate():
-                dlg.setup_ctx()
                 data = dlg.get_data()
+                data = _run_ctx_wizard_if_needed(dlg, data)
                 self.app.claude_manager.update(claude_id, data)
                 self.refresh()
                 break
@@ -1847,10 +2281,1118 @@ class SessionSidebar(Gtk.Box):
         )
         if dlg.run() == Gtk.ResponseType.YES:
             self.app.claude_manager.delete(claude_id)
+            # Ask about ctx cleanup
+            project_dir = config.get("project_dir", "")
+            if project_dir:
+                ctx_name = os.path.basename(project_dir.rstrip("/"))
+                if _is_ctx_available() and _is_ctx_project_registered(ctx_name):
+                    ctx_dlg = Gtk.MessageDialog(
+                        transient_for=self.app,
+                        modal=True,
+                        message_type=Gtk.MessageType.QUESTION,
+                        buttons=Gtk.ButtonsType.YES_NO,
+                        text=f"Also delete ctx project \"{ctx_name}\"?",
+                    )
+                    ctx_dlg.format_secondary_text(
+                        "This will remove all context entries for this project from the ctx database."
+                    )
+                    if ctx_dlg.run() == Gtk.ResponseType.YES:
+                        subprocess.run(
+                            ["ctx", "delete", ctx_name],
+                            capture_output=True, text=True,
+                        )
+                    ctx_dlg.destroy()
             self.refresh()
         dlg.destroy()
 
 
+# ─── Ctx Import / Export ──────────────────────────────────────────────────────
+
+
+class _CtxExportDialog(Gtk.Dialog):
+    """Dialog for selectively exporting ctx data to a JSON file."""
+
+    def __init__(self, parent):
+        super().__init__(
+            title="Export Context",
+            transient_for=parent,
+            modal=True,
+            destroy_with_parent=True,
+        )
+        self.add_buttons(
+            Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL,
+            "Export", Gtk.ResponseType.OK,
+        )
+        self.set_default_size(500, 450)
+        self.set_default_response(Gtk.ResponseType.OK)
+
+        box = self.get_content_area()
+        box.set_border_width(12)
+        box.set_spacing(8)
+
+        # Select all / Deselect all
+        sel_box = Gtk.Box(spacing=8)
+        btn_all = Gtk.Button(label="Select All")
+        btn_all.connect("clicked", lambda _: self._set_all(True))
+        btn_none = Gtk.Button(label="Deselect All")
+        btn_none.connect("clicked", lambda _: self._set_all(False))
+        sel_box.pack_start(btn_all, False, False, 0)
+        sel_box.pack_start(btn_none, False, False, 0)
+        box.pack_start(sel_box, False, False, 0)
+
+        # Tree with checkboxes: toggle, icon, name, data_type, data_key
+        self.store = Gtk.TreeStore(bool, str, str, str, str)
+        self.tree = Gtk.TreeView(model=self.store)
+        self.tree.set_headers_visible(False)
+
+        col = Gtk.TreeViewColumn()
+        cell_toggle = Gtk.CellRendererToggle()
+        cell_toggle.connect("toggled", self._on_toggled)
+        col.pack_start(cell_toggle, False)
+        col.add_attribute(cell_toggle, "active", 0)
+
+        cell_icon = Gtk.CellRendererText()
+        col.pack_start(cell_icon, False)
+        col.add_attribute(cell_icon, "text", 1)
+
+        cell_name = Gtk.CellRendererText()
+        cell_name.set_property("ellipsize", Pango.EllipsizeMode.END)
+        col.pack_start(cell_name, True)
+        col.add_attribute(cell_name, "text", 2)
+
+        self.tree.append_column(col)
+
+        scroll = Gtk.ScrolledWindow()
+        scroll.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC)
+        scroll.add(self.tree)
+        box.pack_start(scroll, True, True, 0)
+
+        self._load_data()
+        self.show_all()
+
+    def _load_data(self):
+        import sqlite3
+        if not os.path.exists(CTX_DB):
+            return
+        db = sqlite3.connect(CTX_DB)
+        db.row_factory = sqlite3.Row
+
+        projects = db.execute(
+            "SELECT name FROM sessions ORDER BY name"
+        ).fetchall()
+        for proj in projects:
+            pname = proj["name"]
+            proj_iter = self.store.append(None, [
+                True, "\U0001f4c1", pname, "project", pname,
+            ])
+            entries = db.execute(
+                "SELECT key FROM contexts WHERE project = ? ORDER BY key",
+                (pname,),
+            ).fetchall()
+            for entry in entries:
+                self.store.append(proj_iter, [
+                    True, " ", entry["key"], "entry", entry["key"],
+                ])
+            scount = db.execute(
+                "SELECT COUNT(*) as c FROM summaries WHERE project = ?",
+                (pname,),
+            ).fetchone()["c"]
+            if scount:
+                self.store.append(proj_iter, [
+                    True, "\U0001f4cb", f"Summaries ({scount})", "summaries", pname,
+                ])
+
+        shared = db.execute("SELECT key FROM shared ORDER BY key").fetchall()
+        if shared:
+            shared_iter = self.store.append(None, [
+                True, "\U0001f517", "Shared", "shared", "",
+            ])
+            for entry in shared:
+                self.store.append(shared_iter, [
+                    True, " ", entry["key"], "shared_entry", entry["key"],
+                ])
+
+        db.close()
+        self.tree.expand_all()
+
+    def _on_toggled(self, renderer, path):
+        it = self.store.get_iter(path)
+        new_val = not self.store.get_value(it, 0)
+        self.store.set_value(it, 0, new_val)
+        # Propagate to children
+        child = self.store.iter_children(it)
+        while child:
+            self.store.set_value(child, 0, new_val)
+            child = self.store.iter_next(child)
+        # Update parent based on children
+        parent = self.store.iter_parent(it)
+        if parent:
+            any_checked = False
+            child = self.store.iter_children(parent)
+            while child:
+                if self.store.get_value(child, 0):
+                    any_checked = True
+                    break
+                child = self.store.iter_next(child)
+            self.store.set_value(parent, 0, any_checked)
+
+    def _set_all(self, val):
+        def _walk(it):
+            while it:
+                self.store.set_value(it, 0, val)
+                child = self.store.iter_children(it)
+                if child:
+                    _walk(child)
+                it = self.store.iter_next(it)
+        root = self.store.get_iter_first()
+        if root:
+            _walk(root)
+
+    def get_export_data(self):
+        """Collect checked items and return export dict."""
+        import sqlite3
+        if not os.path.exists(CTX_DB):
+            return None
+        db = sqlite3.connect(CTX_DB)
+        db.row_factory = sqlite3.Row
+        data = {"sessions": [], "contexts": [], "shared": [], "summaries": []}
+
+        root = self.store.get_iter_first()
+        while root:
+            dtype = self.store.get_value(root, 3)
+            dkey = self.store.get_value(root, 4)
+
+            if dtype == "project":
+                proj_name = dkey
+                child = self.store.iter_children(root)
+                checked_entries = []
+                include_summaries = False
+                while child:
+                    if self.store.get_value(child, 0):
+                        ctype = self.store.get_value(child, 3)
+                        ckey = self.store.get_value(child, 4)
+                        if ctype == "entry":
+                            checked_entries.append(ckey)
+                        elif ctype == "summaries":
+                            include_summaries = True
+                    child = self.store.iter_next(child)
+
+                if checked_entries or include_summaries or self.store.get_value(root, 0):
+                    row = db.execute(
+                        "SELECT * FROM sessions WHERE name = ?", (proj_name,)
+                    ).fetchone()
+                    if row:
+                        data["sessions"].append(dict(row))
+
+                for ekey in checked_entries:
+                    row = db.execute(
+                        "SELECT project, key, value, updated_at FROM contexts "
+                        "WHERE project = ? AND key = ?",
+                        (proj_name, ekey),
+                    ).fetchone()
+                    if row:
+                        data["contexts"].append(dict(row))
+
+                if include_summaries:
+                    rows = db.execute(
+                        "SELECT project, summary, created_at FROM summaries "
+                        "WHERE project = ?",
+                        (proj_name,),
+                    ).fetchall()
+                    data["summaries"].extend(dict(r) for r in rows)
+
+            elif dtype == "shared":
+                child = self.store.iter_children(root)
+                while child:
+                    if self.store.get_value(child, 0):
+                        skey = self.store.get_value(child, 4)
+                        row = db.execute(
+                            "SELECT * FROM shared WHERE key = ?", (skey,)
+                        ).fetchone()
+                        if row:
+                            data["shared"].append(dict(row))
+                    child = self.store.iter_next(child)
+
+            root = self.store.iter_next(root)
+        db.close()
+
+        data = {k: v for k, v in data.items() if v}
+        if not data:
+            return None
+        data["_export_version"] = 1
+        return data
+
+
+class _CtxImportDialog(Gtk.Dialog):
+    """Dialog for importing ctx data from a JSON file."""
+
+    def __init__(self, parent):
+        super().__init__(
+            title="Import Context",
+            transient_for=parent,
+            modal=True,
+            destroy_with_parent=True,
+        )
+        self.add_buttons(
+            Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL,
+            "Import", Gtk.ResponseType.OK,
+        )
+        self.set_default_size(500, 450)
+        self.set_default_response(Gtk.ResponseType.OK)
+        self.set_response_sensitive(Gtk.ResponseType.OK, False)
+
+        box = self.get_content_area()
+        box.set_border_width(12)
+        box.set_spacing(8)
+
+        # File chooser
+        file_box = Gtk.Box(spacing=8)
+        file_box.pack_start(Gtk.Label(label="File:"), False, False, 0)
+        self.file_entry = Gtk.Entry(hexpand=True)
+        self.file_entry.set_placeholder_text("Select JSON file\u2026")
+        self.file_entry.set_editable(False)
+        file_box.pack_start(self.file_entry, True, True, 0)
+        btn_browse = Gtk.Button(label="Browse\u2026")
+        btn_browse.connect("clicked", self._on_browse)
+        file_box.pack_start(btn_browse, False, False, 0)
+        box.pack_start(file_box, False, False, 0)
+
+        # Select all / Deselect all
+        sel_box = Gtk.Box(spacing=8)
+        btn_all = Gtk.Button(label="Select All")
+        btn_all.connect("clicked", lambda _: self._set_all(True))
+        btn_none = Gtk.Button(label="Deselect All")
+        btn_none.connect("clicked", lambda _: self._set_all(False))
+        sel_box.pack_start(btn_all, False, False, 0)
+        sel_box.pack_start(btn_none, False, False, 0)
+        box.pack_start(sel_box, False, False, 0)
+
+        # Preview tree: toggle, icon, name, data_type, data_key
+        self.store = Gtk.TreeStore(bool, str, str, str, str)
+        self.tree = Gtk.TreeView(model=self.store)
+        self.tree.set_headers_visible(False)
+
+        col = Gtk.TreeViewColumn()
+        cell_toggle = Gtk.CellRendererToggle()
+        cell_toggle.connect("toggled", self._on_toggled)
+        col.pack_start(cell_toggle, False)
+        col.add_attribute(cell_toggle, "active", 0)
+
+        cell_icon = Gtk.CellRendererText()
+        col.pack_start(cell_icon, False)
+        col.add_attribute(cell_icon, "text", 1)
+
+        cell_name = Gtk.CellRendererText()
+        cell_name.set_property("ellipsize", Pango.EllipsizeMode.END)
+        col.pack_start(cell_name, True)
+        col.add_attribute(cell_name, "text", 2)
+
+        self.tree.append_column(col)
+
+        scroll = Gtk.ScrolledWindow()
+        scroll.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC)
+        scroll.add(self.tree)
+        box.pack_start(scroll, True, True, 0)
+
+        # Overwrite option
+        self.chk_overwrite = Gtk.CheckButton(label="Overwrite existing entries")
+        box.pack_start(self.chk_overwrite, False, False, 0)
+
+        self.import_data = None
+        self.show_all()
+
+    def _on_browse(self, button):
+        dlg = Gtk.FileChooserDialog(
+            title="Select context file",
+            parent=self,
+            action=Gtk.FileChooserAction.OPEN,
+        )
+        dlg.add_buttons(
+            Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL,
+            Gtk.STOCK_OPEN, Gtk.ResponseType.OK,
+        )
+        filt = Gtk.FileFilter()
+        filt.set_name("JSON files")
+        filt.add_pattern("*.json")
+        dlg.add_filter(filt)
+        filt_all = Gtk.FileFilter()
+        filt_all.set_name("All files")
+        filt_all.add_pattern("*")
+        dlg.add_filter(filt_all)
+        if dlg.run() == Gtk.ResponseType.OK:
+            path = dlg.get_filename()
+            self.file_entry.set_text(path)
+            self._load_preview(path)
+        dlg.destroy()
+
+    def _load_preview(self, path):
+        self.store.clear()
+        self.import_data = None
+        self.set_response_sensitive(Gtk.ResponseType.OK, False)
+        try:
+            with open(path, "r") as f:
+                data = json.load(f)
+        except (json.JSONDecodeError, OSError) as e:
+            dlg = Gtk.MessageDialog(
+                transient_for=self,
+                modal=True,
+                message_type=Gtk.MessageType.ERROR,
+                buttons=Gtk.ButtonsType.OK,
+                text=f"Failed to load file: {e}",
+            )
+            dlg.run()
+            dlg.destroy()
+            return
+
+        self.import_data = data
+
+        # Group by project
+        sessions = {s["name"]: s for s in data.get("sessions", [])}
+        contexts_by_proj = {}
+        for ctx in data.get("contexts", []):
+            contexts_by_proj.setdefault(ctx["project"], []).append(ctx)
+        summaries_by_proj = {}
+        for s in data.get("summaries", []):
+            summaries_by_proj.setdefault(s["project"], []).append(s)
+
+        all_projects = sorted(
+            set(sessions) | set(contexts_by_proj) | set(summaries_by_proj)
+        )
+        for proj_name in all_projects:
+            proj_iter = self.store.append(None, [
+                True, "\U0001f4c1", proj_name, "project", proj_name,
+            ])
+            for ctx in contexts_by_proj.get(proj_name, []):
+                self.store.append(proj_iter, [
+                    True, " ", ctx["key"], "entry", ctx["key"],
+                ])
+            scount = len(summaries_by_proj.get(proj_name, []))
+            if scount:
+                self.store.append(proj_iter, [
+                    True, "\U0001f4cb", f"Summaries ({scount})", "summaries", proj_name,
+                ])
+
+        shared = data.get("shared", [])
+        if shared:
+            shared_iter = self.store.append(None, [
+                True, "\U0001f517", "Shared", "shared", "",
+            ])
+            for entry in shared:
+                self.store.append(shared_iter, [
+                    True, " ", entry["key"], "shared_entry", entry["key"],
+                ])
+
+        self.tree.expand_all()
+        self.set_response_sensitive(Gtk.ResponseType.OK, True)
+
+    def _on_toggled(self, renderer, path):
+        it = self.store.get_iter(path)
+        new_val = not self.store.get_value(it, 0)
+        self.store.set_value(it, 0, new_val)
+        child = self.store.iter_children(it)
+        while child:
+            self.store.set_value(child, 0, new_val)
+            child = self.store.iter_next(child)
+        parent = self.store.iter_parent(it)
+        if parent:
+            any_checked = False
+            child = self.store.iter_children(parent)
+            while child:
+                if self.store.get_value(child, 0):
+                    any_checked = True
+                    break
+                child = self.store.iter_next(child)
+            self.store.set_value(parent, 0, any_checked)
+
+    def _set_all(self, val):
+        def _walk(it):
+            while it:
+                self.store.set_value(it, 0, val)
+                child = self.store.iter_children(it)
+                if child:
+                    _walk(child)
+                it = self.store.iter_next(it)
+        root = self.store.get_iter_first()
+        if root:
+            _walk(root)
+
+    def get_selected_data(self):
+        """Return (filtered_data_dict, overwrite_bool) or (None, False)."""
+        if not self.import_data:
+            return None, False
+
+        data = self.import_data
+        overwrite = self.chk_overwrite.get_active()
+        sessions_map = {s["name"]: s for s in data.get("sessions", [])}
+        contexts_by_proj = {}
+        for ctx in data.get("contexts", []):
+            contexts_by_proj.setdefault(ctx["project"], []).append(ctx)
+        summaries_by_proj = {}
+        for s in data.get("summaries", []):
+            summaries_by_proj.setdefault(s["project"], []).append(s)
+        shared_map = {s["key"]: s for s in data.get("shared", [])}
+
+        result = {"sessions": [], "contexts": [], "shared": [], "summaries": []}
+
+        root = self.store.get_iter_first()
+        while root:
+            dtype = self.store.get_value(root, 3)
+            dkey = self.store.get_value(root, 4)
+
+            if dtype == "project":
+                proj_name = dkey
+                child = self.store.iter_children(root)
+                checked_entries = []
+                include_summaries = False
+                while child:
+                    if self.store.get_value(child, 0):
+                        ctype = self.store.get_value(child, 3)
+                        ckey = self.store.get_value(child, 4)
+                        if ctype == "entry":
+                            checked_entries.append(ckey)
+                        elif ctype == "summaries":
+                            include_summaries = True
+                    child = self.store.iter_next(child)
+
+                if checked_entries or include_summaries:
+                    if proj_name in sessions_map:
+                        result["sessions"].append(sessions_map[proj_name])
+                    for ekey in checked_entries:
+                        for ctx in contexts_by_proj.get(proj_name, []):
+                            if ctx["key"] == ekey:
+                                result["contexts"].append(ctx)
+                                break
+                    if include_summaries:
+                        result["summaries"].extend(
+                            summaries_by_proj.get(proj_name, [])
+                        )
+
+            elif dtype == "shared":
+                child = self.store.iter_children(root)
+                while child:
+                    if self.store.get_value(child, 0):
+                        skey = self.store.get_value(child, 4)
+                        if skey in shared_map:
+                            result["shared"].append(shared_map[skey])
+                    child = self.store.iter_next(child)
+
+            root = self.store.iter_next(root)
+
+        result = {k: v for k, v in result.items() if v}
+        return (result if result else None), overwrite
+
+
+# ─── CtxManagerPanel ──────────────────────────────────────────────────────────
+
+
+class CtxManagerPanel(Gtk.Box):
+    """Panel for browsing and managing ctx project contexts."""
+
+    def __init__(self, app):
+        super().__init__(orientation=Gtk.Orientation.VERTICAL)
+        self.app = app
+
+        # Paned: tree on top, detail on bottom
+        paned = Gtk.VPaned()
+        self.pack_start(paned, True, True, 0)
+
+        # ── Tree ──
+        # Columns: icon, display_name, project, key, color, weight
+        self.store = Gtk.TreeStore(str, str, str, str, str, int)
+        self.tree = Gtk.TreeView(model=self.store)
+        self.tree.set_headers_visible(False)
+        self.tree.set_activate_on_single_click(False)
+
+        col = Gtk.TreeViewColumn()
+        cell_icon = Gtk.CellRendererText()
+        col.pack_start(cell_icon, False)
+        col.add_attribute(cell_icon, "text", 0)
+
+        cell_name = Gtk.CellRendererText()
+        cell_name.set_property("ellipsize", Pango.EllipsizeMode.END)
+        col.pack_start(cell_name, True)
+        col.add_attribute(cell_name, "text", 1)
+        col.add_attribute(cell_name, "foreground", 4)
+        col.add_attribute(cell_name, "weight", 5)
+
+        self.tree.append_column(col)
+
+        tree_scroll = Gtk.ScrolledWindow()
+        tree_scroll.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC)
+        tree_scroll.add(self.tree)
+        paned.pack1(tree_scroll, resize=True, shrink=False)
+
+        # ── Detail pane ──
+        detail_box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
+
+        self.detail_header = Gtk.Label(xalign=0)
+        self.detail_header.set_margin_start(8)
+        self.detail_header.set_margin_top(4)
+        detail_box.pack_start(self.detail_header, False, False, 0)
+
+        detail_scroll = Gtk.ScrolledWindow()
+        detail_scroll.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC)
+        detail_scroll.set_min_content_height(80)
+        self.detail_view = Gtk.TextView()
+        self.detail_view.set_editable(False)
+        self.detail_view.set_cursor_visible(False)
+        self.detail_view.set_wrap_mode(Gtk.WrapMode.WORD_CHAR)
+        self.detail_view.set_left_margin(8)
+        self.detail_view.set_right_margin(8)
+        self.detail_view.set_top_margin(4)
+        self.detail_view.set_bottom_margin(4)
+        self.detail_view.get_style_context().add_class("ctx-detail")
+        detail_scroll.add(self.detail_view)
+        detail_box.pack_start(detail_scroll, True, True, 0)
+
+        paned.pack2(detail_box, resize=False, shrink=False)
+        paned.set_position(300)
+
+        # ── Buttons ──
+        btn_box = Gtk.Box(spacing=4)
+        btn_box.set_border_width(6)
+
+        btn_add = Gtk.MenuButton(label="Add \u25be")
+        btn_add.get_style_context().add_class("sidebar-btn")
+        add_menu = Gtk.Menu()
+        item_proj = Gtk.MenuItem(label="New Project")
+        item_proj.connect("activate", lambda _: self._on_add_project())
+        add_menu.append(item_proj)
+        item_entry = Gtk.MenuItem(label="New Entry")
+        item_entry.connect("activate", lambda _: self._on_add_entry())
+        add_menu.append(item_entry)
+        add_menu.show_all()
+        btn_add.set_popup(add_menu)
+
+        btn_edit = Gtk.Button(label="Edit")
+        btn_edit.get_style_context().add_class("sidebar-btn")
+        btn_edit.connect("clicked", lambda _: self._on_edit())
+
+        btn_del = Gtk.Button(label="Delete")
+        btn_del.get_style_context().add_class("sidebar-btn")
+        btn_del.connect("clicked", lambda _: self._on_delete())
+
+        btn_refresh = Gtk.Button(label="\u21bb")
+        btn_refresh.get_style_context().add_class("sidebar-btn")
+        btn_refresh.set_tooltip_text("Refresh")
+        btn_refresh.connect("clicked", lambda _: self.refresh())
+
+        btn_more = Gtk.MenuButton(label="\u22ee")
+        btn_more.get_style_context().add_class("sidebar-btn")
+        btn_more.set_tooltip_text("More actions")
+        more_menu = Gtk.Menu()
+        item_export = Gtk.MenuItem(label="Export\u2026")
+        item_export.connect("activate", lambda _: self._on_export())
+        more_menu.append(item_export)
+        item_import = Gtk.MenuItem(label="Import\u2026")
+        item_import.connect("activate", lambda _: self._on_import())
+        more_menu.append(item_import)
+        more_menu.show_all()
+        btn_more.set_popup(more_menu)
+
+        btn_box.pack_start(btn_add, True, True, 0)
+        btn_box.pack_start(btn_edit, True, True, 0)
+        btn_box.pack_start(btn_del, True, True, 0)
+        btn_box.pack_start(btn_refresh, False, False, 0)
+        btn_box.pack_start(btn_more, False, False, 0)
+        self.pack_start(btn_box, False, False, 0)
+
+        # Signals
+        self.tree.connect("row-activated", self._on_row_activated)
+        self.tree.connect("button-press-event", self._on_button_press)
+        self.tree.get_selection().connect("changed", self._on_selection_changed)
+
+        self.refresh()
+
+    def refresh(self):
+        """Reload all data from the ctx database."""
+        self.store.clear()
+        self.detail_header.set_text("")
+        self.detail_view.get_buffer().set_text("")
+        if not os.path.exists(CTX_DB):
+            return
+
+        import sqlite3
+        db = sqlite3.connect(CTX_DB)
+        db.row_factory = sqlite3.Row
+
+        projects = db.execute(
+            "SELECT name, description, work_dir FROM sessions ORDER BY name"
+        ).fetchall()
+
+        for proj in projects:
+            proj_iter = self.store.append(None, [
+                "\U0001f4c1",
+                proj["name"],
+                proj["name"],
+                "",
+                CATPPUCCIN["blue"],
+                Pango.Weight.BOLD,
+            ])
+            entries = db.execute(
+                "SELECT key FROM contexts WHERE project = ? ORDER BY key",
+                (proj["name"],),
+            ).fetchall()
+            for entry in entries:
+                self.store.append(proj_iter, [
+                    " ",
+                    entry["key"],
+                    proj["name"],
+                    entry["key"],
+                    CATPPUCCIN["text"],
+                    Pango.Weight.NORMAL,
+                ])
+
+        # Shared entries
+        shared = db.execute("SELECT key FROM shared ORDER BY key").fetchall()
+        if shared:
+            shared_iter = self.store.append(None, [
+                "\U0001f517",
+                "Shared",
+                "__shared__",
+                "",
+                CATPPUCCIN["peach"],
+                Pango.Weight.BOLD,
+            ])
+            for entry in shared:
+                self.store.append(shared_iter, [
+                    " ",
+                    entry["key"],
+                    "__shared__",
+                    entry["key"],
+                    CATPPUCCIN["text"],
+                    Pango.Weight.NORMAL,
+                ])
+
+        db.close()
+        self.tree.expand_all()
+
+    def _get_selected_info(self):
+        """Returns (project_name, entry_key) of selected row."""
+        sel = self.tree.get_selection()
+        model, it = sel.get_selected()
+        if it is None:
+            return None, None
+        return model.get_value(it, 2), model.get_value(it, 3)
+
+    def _on_selection_changed(self, selection):
+        model, it = selection.get_selected()
+        if it is None:
+            self.detail_header.set_text("")
+            self.detail_view.get_buffer().set_text("")
+            return
+        project = model.get_value(it, 2)
+        key = model.get_value(it, 3)
+        if key:
+            self._show_entry_detail(project, key)
+        else:
+            self._show_project_detail(project)
+
+    def _show_project_detail(self, project):
+        import sqlite3
+        if not os.path.exists(CTX_DB):
+            return
+        db = sqlite3.connect(CTX_DB)
+        db.row_factory = sqlite3.Row
+
+        if project == "__shared__":
+            self.detail_header.set_markup("<b>\U0001f517 Shared</b>")
+            self.detail_view.get_buffer().set_text(
+                "Shared context entries available to all projects."
+            )
+            db.close()
+            return
+
+        proj = db.execute(
+            "SELECT description, work_dir FROM sessions WHERE name = ?",
+            (project,),
+        ).fetchone()
+        if not proj:
+            db.close()
+            return
+
+        self.detail_header.set_markup(
+            f"<b>\U0001f4c1 {GLib.markup_escape_text(project)}</b>"
+        )
+        lines = []
+        if proj["description"]:
+            lines.append(proj["description"])
+        if proj["work_dir"]:
+            lines.append(f"Dir: {proj['work_dir']}")
+
+        count = db.execute(
+            "SELECT COUNT(*) FROM contexts WHERE project = ?", (project,)
+        ).fetchone()[0]
+        lines.append(f"Entries: {count}")
+
+        # Last summary
+        summary = db.execute(
+            "SELECT summary, created_at FROM summaries "
+            "WHERE project = ? ORDER BY created_at DESC LIMIT 1",
+            (project,),
+        ).fetchone()
+        if summary:
+            lines.append(
+                f"\n\u2500\u2500 Last summary ({summary['created_at'][:10]}) \u2500\u2500"
+            )
+            lines.append(summary["summary"])
+
+        # Associated Claude session prompt
+        for cs in self.app.claude_manager.all():
+            cs_dir = cs.get("project_dir", "").rstrip("/")
+            if cs_dir and os.path.basename(cs_dir) == project:
+                prompt = cs.get("prompt", "")
+                if prompt:
+                    lines.append("\n\u2500\u2500 Introductory prompt \u2500\u2500")
+                    lines.append(prompt)
+                break
+
+        self.detail_view.get_buffer().set_text("\n".join(lines))
+        db.close()
+
+    def _show_entry_detail(self, project, key):
+        import sqlite3
+        if not os.path.exists(CTX_DB):
+            return
+        db = sqlite3.connect(CTX_DB)
+        if project == "__shared__":
+            row = db.execute(
+                "SELECT value FROM shared WHERE key = ?", (key,)
+            ).fetchone()
+        else:
+            row = db.execute(
+                "SELECT value FROM contexts WHERE project = ? AND key = ?",
+                (project, key),
+            ).fetchone()
+        if row:
+            self.detail_header.set_markup(
+                f"<b>{GLib.markup_escape_text(key)}</b>"
+            )
+            self.detail_view.get_buffer().set_text(row[0])
+        db.close()
+
+    def _on_row_activated(self, tree, path, column):
+        self._on_edit()
+
+    def _on_button_press(self, widget, event):
+        if event.button != 3:
+            return False
+        path_info = self.tree.get_path_at_pos(int(event.x), int(event.y))
+        if not path_info:
+            return True
+        path = path_info[0]
+        self.tree.get_selection().select_path(path)
+        it = self.store.get_iter(path)
+        project = self.store.get_value(it, 2)
+        key = self.store.get_value(it, 3)
+
+        menu = Gtk.Menu()
+        if not key:
+            # Project row
+            item_add = Gtk.MenuItem(label="Add Entry")
+            item_add.connect("activate", lambda _: self._on_add_entry())
+            menu.append(item_add)
+
+            item_edit = Gtk.MenuItem(label="Edit Project")
+            item_edit.connect("activate", lambda _: self._on_edit())
+            menu.append(item_edit)
+
+            menu.append(Gtk.SeparatorMenuItem())
+
+            item_del = Gtk.MenuItem(label="Delete Project")
+            item_del.connect("activate", lambda _: self._on_delete())
+            menu.append(item_del)
+        else:
+            # Entry row
+            item_edit = Gtk.MenuItem(label="Edit Entry")
+            item_edit.connect("activate", lambda _: self._on_edit())
+            menu.append(item_edit)
+
+            item_del = Gtk.MenuItem(label="Delete Entry")
+            item_del.connect("activate", lambda _: self._on_delete())
+            menu.append(item_del)
+
+        menu.show_all()
+        menu.popup_at_pointer(event)
+        return True
+
+    def _on_add_project(self):
+        dlg = _CtxProjectDialog(self.app, "New Project")
+        if dlg.run() == Gtk.ResponseType.OK:
+            name, desc, work_dir = dlg.get_data()
+            if name and desc:
+                args = ["ctx", "init", name, desc]
+                if work_dir:
+                    args.append(work_dir)
+                subprocess.run(args, capture_output=True, text=True)
+                self.refresh()
+        dlg.destroy()
+
+    def _on_add_entry(self):
+        project, _ = self._get_selected_info()
+        if not project or project == "__shared__":
+            return
+        dlg = _CtxEntryDialog(self.app, f"Add entry to {project}")
+        if dlg.run() == Gtk.ResponseType.OK:
+            key, value = dlg.get_data()
+            if key:
+                subprocess.run(
+                    ["ctx", "set", project, key, value],
+                    capture_output=True, text=True,
+                )
+                self.refresh()
+        dlg.destroy()
+
+    def _on_edit(self):
+        project, key = self._get_selected_info()
+        if not project:
+            return
+        if project == "__shared__":
+            if key:
+                self._edit_shared_entry(key)
+            return
+        if key:
+            self._edit_entry(project, key)
+        else:
+            self._edit_project(project)
+
+    def _edit_project(self, project):
+        import sqlite3
+        if not os.path.exists(CTX_DB):
+            return
+        db = sqlite3.connect(CTX_DB)
+        row = db.execute(
+            "SELECT description, work_dir FROM sessions WHERE name = ?",
+            (project,),
+        ).fetchone()
+        db.close()
+        if not row:
+            return
+        dlg = _CtxProjectDialog(
+            self.app, "Edit Project", project, row[0] or "", row[1] or ""
+        )
+        dlg.entry_name.set_sensitive(False)
+        if dlg.run() == Gtk.ResponseType.OK:
+            _, desc, work_dir = dlg.get_data()
+            if desc:
+                args = ["ctx", "init", project, desc]
+                if work_dir:
+                    args.append(work_dir)
+                subprocess.run(args, capture_output=True, text=True)
+                self.refresh()
+        dlg.destroy()
+
+    def _edit_entry(self, project, key):
+        import sqlite3
+        if not os.path.exists(CTX_DB):
+            return
+        db = sqlite3.connect(CTX_DB)
+        row = db.execute(
+            "SELECT value FROM contexts WHERE project = ? AND key = ?",
+            (project, key),
+        ).fetchone()
+        db.close()
+        if not row:
+            return
+        dlg = _CtxEntryDialog(self.app, f"Edit: {key}", key, row[0])
+        if dlg.run() == Gtk.ResponseType.OK:
+            new_key, value = dlg.get_data()
+            if new_key:
+                if new_key != key:
+                    subprocess.run(
+                        ["ctx", "delete", project, key],
+                        capture_output=True, text=True,
+                    )
+                subprocess.run(
+                    ["ctx", "set", project, new_key, value],
+                    capture_output=True, text=True,
+                )
+                self.refresh()
+        dlg.destroy()
+
+    def _edit_shared_entry(self, key):
+        import sqlite3
+        if not os.path.exists(CTX_DB):
+            return
+        db = sqlite3.connect(CTX_DB)
+        row = db.execute(
+            "SELECT value FROM shared WHERE key = ?", (key,)
+        ).fetchone()
+        db.close()
+        if not row:
+            return
+        dlg = _CtxEntryDialog(self.app, f"Edit shared: {key}", key, row[0])
+        if dlg.run() == Gtk.ResponseType.OK:
+            new_key, value = dlg.get_data()
+            if new_key:
+                db = sqlite3.connect(CTX_DB)
+                if new_key != key:
+                    db.execute("DELETE FROM shared WHERE key = ?", (key,))
+                db.execute(
+                    "INSERT OR REPLACE INTO shared (key, value, updated_at) "
+                    "VALUES (?, ?, datetime('now'))",
+                    (new_key, value),
+                )
+                db.commit()
+                db.close()
+                self.refresh()
+        dlg.destroy()
+
+    def _on_delete(self):
+        project, key = self._get_selected_info()
+        if not project:
+            return
+        if key:
+            self._delete_entry(project, key)
+        elif project != "__shared__":
+            self._delete_project(project)
+
+    def _delete_entry(self, project, key):
+        dlg = Gtk.MessageDialog(
+            transient_for=self.app,
+            modal=True,
+            message_type=Gtk.MessageType.QUESTION,
+            buttons=Gtk.ButtonsType.YES_NO,
+            text=f'Delete entry "{key}" from {project}?',
+        )
+        if dlg.run() == Gtk.ResponseType.YES:
+            if project == "__shared__":
+                import sqlite3
+                db = sqlite3.connect(CTX_DB)
+                db.execute("DELETE FROM shared WHERE key = ?", (key,))
+                db.commit()
+                db.close()
+            else:
+                subprocess.run(
+                    ["ctx", "delete", project, key],
+                    capture_output=True, text=True,
+                )
+            self.refresh()
+        dlg.destroy()
+
+    def _delete_project(self, project):
+        dlg = Gtk.MessageDialog(
+            transient_for=self.app,
+            modal=True,
+            message_type=Gtk.MessageType.QUESTION,
+            buttons=Gtk.ButtonsType.YES_NO,
+            text=f'Delete project "{project}" and all its entries?',
+        )
+        if dlg.run() == Gtk.ResponseType.YES:
+            subprocess.run(
+                ["ctx", "delete", project],
+                capture_output=True, text=True,
+            )
+            self.refresh()
+        dlg.destroy()
+
+    def _on_export(self):
+        dlg = _CtxExportDialog(self.app)
+        if dlg.run() == Gtk.ResponseType.OK:
+            data = dlg.get_export_data()
+            if data:
+                save_dlg = Gtk.FileChooserDialog(
+                    title="Save export file",
+                    parent=self.app,
+                    action=Gtk.FileChooserAction.SAVE,
+                )
+                save_dlg.add_buttons(
+                    Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL,
+                    Gtk.STOCK_SAVE, Gtk.ResponseType.OK,
+                )
+                save_dlg.set_do_overwrite_confirmation(True)
+                save_dlg.set_current_name("ctx_export.json")
+                filt = Gtk.FileFilter()
+                filt.set_name("JSON files")
+                filt.add_pattern("*.json")
+                save_dlg.add_filter(filt)
+                if save_dlg.run() == Gtk.ResponseType.OK:
+                    path = save_dlg.get_filename()
+                    try:
+                        with open(path, "w") as f:
+                            json.dump(data, f, indent=2, ensure_ascii=False)
+                    except OSError as e:
+                        err = Gtk.MessageDialog(
+                            transient_for=self.app,
+                            modal=True,
+                            message_type=Gtk.MessageType.ERROR,
+                            buttons=Gtk.ButtonsType.OK,
+                            text=f"Failed to save: {e}",
+                        )
+                        err.run()
+                        err.destroy()
+                save_dlg.destroy()
+        dlg.destroy()
+
+    def _on_import(self):
+        dlg = _CtxImportDialog(self.app)
+        if dlg.run() == Gtk.ResponseType.OK:
+            data, overwrite = dlg.get_selected_data()
+            if data:
+                self._do_import(data, overwrite)
+                self.refresh()
+        dlg.destroy()
+
+    def _do_import(self, data, overwrite):
+        import sqlite3
+        # Ensure database and tables exist
+        subprocess.run(["ctx", "list"], capture_output=True, text=True)
+        if not os.path.exists(CTX_DB):
+            return
+
+        db = sqlite3.connect(CTX_DB)
+        mode = "REPLACE" if overwrite else "IGNORE"
+
+        for session in data.get("sessions", []):
+            db.execute(
+                f"INSERT OR {mode} INTO sessions (name, description, work_dir, created_at) "
+                "VALUES (?, ?, ?, ?)",
+                (
+                    session["name"],
+                    session.get("description", ""),
+                    session.get("work_dir", ""),
+                    session.get("created_at", ""),
+                ),
+            )
+
+        for ctx in data.get("contexts", []):
+            db.execute(
+                f"INSERT OR {mode} INTO contexts (project, key, value, updated_at) "
+                "VALUES (?, ?, ?, ?)",
+                (
+                    ctx["project"],
+                    ctx["key"],
+                    ctx["value"],
+                    ctx.get("updated_at", ""),
+                ),
+            )
+
+        for shared in data.get("shared", []):
+            db.execute(
+                f"INSERT OR {mode} INTO shared (key, value, updated_at) "
+                "VALUES (?, ?, ?)",
+                (
+                    shared["key"],
+                    shared["value"],
+                    shared.get("updated_at", ""),
+                ),
+            )
+
+        for summary in data.get("summaries", []):
+            db.execute(
+                "INSERT INTO summaries (project, summary, created_at) "
+                "VALUES (?, ?, ?)",
+                (
+                    summary["project"],
+                    summary["summary"],
+                    summary.get("created_at", ""),
+                ),
+            )
+
+        db.commit()
+        db.close()
+
+
 # ─── BTerminalApp ─────────────────────────────────────────────────────────────
 
 
@@ -1883,9 +3425,31 @@ class BTerminalApp(Gtk.Window):
         paned = Gtk.HPaned()
         self.add(paned)
 
-        # Sidebar
+        # Sidebar container with stack switcher
+        sidebar_box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
+        sidebar_box.get_style_context().add_class("sidebar")
+        sidebar_box.set_size_request(250, -1)
+
+        self.sidebar_stack = Gtk.Stack()
+        self.sidebar_stack.set_transition_type(
+            Gtk.StackTransitionType.SLIDE_LEFT_RIGHT
+        )
+
         self.sidebar = SessionSidebar(self)
-        paned.pack1(self.sidebar, resize=False, shrink=False)
+        self.sidebar_stack.add_titled(self.sidebar, "sessions", "Sessions")
+
+        self.ctx_panel = CtxManagerPanel(self)
+        self.sidebar_stack.add_titled(self.ctx_panel, "ctx", "Ctx")
+
+        switcher = Gtk.StackSwitcher()
+        switcher.set_stack(self.sidebar_stack)
+        switcher.set_halign(Gtk.Align.FILL)
+        switcher.set_homogeneous(True)
+
+        sidebar_box.pack_start(switcher, False, False, 0)
+        sidebar_box.pack_start(self.sidebar_stack, True, True, 0)
+
+        paned.pack1(sidebar_box, resize=False, shrink=False)
 
         # Notebook (tabs)
         self.notebook = Gtk.Notebook()
@@ -1896,6 +3460,16 @@ class BTerminalApp(Gtk.Window):
 
         paned.set_position(250)
 
+        # Auto-refresh ctx panel when switching to it
+        self.sidebar_stack.connect(
+            "notify::visible-child",
+            lambda s, _: (
+                self.ctx_panel.refresh()
+                if s.get_visible_child() is self.ctx_panel
+                else None
+            ),
+        )
+
         # Keyboard shortcuts
         self.connect("key-press-event", self._on_key_press)
         self.connect("delete-event", self._on_delete_event)
diff --git a/btmsg b/btmsg
new file mode 100755
index 0000000..3507833
--- /dev/null
+++ b/btmsg
@@ -0,0 +1,1183 @@
+#!/usr/bin/env python3
+"""
+btmsg — Group Agent Messenger for BTerminal Mission Control.
+
+Hierarchical communication system for multi-agent orchestration.
+Agents communicate through messages stored in SQLite.
+Agent identity set via BTMSG_AGENT_ID environment variable.
+
+Usage: btmsg <command> [args]
+
+Commands:
+  inbox              Show unread messages (--all for all)
+  read <msg-id>      Read message and mark as read
+  send <to> <msg>    Send message to agent (must be in contacts)
+  reply <msg-id> <msg>  Reply to a message
+  contacts           List allowed contacts for current agent
+  history <agent-id> Show conversation history with agent
+  status             Show all agents and their status
+  register <id> <name> <role> <group> [--tier N] [--model M]
+                     Register an agent
+  allow <from> <to>  Add contact permission
+  whoami             Show current agent identity
+  graph              Visual hierarchy with status dots and links
+"""
+
+import sqlite3
+import sys
+import os
+import uuid
+import json
+from pathlib import Path
+from datetime import datetime, timezone
+
+DB_PATH = Path.home() / ".local" / "share" / "bterminal" / "btmsg.db"
+
+# Agent roles and their tiers
+ROLES = {
+    'admin': 0,
+    'manager': 1,
+    'architect': 1,
+    'tester': 1,
+    'reviewer': 1,
+    'project': 2,
+}
+
+# Colors for terminal output
+C_RESET = "\033[0m"
+C_BOLD = "\033[1m"
+C_DIM = "\033[2m"
+C_RED = "\033[31m"
+C_GREEN = "\033[32m"
+C_YELLOW = "\033[33m"
+C_BLUE = "\033[34m"
+C_MAGENTA = "\033[35m"
+C_CYAN = "\033[36m"
+
+ROLE_COLORS = {
+    'admin': C_CYAN,
+    'manager': C_MAGENTA,
+    'architect': C_BLUE,
+    'tester': C_GREEN,
+    'reviewer': C_CYAN,
+    'project': C_YELLOW,
+}
+
+
+def get_db():
+    DB_PATH.parent.mkdir(parents=True, exist_ok=True)
+    db = sqlite3.connect(str(DB_PATH))
+    db.row_factory = sqlite3.Row
+    db.execute("PRAGMA journal_mode=WAL")
+    return db
+
+
+def init_db():
+    db = get_db()
+    db.executescript("""
+        CREATE TABLE IF NOT EXISTS agents (
+            id TEXT PRIMARY KEY,
+            name TEXT NOT NULL,
+            role TEXT NOT NULL,
+            group_id TEXT NOT NULL,
+            tier INTEGER NOT NULL DEFAULT 2,
+            model TEXT,
+            cwd TEXT,
+            system_prompt TEXT,
+            status TEXT DEFAULT 'stopped',
+            last_active_at TEXT,
+            created_at TEXT DEFAULT (datetime('now'))
+        );
+
+        CREATE TABLE IF NOT EXISTS contacts (
+            agent_id TEXT NOT NULL,
+            contact_id TEXT NOT NULL,
+            PRIMARY KEY (agent_id, contact_id),
+            FOREIGN KEY (agent_id) REFERENCES agents(id),
+            FOREIGN KEY (contact_id) REFERENCES agents(id)
+        );
+
+        CREATE TABLE IF NOT EXISTS messages (
+            id TEXT PRIMARY KEY,
+            from_agent TEXT NOT NULL,
+            to_agent TEXT NOT NULL,
+            content TEXT NOT NULL,
+            read INTEGER DEFAULT 0,
+            reply_to TEXT,
+            group_id TEXT NOT NULL,
+            created_at TEXT DEFAULT (datetime('now')),
+            FOREIGN KEY (from_agent) REFERENCES agents(id),
+            FOREIGN KEY (to_agent) REFERENCES agents(id)
+        );
+
+        CREATE INDEX IF NOT EXISTS idx_messages_to ON messages(to_agent, read);
+        CREATE INDEX IF NOT EXISTS idx_messages_from ON messages(from_agent);
+        CREATE INDEX IF NOT EXISTS idx_messages_group ON messages(group_id);
+        CREATE INDEX IF NOT EXISTS idx_messages_reply ON messages(reply_to);
+
+        CREATE TABLE IF NOT EXISTS channels (
+            id TEXT PRIMARY KEY,
+            name TEXT NOT NULL,
+            group_id TEXT NOT NULL,
+            created_by TEXT NOT NULL,
+            created_at TEXT DEFAULT (datetime('now')),
+            FOREIGN KEY (created_by) REFERENCES agents(id)
+        );
+
+        CREATE TABLE IF NOT EXISTS channel_members (
+            channel_id TEXT NOT NULL,
+            agent_id TEXT NOT NULL,
+            joined_at TEXT DEFAULT (datetime('now')),
+            PRIMARY KEY (channel_id, agent_id),
+            FOREIGN KEY (channel_id) REFERENCES channels(id),
+            FOREIGN KEY (agent_id) REFERENCES agents(id)
+        );
+
+        CREATE TABLE IF NOT EXISTS channel_messages (
+            id TEXT PRIMARY KEY,
+            channel_id TEXT NOT NULL,
+            from_agent TEXT NOT NULL,
+            content TEXT NOT NULL,
+            created_at TEXT DEFAULT (datetime('now')),
+            FOREIGN KEY (channel_id) REFERENCES channels(id),
+            FOREIGN KEY (from_agent) REFERENCES agents(id)
+        );
+
+        CREATE INDEX IF NOT EXISTS idx_channel_messages ON channel_messages(channel_id, created_at);
+    """)
+    db.commit()
+    db.close()
+
+
+def get_agent_id():
+    """Get current agent ID from environment."""
+    agent_id = os.environ.get("BTMSG_AGENT_ID")
+    if not agent_id:
+        print(f"{C_RED}Error: BTMSG_AGENT_ID not set.{C_RESET}")
+        print(f"{C_DIM}Set it with: export BTMSG_AGENT_ID=<your-agent-id>{C_RESET}")
+        sys.exit(1)
+    return agent_id
+
+
+def get_agent(db, agent_id):
+    """Get agent record, or None."""
+    row = db.execute("SELECT * FROM agents WHERE id = ?", (agent_id,)).fetchone()
+    return row
+
+
+def can_message(db, from_id, to_id):
+    """Check if from_agent is allowed to message to_agent."""
+    # Admin (tier 0) can message anyone
+    sender = get_agent(db, from_id)
+    if sender and sender['tier'] == 0:
+        return True
+    row = db.execute(
+        "SELECT 1 FROM contacts WHERE agent_id = ? AND contact_id = ?",
+        (from_id, to_id)
+    ).fetchone()
+    return row is not None
+
+
+def format_time(ts_str):
+    """Format timestamp for display."""
+    if not ts_str:
+        return "?"
+    try:
+        dt = datetime.fromisoformat(ts_str)
+        return dt.strftime("%H:%M:%S")
+    except (ValueError, TypeError):
+        return ts_str[:19]
+
+
+def format_role(role):
+    """Colorize role name."""
+    color = ROLE_COLORS.get(role, C_RESET)
+    return f"{color}{role}{C_RESET}"
+
+
+def short_id(msg_id):
+    """Show first 8 chars of message ID."""
+    return msg_id[:8] if msg_id else "?"
+
+
+# ─── Commands ────────────────────────────────────────────────
+
+def cmd_inbox(args):
+    """Show unread messages (or all with --all)."""
+    agent_id = get_agent_id()
+    show_all = "--all" in args
+    db = get_db()
+
+    agent = get_agent(db, agent_id)
+    if not agent:
+        print(f"{C_RED}Agent '{agent_id}' not registered.{C_RESET}")
+        return
+
+    if show_all:
+        rows = db.execute(
+            "SELECT m.*, a.name as sender_name, a.role as sender_role "
+            "FROM messages m JOIN agents a ON m.from_agent = a.id "
+            "WHERE m.to_agent = ? ORDER BY m.created_at DESC LIMIT 50",
+            (agent_id,)
+        ).fetchall()
+    else:
+        rows = db.execute(
+            "SELECT m.*, a.name as sender_name, a.role as sender_role "
+            "FROM messages m JOIN agents a ON m.from_agent = a.id "
+            "WHERE m.to_agent = ? AND m.read = 0 ORDER BY m.created_at ASC",
+            (agent_id,)
+        ).fetchall()
+
+    if not rows:
+        label = "messages" if show_all else "unread messages"
+        print(f"{C_DIM}No {label}.{C_RESET}")
+        return
+
+    label = "All messages" if show_all else f"Unread messages ({len(rows)})"
+    print(f"\n{C_BOLD}📬 {label} for {agent['name']}:{C_RESET}\n")
+
+    for row in rows:
+        read_mark = " " if row['read'] else f"{C_GREEN}●{C_RESET}"
+        role_str = format_role(row['sender_role'])
+        time_str = format_time(row['created_at'])
+        reply_str = f" {C_DIM}↩ {short_id(row['reply_to'])}{C_RESET}" if row['reply_to'] else ""
+        print(f"  {read_mark} [{short_id(row['id'])}] {C_DIM}{time_str}{C_RESET} "
+              f"{C_BOLD}{row['sender_name']}{C_RESET} ({role_str}){reply_str}")
+        # Show first 120 chars of content
+        preview = row['content'][:120].replace('\n', ' ')
+        if len(row['content']) > 120:
+            preview += "..."
+        print(f"    {preview}\n")
+
+    db.close()
+
+
+def cmd_read(args):
+    """Read a specific message and mark as read."""
+    if not args:
+        print(f"{C_RED}Usage: btmsg read <msg-id>{C_RESET}")
+        return
+
+    agent_id = get_agent_id()
+    msg_id_prefix = args[0]
+    db = get_db()
+
+    # Support short IDs (prefix match)
+    row = db.execute(
+        "SELECT m.*, a.name as sender_name, a.role as sender_role "
+        "FROM messages m JOIN agents a ON m.from_agent = a.id "
+        "WHERE m.id LIKE ? AND m.to_agent = ?",
+        (msg_id_prefix + "%", agent_id)
+    ).fetchone()
+
+    if not row:
+        print(f"{C_RED}Message not found.{C_RESET}")
+        db.close()
+        return
+
+    role_str = format_role(row['sender_role'])
+    time_str = format_time(row['created_at'])
+
+    print(f"\n{C_BOLD}{'─' * 60}{C_RESET}")
+    print(f"  {C_DIM}ID:{C_RESET}   {row['id']}")
+    print(f"  {C_DIM}From:{C_RESET} {C_BOLD}{row['sender_name']}{C_RESET} ({role_str})")
+    print(f"  {C_DIM}Time:{C_RESET} {time_str}")
+    if row['reply_to']:
+        print(f"  {C_DIM}Re:{C_RESET}   {short_id(row['reply_to'])}")
+    print(f"{C_BOLD}{'─' * 60}{C_RESET}\n")
+    print(f"  {row['content']}\n")
+    print(f"{C_BOLD}{'─' * 60}{C_RESET}")
+    print(f"{C_DIM}Reply: btmsg reply {short_id(row['id'])} \"your message\"{C_RESET}\n")
+
+    # Mark as read
+    db.execute("UPDATE messages SET read = 1 WHERE id = ?", (row['id'],))
+    db.commit()
+    db.close()
+
+
+def cmd_send(args):
+    """Send a message to an agent."""
+    if len(args) < 2:
+        print(f"{C_RED}Usage: btmsg send <to-agent-id> <message>{C_RESET}")
+        return
+
+    agent_id = get_agent_id()
+    to_id = args[0]
+    content = " ".join(args[1:])
+    db = get_db()
+
+    # Verify sender exists
+    sender = get_agent(db, agent_id)
+    if not sender:
+        print(f"{C_RED}Agent '{agent_id}' not registered.{C_RESET}")
+        db.close()
+        return
+
+    # Verify recipient exists (support prefix match)
+    recipient = get_agent(db, to_id)
+    if not recipient:
+        # Try prefix match
+        row = db.execute("SELECT * FROM agents WHERE id LIKE ?", (to_id + "%",)).fetchone()
+        if row:
+            recipient = row
+            to_id = row['id']
+        else:
+            print(f"{C_RED}Agent '{to_id}' not found.{C_RESET}")
+            db.close()
+            return
+
+    # Check contact permission
+    if not can_message(db, agent_id, to_id):
+        print(f"{C_RED}Not allowed to message '{recipient['name']}' ({recipient['role']}).{C_RESET}")
+        print(f"{C_DIM}Check your contacts: btmsg contacts{C_RESET}")
+        db.close()
+        return
+
+    msg_id = str(uuid.uuid4())
+    db.execute(
+        "INSERT INTO messages (id, from_agent, to_agent, content, group_id) "
+        "VALUES (?, ?, ?, ?, ?)",
+        (msg_id, agent_id, to_id, content, sender['group_id'])
+    )
+    db.commit()
+    db.close()
+
+    print(f"{C_GREEN}✓ Sent to {recipient['name']} ({recipient['role']}){C_RESET} [{short_id(msg_id)}]")
+
+
+def cmd_reply(args):
+    """Reply to a message."""
+    if len(args) < 2:
+        print(f"{C_RED}Usage: btmsg reply <msg-id> <message>{C_RESET}")
+        return
+
+    agent_id = get_agent_id()
+    msg_id_prefix = args[0]
+    content = " ".join(args[1:])
+    db = get_db()
+
+    # Find original message (prefix match)
+    original = db.execute(
+        "SELECT * FROM messages WHERE id LIKE ? AND to_agent = ?",
+        (msg_id_prefix + "%", agent_id)
+    ).fetchone()
+
+    if not original:
+        print(f"{C_RED}Message not found.{C_RESET}")
+        db.close()
+        return
+
+    # Reply goes back to sender
+    sender = get_agent(db, agent_id)
+    if not sender:
+        print(f"{C_RED}Agent '{agent_id}' not registered.{C_RESET}")
+        db.close()
+        return
+
+    to_id = original['from_agent']
+
+    # Check contact permission
+    if not can_message(db, agent_id, to_id):
+        recipient = get_agent(db, to_id)
+        rname = recipient['name'] if recipient else to_id
+        print(f"{C_RED}Not allowed to reply to '{rname}'.{C_RESET}")
+        db.close()
+        return
+
+    reply_id = str(uuid.uuid4())
+    db.execute(
+        "INSERT INTO messages (id, from_agent, to_agent, content, reply_to, group_id) "
+        "VALUES (?, ?, ?, ?, ?, ?)",
+        (reply_id, agent_id, to_id, content, original['id'], sender['group_id'])
+    )
+    db.commit()
+
+    recipient = get_agent(db, to_id)
+    rname = recipient['name'] if recipient else to_id
+    print(f"{C_GREEN}✓ Replied to {rname}{C_RESET} [{short_id(reply_id)}]")
+    db.close()
+
+
+def cmd_contacts(args):
+    """List allowed contacts for current agent."""
+    agent_id = get_agent_id()
+    db = get_db()
+
+    agent = get_agent(db, agent_id)
+    if not agent:
+        print(f"{C_RED}Agent '{agent_id}' not registered.{C_RESET}")
+        db.close()
+        return
+
+    rows = db.execute(
+        "SELECT a.* FROM contacts c JOIN agents a ON c.contact_id = a.id "
+        "WHERE c.agent_id = ? ORDER BY a.tier, a.role, a.name",
+        (agent_id,)
+    ).fetchall()
+
+    print(f"\n{C_BOLD}📋 Contacts for {agent['name']} ({format_role(agent['role'])}):{C_RESET}\n")
+
+    if not rows:
+        print(f"  {C_DIM}No contacts configured.{C_RESET}")
+        db.close()
+        return
+
+    current_tier = None
+    for row in rows:
+        if row['tier'] != current_tier:
+            current_tier = row['tier']
+            tier_label = "Management" if current_tier == 1 else "Execution"
+            print(f"  {C_DIM}── Tier {current_tier}: {tier_label} ──{C_RESET}")
+        status_dot = f"{C_GREEN}●{C_RESET}" if row['status'] == 'active' else f"{C_DIM}○{C_RESET}"
+        print(f"  {status_dot} {C_BOLD}{row['id']}{C_RESET} — {row['name']} ({format_role(row['role'])})")
+
+    print()
+    db.close()
+
+
+def cmd_history(args):
+    """Show conversation history with another agent."""
+    if not args:
+        print(f"{C_RED}Usage: btmsg history <agent-id> [--limit N]{C_RESET}")
+        return
+
+    agent_id = get_agent_id()
+    other_id = args[0]
+    limit = 20
+
+    if "--limit" in args:
+        idx = args.index("--limit")
+        if idx + 1 < len(args):
+            try:
+                limit = int(args[idx + 1])
+            except ValueError:
+                pass
+
+    db = get_db()
+
+    # Support prefix match for other_id
+    other = get_agent(db, other_id)
+    if not other:
+        row = db.execute("SELECT * FROM agents WHERE id LIKE ?", (other_id + "%",)).fetchone()
+        if row:
+            other = row
+            other_id = row['id']
+        else:
+            print(f"{C_RED}Agent '{other_id}' not found.{C_RESET}")
+            db.close()
+            return
+
+    agent = get_agent(db, agent_id)
+    if not agent:
+        print(f"{C_RED}Agent '{agent_id}' not registered.{C_RESET}")
+        db.close()
+        return
+
+    rows = db.execute(
+        "SELECT m.*, a.name as sender_name, a.role as sender_role "
+        "FROM messages m JOIN agents a ON m.from_agent = a.id "
+        "WHERE (m.from_agent = ? AND m.to_agent = ?) "
+        "   OR (m.from_agent = ? AND m.to_agent = ?) "
+        "ORDER BY m.created_at ASC LIMIT ?",
+        (agent_id, other_id, other_id, agent_id, limit)
+    ).fetchall()
+
+    print(f"\n{C_BOLD}💬 History: {agent['name']} ↔ {other['name']}{C_RESET}\n")
+
+    if not rows:
+        print(f"  {C_DIM}No messages yet.{C_RESET}\n")
+        db.close()
+        return
+
+    for row in rows:
+        time_str = format_time(row['created_at'])
+        is_me = row['from_agent'] == agent_id
+        arrow = f"{C_CYAN}→{C_RESET}" if is_me else f"{C_YELLOW}←{C_RESET}"
+        name = "You" if is_me else row['sender_name']
+        print(f"  {C_DIM}{time_str}{C_RESET} {arrow} {C_BOLD}{name}{C_RESET}: {row['content']}")
+
+    print()
+    db.close()
+
+
+def cmd_status(args):
+    """Show all agents in the group and their status."""
+    db = get_db()
+
+    # Get current agent's group, or show all
+    agent_id = os.environ.get("BTMSG_AGENT_ID")
+    if agent_id:
+        agent = get_agent(db, agent_id)
+        if agent:
+            group_id = agent['group_id']
+            rows = db.execute(
+                "SELECT * FROM agents WHERE group_id = ? ORDER BY tier, role, name",
+                (group_id,)
+            ).fetchall()
+        else:
+            rows = db.execute("SELECT * FROM agents ORDER BY group_id, tier, role, name").fetchall()
+    else:
+        rows = db.execute("SELECT * FROM agents ORDER BY group_id, tier, role, name").fetchall()
+
+    if not rows:
+        print(f"{C_DIM}No agents registered.{C_RESET}")
+        db.close()
+        return
+
+    # Count unread per agent
+    unread_counts = {}
+    for row in rows:
+        count = db.execute(
+            "SELECT COUNT(*) FROM messages WHERE to_agent = ? AND read = 0",
+            (row['id'],)
+        ).fetchone()[0]
+        unread_counts[row['id']] = count
+
+    print(f"\n{C_BOLD}🤖 Agent Status{C_RESET}\n")
+
+    current_tier = None
+    for row in rows:
+        if row['tier'] != current_tier:
+            current_tier = row['tier']
+            tier_label = "TIER 1 — Management" if current_tier == 1 else "TIER 2 — Execution"
+            print(f"  {C_BOLD}{tier_label}{C_RESET}")
+
+        status = row['status'] or 'stopped'
+        if status == 'active':
+            status_str = f"{C_GREEN}● active{C_RESET}"
+        elif status == 'sleeping':
+            status_str = f"{C_YELLOW}◐ sleeping{C_RESET}"
+        else:
+            status_str = f"{C_DIM}○ stopped{C_RESET}"
+
+        unread = unread_counts.get(row['id'], 0)
+        unread_str = f" {C_RED}({unread} unread){C_RESET}" if unread > 0 else ""
+
+        model_str = f" {C_DIM}[{row['model']}]{C_RESET}" if row['model'] else ""
+
+        print(f"    {status_str} {C_BOLD}{row['name']}{C_RESET} "
+              f"({format_role(row['role'])}) — {row['id']}{model_str}{unread_str}")
+
+    print()
+    db.close()
+
+
+def cmd_register(args):
+    """Register a new agent."""
+    if len(args) < 4:
+        print(f"{C_RED}Usage: btmsg register <id> <name> <role> <group-id> [--tier N] [--model M] [--cwd PATH]{C_RESET}")
+        print(f"{C_DIM}Roles: {', '.join(ROLES.keys())}{C_RESET}")
+        return
+
+    agent_id = args[0]
+    name = args[1]
+    role = args[2]
+    group_id = args[3]
+
+    tier = ROLES.get(role, 2)
+    model = None
+    cwd = None
+
+    # Parse optional flags
+    i = 4
+    while i < len(args):
+        if args[i] == "--tier" and i + 1 < len(args):
+            tier = int(args[i + 1])
+            i += 2
+        elif args[i] == "--model" and i + 1 < len(args):
+            model = args[i + 1]
+            i += 2
+        elif args[i] == "--cwd" and i + 1 < len(args):
+            cwd = args[i + 1]
+            i += 2
+        else:
+            i += 1
+
+    db = get_db()
+
+    # Check if agent already exists
+    existing = get_agent(db, agent_id)
+    if existing:
+        print(f"{C_YELLOW}Agent '{agent_id}' already exists. Updating...{C_RESET}")
+        db.execute(
+            "UPDATE agents SET name=?, role=?, group_id=?, tier=?, model=?, cwd=? WHERE id=?",
+            (name, role, group_id, tier, model, cwd, agent_id)
+        )
+    else:
+        db.execute(
+            "INSERT INTO agents (id, name, role, group_id, tier, model, cwd) "
+            "VALUES (?, ?, ?, ?, ?, ?, ?)",
+            (agent_id, name, role, group_id, tier, model, cwd)
+        )
+
+    db.commit()
+    db.close()
+    print(f"{C_GREEN}✓ Registered: {name} ({role}, tier {tier}){C_RESET}")
+
+
+def cmd_allow(args):
+    """Add contact permission between agents."""
+    if len(args) < 2:
+        print(f"{C_RED}Usage: btmsg allow <from-agent> <to-agent> [--bidirectional]{C_RESET}")
+        return
+
+    from_id = args[0]
+    to_id = args[1]
+    bidir = "--bidirectional" in args or "-b" in args
+
+    db = get_db()
+
+    # Verify both agents exist
+    for aid in [from_id, to_id]:
+        if not get_agent(db, aid):
+            print(f"{C_RED}Agent '{aid}' not found.{C_RESET}")
+            db.close()
+            return
+
+    db.execute(
+        "INSERT OR IGNORE INTO contacts (agent_id, contact_id) VALUES (?, ?)",
+        (from_id, to_id)
+    )
+    if bidir:
+        db.execute(
+            "INSERT OR IGNORE INTO contacts (agent_id, contact_id) VALUES (?, ?)",
+            (to_id, from_id)
+        )
+
+    db.commit()
+    db.close()
+
+    direction = "↔" if bidir else "→"
+    print(f"{C_GREEN}✓ Contact: {from_id} {direction} {to_id}{C_RESET}")
+
+
+def cmd_whoami(args):
+    """Show current agent identity."""
+    agent_id = get_agent_id()
+    db = get_db()
+
+    agent = get_agent(db, agent_id)
+    if not agent:
+        print(f"{C_YELLOW}Agent ID: {agent_id} (not registered){C_RESET}")
+        db.close()
+        return
+
+    unread = db.execute(
+        "SELECT COUNT(*) FROM messages WHERE to_agent = ? AND read = 0",
+        (agent_id,)
+    ).fetchone()[0]
+
+    print(f"\n{C_BOLD}🤖 {agent['name']}{C_RESET}")
+    print(f"  {C_DIM}ID:{C_RESET}    {agent['id']}")
+    print(f"  {C_DIM}Role:{C_RESET}  {format_role(agent['role'])} (Tier {agent['tier']})")
+    print(f"  {C_DIM}Group:{C_RESET} {agent['group_id']}")
+    if agent['model']:
+        print(f"  {C_DIM}Model:{C_RESET} {agent['model']}")
+    if agent['cwd']:
+        print(f"  {C_DIM}CWD:{C_RESET}   {agent['cwd']}")
+    print(f"  {C_DIM}Unread:{C_RESET} {unread} messages")
+    print()
+    db.close()
+
+
+def cmd_unread_count(args):
+    """Print just the unread count (for notifications)."""
+    agent_id = os.environ.get("BTMSG_AGENT_ID")
+    if not agent_id:
+        print("0")
+        return
+
+    db = get_db()
+    count = db.execute(
+        "SELECT COUNT(*) FROM messages WHERE to_agent = ? AND read = 0",
+        (agent_id,)
+    ).fetchone()[0]
+    db.close()
+    print(count)
+
+
+def cmd_notify(args):
+    """Print notification line if there are unread messages (for agent injection)."""
+    agent_id = os.environ.get("BTMSG_AGENT_ID")
+    if not agent_id:
+        return
+
+    db = get_db()
+    count = db.execute(
+        "SELECT COUNT(*) FROM messages WHERE to_agent = ? AND read = 0",
+        (agent_id,)
+    ).fetchone()[0]
+
+    if count > 0:
+        # Get latest unread sender
+        latest = db.execute(
+            "SELECT a.name, a.role FROM messages m JOIN agents a ON m.from_agent = a.id "
+            "WHERE m.to_agent = ? AND m.read = 0 ORDER BY m.created_at DESC LIMIT 1",
+            (agent_id,)
+        ).fetchone()
+        sender_info = f" (latest from {latest['name']})" if latest else ""
+        print(f"📬 You have {count} unread message{'s' if count != 1 else ''}!{sender_info}")
+        print(f"   Use: btmsg inbox")
+
+    db.close()
+
+
+def cmd_graph(args):
+    """Show visual hierarchy graph with agent status."""
+    db = get_db()
+
+    # Get current group
+    agent_id = os.environ.get("BTMSG_AGENT_ID")
+    group_id = None
+    if agent_id:
+        agent = get_agent(db, agent_id)
+        if agent:
+            group_id = agent['group_id']
+
+    if group_id:
+        agents = db.execute(
+            "SELECT * FROM agents WHERE group_id = ? ORDER BY tier, role, name",
+            (group_id,)
+        ).fetchall()
+    else:
+        agents = db.execute("SELECT * FROM agents ORDER BY group_id, tier, role, name").fetchall()
+
+    if not agents:
+        print(f"{C_DIM}No agents registered.{C_RESET}")
+        db.close()
+        return
+
+    # Build contact map
+    contacts_map = {}
+    for a in agents:
+        rows = db.execute(
+            "SELECT contact_id FROM contacts WHERE agent_id = ?", (a['id'],)
+        ).fetchall()
+        contacts_map[a['id']] = [r['contact_id'] for r in rows]
+
+    # Unread counts
+    unread = {}
+    for a in agents:
+        count = db.execute(
+            "SELECT COUNT(*) FROM messages WHERE to_agent = ? AND read = 0",
+            (a['id'],)
+        ).fetchone()[0]
+        unread[a['id']] = count
+
+    # Status dot
+    def dot(agent):
+        s = agent['status'] or 'stopped'
+        if s == 'active':
+            return f"{C_GREEN}●{C_RESET}"
+        elif s == 'sleeping':
+            return f"{C_YELLOW}●{C_RESET}"
+        else:
+            return f"{C_RED}●{C_RESET}"
+
+    # Agent label with status
+    def label(agent):
+        d = dot(agent)
+        name = agent['name']
+        role_c = ROLE_COLORS.get(agent['role'], C_RESET)
+        unread_str = f" {C_RED}✉{unread[agent['id']]}{C_RESET}" if unread.get(agent['id'], 0) > 0 else ""
+        model_str = f" {C_DIM}[{agent['model']}]{C_RESET}" if agent['model'] else ""
+        return f"{d} {C_BOLD}{name}{C_RESET} {role_c}({agent['role']}){C_RESET}{model_str}{unread_str}"
+
+    # Separate by tier
+    tier1 = [a for a in agents if a['tier'] == 1]
+    tier2 = [a for a in agents if a['tier'] == 2]
+
+    # Find manager, architect, tester
+    manager = next((a for a in tier1 if a['role'] == 'manager'), None)
+    architect = next((a for a in tier1 if a['role'] == 'architect'), None)
+    tester = next((a for a in tier1 if a['role'] == 'tester'), None)
+    other_tier1 = [a for a in tier1 if a['role'] not in ('manager', 'architect', 'tester')]
+
+    # Draw graph
+    group_name = group_id or "all"
+    print(f"\n{C_BOLD}  ╔══════════════════════════════════════════════════════╗{C_RESET}")
+    print(f"{C_BOLD}  ║  Agent Hierarchy — {group_name:<35s}║{C_RESET}")
+    print(f"{C_BOLD}  ╚══════════════════════════════════════════════════════╝{C_RESET}")
+
+    # USER at top
+    print(f"\n  {C_BOLD}{C_CYAN}👤 USER{C_RESET}")
+    print(f"  {C_DIM}  │{C_RESET}")
+
+    # TIER 1
+    print(f"  {C_DIM}  │  ┌─────────────────────────────────────────────┐{C_RESET}")
+    print(f"  {C_DIM}  │  │{C_RESET} {C_BOLD}TIER 1 — Management{C_RESET}                       {C_DIM}│{C_RESET}")
+    print(f"  {C_DIM}  │  │{C_RESET}                                             {C_DIM}│{C_RESET}")
+
+    if manager:
+        print(f"  {C_DIM}  ├──│{C_RESET}  {label(manager)}")
+        if architect:
+            print(f"  {C_DIM}     │    ├── {C_RESET}{label(architect)}")
+            if tester:
+                print(f"  {C_DIM}     │    │     └── {C_RESET}{label(tester)}")
+        elif tester:
+            print(f"  {C_DIM}     │    └── {C_RESET}{label(tester)}")
+        for a in other_tier1:
+            print(f"  {C_DIM}     │    ├── {C_RESET}{label(a)}")
+    else:
+        for a in tier1:
+            print(f"  {C_DIM}     │  {C_RESET}  {label(a)}")
+
+    print(f"  {C_DIM}     │{C_RESET}                                             {C_DIM}│{C_RESET}")
+    print(f"  {C_DIM}     └─────────────────────────────────────────────┘{C_RESET}")
+
+    if tier2:
+        # Connection lines from manager to tier 2
+        print(f"  {C_DIM}     │{C_RESET}")
+        print(f"  {C_DIM}     │  ┌─────────────────────────────────────────────┐{C_RESET}")
+        print(f"  {C_DIM}     │  │{C_RESET} {C_BOLD}TIER 2 — Execution{C_RESET}                        {C_DIM}│{C_RESET}")
+        print(f"  {C_DIM}     │  │{C_RESET}                                             {C_DIM}│{C_RESET}")
+
+        for i, a in enumerate(tier2):
+            is_last = i == len(tier2) - 1
+            connector = "└" if is_last else "├"
+            print(f"  {C_DIM}     ├──│{C_RESET}  {connector}── {label(a)}")
+
+        print(f"  {C_DIM}        │{C_RESET}                                             {C_DIM}│{C_RESET}")
+        print(f"  {C_DIM}        └─────────────────────────────────────────────┘{C_RESET}")
+
+    # Legend
+    print(f"\n  {C_DIM}Legend: {C_GREEN}●{C_RESET}{C_DIM} active  {C_YELLOW}●{C_RESET}{C_DIM} sleeping  {C_RED}●{C_RESET}{C_DIM} stopped  {C_RED}✉{C_RESET}{C_DIM} unread{C_RESET}")
+
+    # Communication lines summary
+    print(f"\n  {C_BOLD}Communication links:{C_RESET}")
+    for a in agents:
+        targets = contacts_map.get(a['id'], [])
+        if targets:
+            target_names = []
+            for t_id in targets:
+                t = get_agent(db, t_id)
+                if t:
+                    target_names.append(t['name'])
+            if target_names:
+                role_c = ROLE_COLORS.get(a['role'], C_RESET)
+                print(f"    {role_c}{a['name']}{C_RESET} → {', '.join(target_names)}")
+
+    print()
+    db.close()
+
+
+def cmd_feed(args):
+    """Show all messages in the group (admin only)."""
+    agent_id = get_agent_id()
+    db = get_db()
+    agent = get_agent(db, agent_id)
+    if not agent or agent['tier'] != 0:
+        print(f"{C_RED}Admin access required (tier 0).{C_RESET}")
+        db.close()
+        return
+
+    limit = 50
+    if "--limit" in args:
+        idx = args.index("--limit")
+        if idx + 1 < len(args):
+            try:
+                limit = int(args[idx + 1])
+            except ValueError:
+                pass
+
+    rows = db.execute(
+        "SELECT m.*, a1.name as sender_name, a1.role as sender_role, "
+        "a2.name as recipient_name, a2.role as recipient_role "
+        "FROM messages m "
+        "JOIN agents a1 ON m.from_agent = a1.id "
+        "JOIN agents a2 ON m.to_agent = a2.id "
+        "WHERE m.group_id = ? ORDER BY m.created_at DESC LIMIT ?",
+        (agent['group_id'], limit)
+    ).fetchall()
+
+    print(f"\n{C_BOLD}📡 Activity Feed — All Messages{C_RESET}\n")
+    if not rows:
+        print(f"  {C_DIM}No messages yet.{C_RESET}\n")
+        db.close()
+        return
+
+    for row in reversed(rows):
+        time_str = format_time(row['created_at'])
+        sender_role = format_role(row['sender_role'])
+        recipient_role = format_role(row['recipient_role'])
+        print(f"  {C_DIM}{time_str}{C_RESET} {C_BOLD}{row['sender_name']}{C_RESET} ({sender_role}) "
+              f"→ {C_BOLD}{row['recipient_name']}{C_RESET} ({recipient_role})")
+        preview = row['content'][:200].replace('\n', ' ')
+        if len(row['content']) > 200:
+            preview += "..."
+        print(f"    {preview}\n")
+
+    db.close()
+
+
+def cmd_channel(args):
+    """Channel management commands."""
+    if not args:
+        print(f"{C_RED}Usage: btmsg channel <create|list|send|history|add> [args]{C_RESET}")
+        return
+
+    subcmd = args[0]
+    subargs = args[1:]
+
+    handlers = {
+        'create': cmd_channel_create,
+        'list': cmd_channel_list,
+        'send': cmd_channel_send,
+        'history': cmd_channel_history,
+        'add': cmd_channel_add,
+    }
+    handler = handlers.get(subcmd)
+    if handler:
+        handler(subargs)
+    else:
+        print(f"{C_RED}Unknown channel command: {subcmd}{C_RESET}")
+
+
+def cmd_channel_create(args):
+    """Create a new channel."""
+    if not args:
+        print(f"{C_RED}Usage: btmsg channel create <name>{C_RESET}")
+        return
+
+    agent_id = get_agent_id()
+    name = args[0]
+    db = get_db()
+
+    agent = get_agent(db, agent_id)
+    if not agent:
+        print(f"{C_RED}Agent '{agent_id}' not registered.{C_RESET}")
+        db.close()
+        return
+
+    channel_id = str(uuid.uuid4())[:8]
+    db.execute(
+        "INSERT INTO channels (id, name, group_id, created_by) VALUES (?, ?, ?, ?)",
+        (channel_id, name, agent['group_id'], agent_id)
+    )
+    db.execute(
+        "INSERT INTO channel_members (channel_id, agent_id) VALUES (?, ?)",
+        (channel_id, agent_id)
+    )
+    db.commit()
+    db.close()
+    print(f"{C_GREEN}✓ Channel #{name} created [{channel_id}]{C_RESET}")
+
+
+def cmd_channel_list(args):
+    """List channels."""
+    agent_id = get_agent_id()
+    db = get_db()
+    agent = get_agent(db, agent_id)
+    if not agent:
+        print(f"{C_RED}Agent '{agent_id}' not registered.{C_RESET}")
+        db.close()
+        return
+
+    rows = db.execute(
+        "SELECT c.*, "
+        "(SELECT COUNT(*) FROM channel_members cm WHERE cm.channel_id = c.id) as member_count, "
+        "(SELECT content FROM channel_messages cm2 WHERE cm2.channel_id = c.id "
+        "ORDER BY cm2.created_at DESC LIMIT 1) as last_msg "
+        "FROM channels c WHERE c.group_id = ? ORDER BY c.name",
+        (agent['group_id'],)
+    ).fetchall()
+
+    print(f"\n{C_BOLD}📢 Channels{C_RESET}\n")
+    if not rows:
+        print(f"  {C_DIM}No channels yet. Create one: btmsg channel create <name>{C_RESET}\n")
+        db.close()
+        return
+
+    for row in rows:
+        last = row['last_msg'] or ""
+        if len(last) > 60:
+            last = last[:60] + "..."
+        print(f"  {C_CYAN}#{row['name']}{C_RESET} ({row['member_count']} members) [{row['id']}]")
+        if last:
+            print(f"    {C_DIM}{last}{C_RESET}")
+
+    print()
+    db.close()
+
+
+def cmd_channel_send(args):
+    """Send message to a channel."""
+    if len(args) < 2:
+        print(f"{C_RED}Usage: btmsg channel send <channel-name> <message>{C_RESET}")
+        return
+
+    agent_id = get_agent_id()
+    channel_ref = args[0]
+    content = " ".join(args[1:])
+    db = get_db()
+
+    agent = get_agent(db, agent_id)
+    if not agent:
+        print(f"{C_RED}Agent '{agent_id}' not registered.{C_RESET}")
+        db.close()
+        return
+
+    channel = db.execute(
+        "SELECT * FROM channels WHERE id = ? OR name = ?",
+        (channel_ref, channel_ref)
+    ).fetchone()
+
+    if not channel:
+        print(f"{C_RED}Channel '{channel_ref}' not found.{C_RESET}")
+        db.close()
+        return
+
+    if agent['tier'] > 0:
+        is_member = db.execute(
+            "SELECT 1 FROM channel_members WHERE channel_id = ? AND agent_id = ?",
+            (channel['id'], agent_id)
+        ).fetchone()
+        if not is_member:
+            print(f"{C_RED}Not a member of #{channel['name']}.{C_RESET}")
+            db.close()
+            return
+
+    msg_id = str(uuid.uuid4())
+    db.execute(
+        "INSERT INTO channel_messages (id, channel_id, from_agent, content) VALUES (?, ?, ?, ?)",
+        (msg_id, channel['id'], agent_id, content)
+    )
+    db.commit()
+    db.close()
+    print(f"{C_GREEN}✓ Sent to #{channel['name']}{C_RESET} [{short_id(msg_id)}]")
+
+
+def cmd_channel_history(args):
+    """Show channel message history."""
+    if not args:
+        print(f"{C_RED}Usage: btmsg channel history <channel-name> [--limit N]{C_RESET}")
+        return
+
+    channel_ref = args[0]
+    limit = 30
+    if "--limit" in args:
+        idx = args.index("--limit")
+        if idx + 1 < len(args):
+            try:
+                limit = int(args[idx + 1])
+            except ValueError:
+                pass
+
+    db = get_db()
+    channel = db.execute(
+        "SELECT * FROM channels WHERE id = ? OR name = ?",
+        (channel_ref, channel_ref)
+    ).fetchone()
+
+    if not channel:
+        print(f"{C_RED}Channel '{channel_ref}' not found.{C_RESET}")
+        db.close()
+        return
+
+    rows = db.execute(
+        "SELECT cm.*, a.name as sender_name, a.role as sender_role "
+        "FROM channel_messages cm JOIN agents a ON cm.from_agent = a.id "
+        "WHERE cm.channel_id = ? ORDER BY cm.created_at ASC LIMIT ?",
+        (channel['id'], limit)
+    ).fetchall()
+
+    print(f"\n{C_BOLD}📢 #{channel['name']}{C_RESET}\n")
+
+    if not rows:
+        print(f"  {C_DIM}No messages yet.{C_RESET}\n")
+        db.close()
+        return
+
+    for row in rows:
+        time_str = format_time(row['created_at'])
+        role_str = format_role(row['sender_role'])
+        print(f"  {C_DIM}{time_str}{C_RESET} {C_BOLD}{row['sender_name']}{C_RESET} ({role_str}): {row['content']}")
+
+    print()
+    db.close()
+
+
+def cmd_channel_add(args):
+    """Add member to a channel."""
+    if len(args) < 2:
+        print(f"{C_RED}Usage: btmsg channel add <channel-name> <agent-id>{C_RESET}")
+        return
+
+    channel_ref = args[0]
+    member_id = args[1]
+    db = get_db()
+
+    channel = db.execute(
+        "SELECT * FROM channels WHERE id = ? OR name = ?",
+        (channel_ref, channel_ref)
+    ).fetchone()
+    if not channel:
+        print(f"{C_RED}Channel '{channel_ref}' not found.{C_RESET}")
+        db.close()
+        return
+
+    member = get_agent(db, member_id)
+    if not member:
+        print(f"{C_RED}Agent '{member_id}' not found.{C_RESET}")
+        db.close()
+        return
+
+    db.execute(
+        "INSERT OR IGNORE INTO channel_members (channel_id, agent_id) VALUES (?, ?)",
+        (channel['id'], member_id)
+    )
+    db.commit()
+    db.close()
+    print(f"{C_GREEN}✓ Added {member['name']} to #{channel['name']}{C_RESET}")
+
+
+def cmd_help(args=None):
+    """Show help."""
+    print(__doc__)
+
+
+# ─── Main dispatch ───────────────────────────────────────────
+
+COMMANDS = {
+    'inbox': cmd_inbox,
+    'read': cmd_read,
+    'send': cmd_send,
+    'reply': cmd_reply,
+    'contacts': cmd_contacts,
+    'history': cmd_history,
+    'status': cmd_status,
+    'register': cmd_register,
+    'allow': cmd_allow,
+    'whoami': cmd_whoami,
+    'graph': cmd_graph,
+    'unread': cmd_unread_count,
+    'notify': cmd_notify,
+    'feed': cmd_feed,
+    'channel': cmd_channel,
+    'help': cmd_help,
+    '--help': cmd_help,
+    '-h': cmd_help,
+}
+
+
+def main():
+    init_db()
+
+    if len(sys.argv) < 2:
+        cmd_help()
+        sys.exit(0)
+
+    command = sys.argv[1]
+    args = sys.argv[2:]
+
+    handler = COMMANDS.get(command)
+    if not handler:
+        print(f"{C_RED}Unknown command: {command}{C_RESET}")
+        cmd_help()
+        sys.exit(1)
+
+    handler(args)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/bttask b/bttask
new file mode 100755
index 0000000..6f642f3
--- /dev/null
+++ b/bttask
@@ -0,0 +1,729 @@
+#!/usr/bin/env python3
+"""
+bttask — Group Task Manager for BTerminal Mission Control.
+
+Hierarchical task management for multi-agent orchestration.
+Tasks stored in SQLite, role-based visibility.
+Agent identity set via BTMSG_AGENT_ID environment variable.
+
+Usage: bttask <command> [args]
+
+Commands:
+  list [--all]         Show tasks (filtered by role visibility)
+  add <title>          Create task (Manager/Architect only)
+  assign <id> <agent>  Assign task to agent (Manager only)
+  status <id> <state>  Set task status (todo/progress/review/done/blocked)
+  comment <id> <text>  Add comment to task
+  show <id>            Show task details with comments
+  board                Kanban board view
+  delete <id>          Delete task (Manager only)
+  priorities           Reorder tasks by priority
+"""
+
+import sqlite3
+import sys
+import os
+import uuid
+from pathlib import Path
+from datetime import datetime
+
+DB_PATH = Path.home() / ".local" / "share" / "bterminal" / "btmsg.db"
+
+TASK_STATES = ['todo', 'progress', 'review', 'done', 'blocked']
+
+# Roles that can create tasks
+CREATOR_ROLES = {'manager', 'architect'}
+# Roles that can assign tasks
+ASSIGNER_ROLES = {'manager'}
+# Roles that can see full task list
+VIEWER_ROLES = {'manager', 'architect', 'tester'}
+
+# Colors
+C_RESET = "\033[0m"
+C_BOLD = "\033[1m"
+C_DIM = "\033[2m"
+C_RED = "\033[31m"
+C_GREEN = "\033[32m"
+C_YELLOW = "\033[33m"
+C_BLUE = "\033[34m"
+C_MAGENTA = "\033[35m"
+C_CYAN = "\033[36m"
+C_WHITE = "\033[37m"
+
+STATE_COLORS = {
+    'todo': C_WHITE,
+    'progress': C_CYAN,
+    'review': C_YELLOW,
+    'done': C_GREEN,
+    'blocked': C_RED,
+}
+
+STATE_ICONS = {
+    'todo': '○',
+    'progress': '◐',
+    'review': '◑',
+    'done': '●',
+    'blocked': '✗',
+}
+
+PRIORITY_COLORS = {
+    'critical': C_RED,
+    'high': C_YELLOW,
+    'medium': C_WHITE,
+    'low': C_DIM,
+}
+
+
+def get_db():
+    DB_PATH.parent.mkdir(parents=True, exist_ok=True)
+    db = sqlite3.connect(str(DB_PATH))
+    db.row_factory = sqlite3.Row
+    db.execute("PRAGMA journal_mode=WAL")
+    return db
+
+
+def init_db():
+    db = get_db()
+    db.executescript("""
+        CREATE TABLE IF NOT EXISTS tasks (
+            id TEXT PRIMARY KEY,
+            title TEXT NOT NULL,
+            description TEXT DEFAULT '',
+            status TEXT DEFAULT 'todo',
+            priority TEXT DEFAULT 'medium',
+            assigned_to TEXT,
+            created_by TEXT NOT NULL,
+            group_id TEXT NOT NULL,
+            parent_task_id TEXT,
+            sort_order INTEGER DEFAULT 0,
+            created_at TEXT DEFAULT (datetime('now')),
+            updated_at TEXT DEFAULT (datetime('now')),
+            version INTEGER DEFAULT 1,
+            FOREIGN KEY (assigned_to) REFERENCES agents(id),
+            FOREIGN KEY (created_by) REFERENCES agents(id)
+        );
+
+        CREATE TABLE IF NOT EXISTS task_comments (
+            id TEXT PRIMARY KEY,
+            task_id TEXT NOT NULL,
+            agent_id TEXT NOT NULL,
+            content TEXT NOT NULL,
+            created_at TEXT DEFAULT (datetime('now')),
+            FOREIGN KEY (task_id) REFERENCES tasks(id),
+            FOREIGN KEY (agent_id) REFERENCES agents(id)
+        );
+
+        CREATE INDEX IF NOT EXISTS idx_tasks_group ON tasks(group_id);
+        CREATE INDEX IF NOT EXISTS idx_tasks_status ON tasks(status);
+        CREATE INDEX IF NOT EXISTS idx_tasks_assigned ON tasks(assigned_to);
+        CREATE INDEX IF NOT EXISTS idx_task_comments_task ON task_comments(task_id);
+    """)
+
+    # Migration: add version column if missing (for existing databases)
+    cursor = db.execute("PRAGMA table_info(tasks)")
+    columns = [row[1] for row in cursor.fetchall()]
+    if 'version' not in columns:
+        db.execute("ALTER TABLE tasks ADD COLUMN version INTEGER DEFAULT 1")
+        db.commit()
+
+    db.commit()
+    db.close()
+
+
+def get_agent_id():
+    agent_id = os.environ.get("BTMSG_AGENT_ID")
+    if not agent_id:
+        print(f"{C_RED}Error: BTMSG_AGENT_ID not set.{C_RESET}")
+        sys.exit(1)
+    return agent_id
+
+
+def get_agent(db, agent_id):
+    return db.execute("SELECT * FROM agents WHERE id = ?", (agent_id,)).fetchone()
+
+
+def short_id(task_id):
+    return task_id[:8] if task_id else "?"
+
+
+def format_time(ts_str):
+    if not ts_str:
+        return "?"
+    try:
+        dt = datetime.fromisoformat(ts_str)
+        return dt.strftime("%m-%d %H:%M")
+    except (ValueError, TypeError):
+        return ts_str[:16]
+
+
+def format_state(state):
+    icon = STATE_ICONS.get(state, '?')
+    color = STATE_COLORS.get(state, C_RESET)
+    return f"{color}{icon} {state}{C_RESET}"
+
+
+def format_priority(priority):
+    color = PRIORITY_COLORS.get(priority, C_RESET)
+    return f"{color}{priority}{C_RESET}"
+
+
+def check_role(db, agent_id, allowed_roles, action="do this"):
+    agent = get_agent(db, agent_id)
+    if not agent:
+        print(f"{C_RED}Agent '{agent_id}' not registered.{C_RESET}")
+        return None
+    if agent['role'] not in allowed_roles:
+        print(f"{C_RED}Permission denied: {agent['role']} cannot {action}.{C_RESET}")
+        print(f"{C_DIM}Required roles: {', '.join(allowed_roles)}{C_RESET}")
+        return None
+    return agent
+
+
+def find_task(db, task_id_prefix, group_id=None):
+    """Find task by ID prefix, optionally filtered by group."""
+    if group_id:
+        return db.execute(
+            "SELECT * FROM tasks WHERE id LIKE ? AND group_id = ?",
+            (task_id_prefix + "%", group_id)
+        ).fetchone()
+    return db.execute(
+        "SELECT * FROM tasks WHERE id LIKE ?", (task_id_prefix + "%",)
+    ).fetchone()
+
+
+# ─── Commands ────────────────────────────────────────────────
+
+def cmd_list(args):
+    """List tasks visible to current agent."""
+    agent_id = get_agent_id()
+    show_all = "--all" in args
+    db = get_db()
+
+    agent = get_agent(db, agent_id)
+    if not agent:
+        print(f"{C_RED}Agent '{agent_id}' not registered.{C_RESET}")
+        db.close()
+        return
+
+    # Tier 2 agents cannot see task list
+    if agent['role'] not in VIEWER_ROLES:
+        print(f"{C_RED}Access denied: project agents don't see the task list.{C_RESET}")
+        print(f"{C_DIM}Tasks are assigned to you via btmsg messages.{C_RESET}")
+        db.close()
+        return
+
+    group_id = agent['group_id']
+
+    if show_all:
+        rows = db.execute(
+            "SELECT t.*, a.name as assignee_name FROM tasks t "
+            "LEFT JOIN agents a ON t.assigned_to = a.id "
+            "WHERE t.group_id = ? ORDER BY t.sort_order, t.created_at",
+            (group_id,)
+        ).fetchall()
+    else:
+        rows = db.execute(
+            "SELECT t.*, a.name as assignee_name FROM tasks t "
+            "LEFT JOIN agents a ON t.assigned_to = a.id "
+            "WHERE t.group_id = ? AND t.status != 'done' "
+            "ORDER BY t.sort_order, t.created_at",
+            (group_id,)
+        ).fetchall()
+
+    if not rows:
+        print(f"{C_DIM}No tasks.{C_RESET}")
+        db.close()
+        return
+
+    label = "All tasks" if show_all else "Active tasks"
+    print(f"\n{C_BOLD}📋 {label} ({len(rows)}):{C_RESET}\n")
+
+    for row in rows:
+        state_str = format_state(row['status'])
+        priority_str = format_priority(row['priority'])
+        assignee = row['assignee_name'] or f"{C_DIM}unassigned{C_RESET}"
+        print(f"  {state_str}  [{short_id(row['id'])}] {C_BOLD}{row['title']}{C_RESET}")
+        print(f"        {priority_str} → {assignee}  {C_DIM}{format_time(row['updated_at'])}{C_RESET}")
+
+        # Show comment count
+        count = db.execute(
+            "SELECT COUNT(*) FROM task_comments WHERE task_id = ?", (row['id'],)
+        ).fetchone()[0]
+        if count > 0:
+            print(f"        {C_DIM}💬 {count} comment{'s' if count != 1 else ''}{C_RESET}")
+        print()
+
+    db.close()
+
+
+def cmd_add(args):
+    """Create a new task."""
+    if not args:
+        print(f"{C_RED}Usage: bttask add <title> [--desc TEXT] [--priority critical|high|medium|low] [--assign AGENT] [--parent TASK_ID]{C_RESET}")
+        return
+
+    agent_id = get_agent_id()
+    db = get_db()
+
+    agent = check_role(db, agent_id, CREATOR_ROLES, "create tasks")
+    if not agent:
+        db.close()
+        return
+
+    # Parse args
+    title_parts = []
+    description = ""
+    priority = "medium"
+    assign_to = None
+    parent_id = None
+
+    i = 0
+    while i < len(args):
+        if args[i] == "--desc" and i + 1 < len(args):
+            description = args[i + 1]
+            i += 2
+        elif args[i] == "--priority" and i + 1 < len(args):
+            priority = args[i + 1]
+            if priority not in PRIORITY_COLORS:
+                print(f"{C_RED}Invalid priority: {priority}. Use: critical, high, medium, low{C_RESET}")
+                db.close()
+                return
+            i += 2
+        elif args[i] == "--assign" and i + 1 < len(args):
+            assign_to = args[i + 1]
+            i += 2
+        elif args[i] == "--parent" and i + 1 < len(args):
+            parent_id = args[i + 1]
+            i += 2
+        else:
+            title_parts.append(args[i])
+            i += 1
+
+    title = " ".join(title_parts)
+    if not title:
+        print(f"{C_RED}Title is required.{C_RESET}")
+        db.close()
+        return
+
+    # Verify assignee if specified
+    if assign_to:
+        assignee = get_agent(db, assign_to)
+        if not assignee:
+            # prefix match
+            row = db.execute("SELECT * FROM agents WHERE id LIKE ?", (assign_to + "%",)).fetchone()
+            if row:
+                assign_to = row['id']
+            else:
+                print(f"{C_RED}Agent '{assign_to}' not found.{C_RESET}")
+                db.close()
+                return
+
+    # Resolve parent task
+    if parent_id:
+        parent = find_task(db, parent_id, agent['group_id'])
+        if not parent:
+            print(f"{C_RED}Parent task '{parent_id}' not found.{C_RESET}")
+            db.close()
+            return
+        parent_id = parent['id']
+
+    # Get max sort_order
+    max_order = db.execute(
+        "SELECT COALESCE(MAX(sort_order), 0) FROM tasks WHERE group_id = ?",
+        (agent['group_id'],)
+    ).fetchone()[0]
+
+    task_id = str(uuid.uuid4())
+    db.execute(
+        "INSERT INTO tasks (id, title, description, priority, assigned_to, created_by, "
+        "group_id, parent_task_id, sort_order) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)",
+        (task_id, title, description, priority, assign_to, agent_id,
+         agent['group_id'], parent_id, max_order + 1)
+    )
+    db.commit()
+    db.close()
+
+    print(f"{C_GREEN}✓ Created: {title}{C_RESET} [{short_id(task_id)}]")
+    if assign_to:
+        print(f"  {C_DIM}Assigned to: {assign_to}{C_RESET}")
+
+
+def cmd_assign(args):
+    """Assign task to an agent."""
+    if len(args) < 2:
+        print(f"{C_RED}Usage: bttask assign <task-id> <agent-id>{C_RESET}")
+        return
+
+    agent_id = get_agent_id()
+    db = get_db()
+
+    agent = check_role(db, agent_id, ASSIGNER_ROLES, "assign tasks")
+    if not agent:
+        db.close()
+        return
+
+    task = find_task(db, args[0], agent['group_id'])
+    if not task:
+        print(f"{C_RED}Task not found.{C_RESET}")
+        db.close()
+        return
+
+    assignee_id = args[1]
+    assignee = get_agent(db, assignee_id)
+    if not assignee:
+        row = db.execute("SELECT * FROM agents WHERE id LIKE ?", (assignee_id + "%",)).fetchone()
+        if row:
+            assignee = row
+            assignee_id = row['id']
+        else:
+            print(f"{C_RED}Agent '{assignee_id}' not found.{C_RESET}")
+            db.close()
+            return
+
+    db.execute(
+        "UPDATE tasks SET assigned_to = ?, updated_at = datetime('now') WHERE id = ?",
+        (assignee_id, task['id'])
+    )
+    db.commit()
+    db.close()
+
+    print(f"{C_GREEN}✓ Assigned [{short_id(task['id'])}] to {assignee['name']}{C_RESET}")
+
+
+def cmd_status(args):
+    """Change task status."""
+    if len(args) < 2:
+        print(f"{C_RED}Usage: bttask status <task-id> <{'/'.join(TASK_STATES)}>{C_RESET}")
+        return
+
+    agent_id = get_agent_id()
+    new_status = args[1]
+
+    if new_status not in TASK_STATES:
+        print(f"{C_RED}Invalid status: {new_status}. Use: {', '.join(TASK_STATES)}{C_RESET}")
+        return
+
+    db = get_db()
+    agent = get_agent(db, agent_id)
+    if not agent:
+        print(f"{C_RED}Agent '{agent_id}' not registered.{C_RESET}")
+        db.close()
+        return
+
+    task = find_task(db, args[0], agent['group_id'])
+    if not task:
+        print(f"{C_RED}Task not found.{C_RESET}")
+        db.close()
+        return
+
+    # Tier 2 can only update tasks assigned to them
+    if agent['role'] not in VIEWER_ROLES and task['assigned_to'] != agent_id:
+        print(f"{C_RED}Cannot update task not assigned to you.{C_RESET}")
+        db.close()
+        return
+
+    old_status = task['status']
+    current_version = task['version'] if task['version'] is not None else 1
+
+    cursor = db.execute(
+        "UPDATE tasks SET status = ?, version = version + 1, updated_at = datetime('now') "
+        "WHERE id = ? AND version = ?",
+        (new_status, task['id'], current_version)
+    )
+
+    if cursor.rowcount == 0:
+        print(f"{C_RED}Error: Task was modified by another agent (version conflict).{C_RESET}")
+        print(f"{C_DIM}Re-fetch the task and try again.{C_RESET}")
+        db.close()
+        sys.exit(1)
+
+    # Auto-add comment for status change
+    comment_id = str(uuid.uuid4())
+    db.execute(
+        "INSERT INTO task_comments (id, task_id, agent_id, content) VALUES (?, ?, ?, ?)",
+        (comment_id, task['id'], agent_id, f"Status: {old_status} → {new_status}")
+    )
+
+    db.commit()
+    db.close()
+
+    new_version = current_version + 1
+    print(f"{C_GREEN}✓ [{short_id(task['id'])}] {format_state(old_status)} → {format_state(new_status)} {C_DIM}(v{new_version}){C_RESET}")
+
+
+def cmd_comment(args):
+    """Add comment to a task."""
+    if len(args) < 2:
+        print(f"{C_RED}Usage: bttask comment <task-id> <text>{C_RESET}")
+        return
+
+    agent_id = get_agent_id()
+    db = get_db()
+
+    agent = get_agent(db, agent_id)
+    if not agent:
+        print(f"{C_RED}Agent '{agent_id}' not registered.{C_RESET}")
+        db.close()
+        return
+
+    task = find_task(db, args[0], agent['group_id'])
+    if not task:
+        print(f"{C_RED}Task not found.{C_RESET}")
+        db.close()
+        return
+
+    content = " ".join(args[1:])
+    comment_id = str(uuid.uuid4())
+    db.execute(
+        "INSERT INTO task_comments (id, task_id, agent_id, content) VALUES (?, ?, ?, ?)",
+        (comment_id, task['id'], agent_id, content)
+    )
+    db.execute(
+        "UPDATE tasks SET updated_at = datetime('now') WHERE id = ?", (task['id'],)
+    )
+    db.commit()
+    db.close()
+
+    print(f"{C_GREEN}✓ Comment added to [{short_id(task['id'])}]{C_RESET}")
+
+
+def cmd_show(args):
+    """Show task details with comments."""
+    if not args:
+        print(f"{C_RED}Usage: bttask show <task-id>{C_RESET}")
+        return
+
+    agent_id = get_agent_id()
+    db = get_db()
+
+    agent = get_agent(db, agent_id)
+    if not agent:
+        print(f"{C_RED}Agent '{agent_id}' not registered.{C_RESET}")
+        db.close()
+        return
+
+    task = find_task(db, args[0], agent['group_id'])
+    if not task:
+        print(f"{C_RED}Task not found.{C_RESET}")
+        db.close()
+        return
+
+    # Get assignee name
+    assignee_name = "unassigned"
+    if task['assigned_to']:
+        assignee = get_agent(db, task['assigned_to'])
+        if assignee:
+            assignee_name = assignee['name']
+
+    # Get creator name
+    creator = get_agent(db, task['created_by'])
+    creator_name = creator['name'] if creator else task['created_by']
+
+    print(f"\n{C_BOLD}{'─' * 60}{C_RESET}")
+    print(f"  {format_state(task['status'])}  {C_BOLD}{task['title']}{C_RESET}")
+    print(f"{C_BOLD}{'─' * 60}{C_RESET}")
+    print(f"  {C_DIM}ID:{C_RESET}       {task['id']}")
+    print(f"  {C_DIM}Priority:{C_RESET} {format_priority(task['priority'])}")
+    print(f"  {C_DIM}Assigned:{C_RESET} {assignee_name}")
+    print(f"  {C_DIM}Created:{C_RESET}  {creator_name} @ {format_time(task['created_at'])}")
+    print(f"  {C_DIM}Updated:{C_RESET}  {format_time(task['updated_at'])}")
+
+    if task['description']:
+        print(f"\n  {task['description']}")
+
+    if task['parent_task_id']:
+        parent = find_task(db, task['parent_task_id'])
+        if parent:
+            print(f"  {C_DIM}Parent:{C_RESET}   [{short_id(parent['id'])}] {parent['title']}")
+
+    # Subtasks
+    subtasks = db.execute(
+        "SELECT * FROM tasks WHERE parent_task_id = ? ORDER BY sort_order",
+        (task['id'],)
+    ).fetchall()
+    if subtasks:
+        print(f"\n  {C_BOLD}Subtasks:{C_RESET}")
+        for st in subtasks:
+            print(f"    {format_state(st['status'])} [{short_id(st['id'])}] {st['title']}")
+
+    # Comments
+    comments = db.execute(
+        "SELECT c.*, a.name as agent_name, a.role as agent_role "
+        "FROM task_comments c JOIN agents a ON c.agent_id = a.id "
+        "WHERE c.task_id = ? ORDER BY c.created_at ASC",
+        (task['id'],)
+    ).fetchall()
+
+    if comments:
+        print(f"\n  {C_BOLD}Comments ({len(comments)}):{C_RESET}")
+        for c in comments:
+            time_str = format_time(c['created_at'])
+            print(f"    {C_DIM}{time_str}{C_RESET} {C_BOLD}{c['agent_name']}{C_RESET}: {c['content']}")
+
+    print(f"\n{C_BOLD}{'─' * 60}{C_RESET}\n")
+    db.close()
+
+
+def cmd_board(args):
+    """Kanban board view."""
+    agent_id = get_agent_id()
+    db = get_db()
+
+    agent = get_agent(db, agent_id)
+    if not agent:
+        print(f"{C_RED}Agent '{agent_id}' not registered.{C_RESET}")
+        db.close()
+        return
+
+    if agent['role'] not in VIEWER_ROLES:
+        print(f"{C_RED}Access denied: project agents don't see the task board.{C_RESET}")
+        db.close()
+        return
+
+    group_id = agent['group_id']
+
+    # Get all tasks grouped by status
+    all_tasks = db.execute(
+        "SELECT t.*, a.name as assignee_name FROM tasks t "
+        "LEFT JOIN agents a ON t.assigned_to = a.id "
+        "WHERE t.group_id = ? ORDER BY t.sort_order, t.created_at",
+        (group_id,)
+    ).fetchall()
+
+    columns = {}
+    for state in TASK_STATES:
+        columns[state] = [t for t in all_tasks if t['status'] == state]
+
+    # Calculate column width
+    col_width = 20
+
+    # Header
+    print(f"\n{C_BOLD}  📋 Task Board{C_RESET}\n")
+
+    # Column headers
+    header_line = "  "
+    for state in TASK_STATES:
+        icon = STATE_ICONS[state]
+        color = STATE_COLORS[state]
+        count = len(columns[state])
+        col_header = f"{color}{icon} {state.upper()} ({count}){C_RESET}"
+        header_line += col_header.ljust(col_width + len(color) + len(C_RESET) + 5)
+    print(header_line)
+    print(f"  {'─' * (col_width * len(TASK_STATES) + 10)}")
+
+    # Find max rows
+    max_rows = max(len(columns[s]) for s in TASK_STATES) if all_tasks else 0
+
+    for row_idx in range(max_rows):
+        line = "  "
+        for state in TASK_STATES:
+            tasks_in_col = columns[state]
+            if row_idx < len(tasks_in_col):
+                t = tasks_in_col[row_idx]
+                title = t['title'][:col_width - 2]
+                assignee = (t['assignee_name'] or "?")[:8]
+                priority_c = PRIORITY_COLORS.get(t['priority'], C_RESET)
+                cell = f"{priority_c}{short_id(t['id'])}{C_RESET} {title}"
+                # Pad to column width (accounting for color codes)
+                visible_len = len(short_id(t['id'])) + 1 + len(title)
+                padding = max(0, col_width - visible_len)
+                line += cell + " " * padding + "  "
+            else:
+                line += " " * (col_width + 2)
+        print(line)
+
+        # Second line with assignee
+        line2 = "  "
+        for state in TASK_STATES:
+            tasks_in_col = columns[state]
+            if row_idx < len(tasks_in_col):
+                t = tasks_in_col[row_idx]
+                assignee = (t['assignee_name'] or "unassigned")[:col_width - 2]
+                cell = f"{C_DIM}  → {assignee}{C_RESET}"
+                visible_len = 4 + len(assignee)
+                padding = max(0, col_width - visible_len)
+                line2 += cell + " " * padding + "  "
+            else:
+                line2 += " " * (col_width + 2)
+        print(line2)
+        print()
+
+    if not all_tasks:
+        print(f"  {C_DIM}No tasks. Create one: bttask add \"Task title\"{C_RESET}")
+
+    print()
+    db.close()
+
+
+def cmd_delete(args):
+    """Delete a task."""
+    if not args:
+        print(f"{C_RED}Usage: bttask delete <task-id>{C_RESET}")
+        return
+
+    agent_id = get_agent_id()
+    db = get_db()
+
+    agent = check_role(db, agent_id, ASSIGNER_ROLES, "delete tasks")
+    if not agent:
+        db.close()
+        return
+
+    task = find_task(db, args[0], agent['group_id'])
+    if not task:
+        print(f"{C_RED}Task not found.{C_RESET}")
+        db.close()
+        return
+
+    title = task['title']
+    db.execute("DELETE FROM task_comments WHERE task_id = ?", (task['id'],))
+    db.execute("DELETE FROM tasks WHERE id = ?", (task['id'],))
+    db.commit()
+    db.close()
+
+    print(f"{C_GREEN}✓ Deleted: {title}{C_RESET}")
+
+
+def cmd_help(args=None):
+    """Show help."""
+    print(__doc__)
+
+
+# ─── Main dispatch ───────────────────────────────────────────
+
+COMMANDS = {
+    'list': cmd_list,
+    'add': cmd_add,
+    'assign': cmd_assign,
+    'status': cmd_status,
+    'comment': cmd_comment,
+    'show': cmd_show,
+    'board': cmd_board,
+    'delete': cmd_delete,
+    'help': cmd_help,
+    '--help': cmd_help,
+    '-h': cmd_help,
+}
+
+
+def main():
+    init_db()
+
+    if len(sys.argv) < 2:
+        cmd_help()
+        sys.exit(0)
+
+    command = sys.argv[1]
+    args = sys.argv[2:]
+
+    handler = COMMANDS.get(command)
+    if not handler:
+        print(f"{C_RED}Unknown command: {command}{C_RESET}")
+        cmd_help()
+        sys.exit(1)
+
+    handler(args)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/ctx b/ctx
index b54115d..a089e76 100755
--- a/ctx
+++ b/ctx
@@ -8,15 +8,14 @@ Usage: ctx <command> [args]
 
 import sqlite3
 import sys
-import os
 import json
-from datetime import datetime, timezone
 from pathlib import Path
 
 DB_PATH = Path.home() / ".claude-context" / "context.db"
 
 
 def get_db():
+    DB_PATH.parent.mkdir(parents=True, exist_ok=True)
     db = sqlite3.connect(str(DB_PATH))
     db.row_factory = sqlite3.Row
     db.execute("PRAGMA journal_mode=WAL")
@@ -104,19 +103,18 @@ def cmd_init(args):
 
 
 def cmd_get(args):
-    """Get full context for a project (shared + project-specific + recent summaries)."""
+    """Get full context for a project (project-specific + recent summaries).
+    Use --shared flag to also include shared context."""
     if len(args) < 1:
-        print("Usage: ctx get <project>")
+        print("Usage: ctx get <project> [--shared]")
         sys.exit(1)
     project = args[0]
+    show_shared = "--shared" in args
     db = get_db()
 
     # Session info
     session = db.execute("SELECT * FROM sessions WHERE name = ?", (project,)).fetchone()
 
-    # Shared context
-    shared = db.execute("SELECT key, value FROM shared ORDER BY key").fetchall()
-
     # Project context
     contexts = db.execute(
         "SELECT key, value FROM contexts WHERE project = ? ORDER BY key", (project,)
@@ -138,11 +136,13 @@ def cmd_get(args):
         print(f"PROJECT: {project} (not registered, use: ctx init)")
     print("=" * 60)
 
-    if shared:
-        print("\n--- Shared Context ---")
-        for row in shared:
-            print(f"\n[{row['key']}]")
-            print(row["value"])
+    if show_shared:
+        shared = db.execute("SELECT key, value FROM shared ORDER BY key").fetchall()
+        if shared:
+            print("\n--- Shared Context ---")
+            for row in shared:
+                print(f"\n[{row['key']}]")
+                print(row["value"])
 
     if contexts:
         print(f"\n--- {project} Context ---")
@@ -156,8 +156,8 @@ def cmd_get(args):
             print(f"\n[{row['created_at']}]")
             print(row["summary"])
 
-    if not shared and not contexts and not summaries:
-        print("\nNo context stored yet. Use 'ctx set' or 'ctx shared set' to add.")
+    if not contexts and not summaries:
+        print("\nNo context stored yet. Use 'ctx set' to add project context.")
 
     db.close()
 
@@ -279,7 +279,11 @@ def cmd_history(args):
         print("Usage: ctx history <project> [limit]")
         sys.exit(1)
     project = args[0]
-    limit = int(args[1]) if len(args) > 1 else 10
+    try:
+        limit = int(args[1]) if len(args) > 1 else 10
+    except ValueError:
+        print(f"Error: limit must be an integer, got '{args[1]}'")
+        sys.exit(1)
     db = get_db()
     rows = db.execute(
         "SELECT summary, created_at FROM summaries WHERE project = ? ORDER BY created_at DESC LIMIT ?",
@@ -302,16 +306,24 @@ def cmd_search(args):
     query = " ".join(args)
     db = get_db()
 
-    # Search project contexts
-    results_ctx = db.execute(
-        "SELECT project, key, value FROM contexts_fts WHERE contexts_fts MATCH ?",
-        (query,),
-    ).fetchall()
+    # Search project contexts (FTS5 MATCH can fail on malformed query syntax)
+    try:
+        results_ctx = db.execute(
+            "SELECT project, key, value FROM contexts_fts WHERE contexts_fts MATCH ?",
+            (query,),
+        ).fetchall()
+    except sqlite3.OperationalError:
+        print(f"Invalid search query: '{query}' (FTS5 syntax error)")
+        db.close()
+        sys.exit(1)
 
     # Search shared contexts
-    results_shared = db.execute(
-        "SELECT key, value FROM shared_fts WHERE shared_fts MATCH ?", (query,)
-    ).fetchall()
+    try:
+        results_shared = db.execute(
+            "SELECT key, value FROM shared_fts WHERE shared_fts MATCH ?", (query,)
+        ).fetchall()
+    except sqlite3.OperationalError:
+        results_shared = []
 
     # Search summaries (simple LIKE since no FTS on summaries)
     results_sum = db.execute(
@@ -433,7 +445,7 @@ def print_help():
     print("ctx — Cross-session context manager for Claude Code\n")
     print("Commands:")
     print("  init <project> <desc> [dir]   Register a new project")
-    print("  get <project>                 Load full context (shared + project)")
+    print("  get <project> [--shared]      Load project context (optionally with shared)")
     print("  set <project> <key> <value>   Set project context entry")
     print("  append <project> <key> <val>  Append to existing entry")
     print("  shared get|set|delete         Manage shared context")
diff --git a/docker/tempo/docker-compose.yaml b/docker/tempo/docker-compose.yaml
new file mode 100644
index 0000000..95857b3
--- /dev/null
+++ b/docker/tempo/docker-compose.yaml
@@ -0,0 +1,27 @@
+services:
+  tempo:
+    image: grafana/tempo:latest
+    command: ["-config.file=/etc/tempo.yaml"]
+    volumes:
+      - ./tempo.yaml:/etc/tempo.yaml:ro
+      - tempo-data:/var/tempo
+    ports:
+      - "4317:4317"   # OTLP gRPC
+      - "4318:4318"   # OTLP HTTP
+      - "3200:3200"   # Tempo query API
+
+  grafana:
+    image: grafana/grafana:latest
+    environment:
+      - GF_AUTH_ANONYMOUS_ENABLED=true
+      - GF_AUTH_ANONYMOUS_ORG_ROLE=Admin
+      - GF_AUTH_DISABLE_LOGIN_FORM=true
+    volumes:
+      - ./grafana-datasources.yaml:/etc/grafana/provisioning/datasources/datasources.yaml:ro
+    ports:
+      - "9715:3000"   # Grafana UI (project port convention)
+    depends_on:
+      - tempo
+
+volumes:
+  tempo-data:
diff --git a/docker/tempo/grafana-datasources.yaml b/docker/tempo/grafana-datasources.yaml
new file mode 100644
index 0000000..c5ceb4f
--- /dev/null
+++ b/docker/tempo/grafana-datasources.yaml
@@ -0,0 +1,11 @@
+apiVersion: 1
+
+datasources:
+  - name: Tempo
+    type: tempo
+    access: proxy
+    url: http://tempo:3200
+    isDefault: true
+    jsonData:
+      tracesToLogsV2:
+        datasourceUid: ''
diff --git a/docker/tempo/tempo.yaml b/docker/tempo/tempo.yaml
new file mode 100644
index 0000000..2eb3414
--- /dev/null
+++ b/docker/tempo/tempo.yaml
@@ -0,0 +1,19 @@
+server:
+  http_listen_port: 3200
+
+distributor:
+  receivers:
+    otlp:
+      protocols:
+        grpc:
+          endpoint: 0.0.0.0:4317
+        http:
+          endpoint: 0.0.0.0:4318
+
+storage:
+  trace:
+    backend: local
+    local:
+      path: /var/tempo/traces
+    wal:
+      path: /var/tempo/wal
diff --git a/docs/README.md b/docs/README.md
index e68a108..7ee6af9 100644
--- a/docs/README.md
+++ b/docs/README.md
@@ -11,3 +11,31 @@ description: "Project documentation index"
 Project documentation lives here.
 
 > This directory is maintained automatically. When features are added or changed, corresponding documentation is updated.
+
+## Index
+
+### v2 Documentation
+| Document | Description |
+|----------|-------------|
+| [task_plan.md](task_plan.md) | v2 architecture decisions, error handling, testing strategy |
+| [phases.md](phases.md) | v2 implementation phases (1-7 + multi-machine A-D + profiles/skills) with checklists |
+| [findings.md](findings.md) | Research findings (Agent SDK, Tauri, xterm.js, performance) |
+| [multi-machine.md](multi-machine.md) | Multi-machine support architecture (implemented, WebSocket relay, reconnection) |
+
+### v3 Mission Control Documentation
+| Document | Description |
+|----------|-------------|
+| [v3-task_plan.md](v3-task_plan.md) | v3 Mission Control architecture: adversarial review, data model, component tree, layout system, 10-phase plan |
+| [v3-findings.md](v3-findings.md) | v3 adversarial review results and codebase reuse analysis |
+| [v3-progress.md](v3-progress.md) | v3 session progress log (All Phases 1-10 complete) |
+
+### Testing
+| Document | Description |
+|----------|-------------|
+| [e2e-testing.md](e2e-testing.md) | E2E testing facility: fixtures, test mode, LLM judge, spec phases, CI |
+
+### Progress Logs
+| Document | Description |
+|----------|-------------|
+| [progress.md](progress.md) | Session-by-session progress log (recent sessions, v2 + v3) |
+| [progress-archive.md](progress-archive.md) | Archived progress log (2026-03-05 to 2026-03-06 early) |
diff --git a/docs/e2e-testing.md b/docs/e2e-testing.md
new file mode 100644
index 0000000..3c84e87
--- /dev/null
+++ b/docs/e2e-testing.md
@@ -0,0 +1,282 @@
+# E2E Testing Facility
+
+BTerminal's end-to-end testing uses **WebDriverIO + tauri-driver** to drive the real Tauri application through WebKit2GTK's inspector protocol. The facility has three pillars:
+
+1. **Test Fixtures** — isolated fake environments with dummy projects
+2. **Test Mode** — app-level env vars that disable watchers and redirect data/config paths
+3. **LLM Judge** — Claude-powered semantic assertions for evaluating agent behavior
+
+## Quick Start
+
+```bash
+# Run all tests (vitest + cargo + E2E)
+cd v2 && npm run test:all:e2e
+
+# Run E2E only (requires pre-built debug binary)
+cd v2 && SKIP_BUILD=1 npm run test:e2e
+
+# Build debug binary separately (faster iteration)
+cd v2 && cargo tauri build --debug --no-bundle
+
+# Run with LLM judge via CLI (default, auto-detected)
+cd v2 && npm run test:e2e
+
+# Force LLM judge to use API instead of CLI
+cd v2 && LLM_JUDGE_BACKEND=api ANTHROPIC_API_KEY=sk-... npm run test:e2e
+```
+
+## Prerequisites
+
+| Dependency | Purpose | Install |
+|-----------|---------|---------|
+| Rust + Cargo | Build Tauri backend | [rustup.rs](https://rustup.rs) |
+| Node.js 20+ | Frontend + test runner | `mise install node` |
+| tauri-driver | WebDriver bridge to WebKit2GTK | `cargo install tauri-driver` |
+| X11 display | WebKit2GTK needs a display | Real X, or `xvfb-run` in CI |
+| Claude CLI | LLM judge (optional) | [claude.ai/download](https://claude.ai/download) |
+
+## Architecture
+
+```
+┌─────────────────────────────────────────────────────────┐
+│ WebDriverIO (mocha runner)                              │
+│   specs/*.test.ts                                       │
+│     └─ browser.execute() → DOM queries + assertions     │
+│     └─ assertWithJudge() → LLM semantic evaluation     │
+├─────────────────────────────────────────────────────────┤
+│ tauri-driver (port 4444)                                │
+│   WebDriver protocol ↔ WebKit2GTK inspector             │
+├─────────────────────────────────────────────────────────┤
+│ BTerminal debug binary                                  │
+│   BTERMINAL_TEST=1 (disables watchers, wake scheduler)  │
+│   BTERMINAL_TEST_DATA_DIR → isolated SQLite DBs         │
+│   BTERMINAL_TEST_CONFIG_DIR → test groups.json          │
+└─────────────────────────────────────────────────────────┘
+```
+
+## Pillar 1: Test Fixtures (`fixtures.ts`)
+
+The fixture generator creates isolated temporary environments so tests never touch real user data. Each fixture includes:
+
+- **Temp root dir** under `/tmp/bterminal-e2e-{timestamp}/`
+- **Data dir** — empty, SQLite databases created at runtime
+- **Config dir** — contains a generated `groups.json` with test projects
+- **Project dir** — a real git repo with `README.md` and `hello.py` (for agent testing)
+
+### Single-Project Fixture
+
+```typescript
+import { createTestFixture, destroyTestFixture } from '../fixtures';
+
+const fixture = createTestFixture('my-test');
+
+// fixture.rootDir    → /tmp/my-test-1710234567890/
+// fixture.dataDir    → /tmp/my-test-1710234567890/data/
+// fixture.configDir  → /tmp/my-test-1710234567890/config/
+// fixture.projectDir → /tmp/my-test-1710234567890/test-project/
+// fixture.env        → { BTERMINAL_TEST: '1', BTERMINAL_TEST_DATA_DIR: '...', BTERMINAL_TEST_CONFIG_DIR: '...' }
+
+// The test project is a git repo with:
+//   README.md  — "# Test Project\n\nA simple test project for BTerminal E2E tests."
+//   hello.py   — "def greet(name: str) -> str:\n    return f\"Hello, {name}!\""
+// Both committed as "initial commit"
+
+// groups.json contains one group "Test Group" with one project pointing at projectDir
+
+// Cleanup when done:
+destroyTestFixture(fixture);
+```
+
+### Multi-Project Fixture
+
+```typescript
+import { createMultiProjectFixture } from '../fixtures';
+
+const fixture = createMultiProjectFixture(3); // 3 separate git repos
+
+// Creates project-0, project-1, project-2 under fixture.rootDir
+// Each is a git repo with README.md
+// groups.json has one group "Multi Project Group" with all 3 projects
+```
+
+### Fixture Environment Variables
+
+Pass `fixture.env` to the app to redirect all data/config paths:
+
+| Variable | Effect |
+|----------|--------|
+| `BTERMINAL_TEST=1` | Disables file watchers, wake scheduler, enables `is_test_mode` |
+| `BTERMINAL_TEST_DATA_DIR` | Redirects `sessions.db` and `btmsg.db` storage |
+| `BTERMINAL_TEST_CONFIG_DIR` | Redirects `groups.json` config loading |
+
+## Pillar 2: Test Mode
+
+When `BTERMINAL_TEST=1` is set:
+
+- **Rust backend**: `watcher.rs` and `fs_watcher.rs` skip file watchers
+- **Frontend**: `is_test_mode` Tauri command returns true, wake scheduler disabled via `disableWakeScheduler()`
+- **Data isolation**: `BTERMINAL_TEST_DATA_DIR` / `BTERMINAL_TEST_CONFIG_DIR` override default paths
+
+The WebDriverIO config (`wdio.conf.js`) passes these env vars via `tauri:options.env` in capabilities.
+
+## Pillar 3: LLM Judge (`llm-judge.ts`)
+
+The LLM judge enables semantic assertions — evaluating whether agent output "looks right" rather than exact string matching. Useful for testing AI agent responses where exact output is non-deterministic.
+
+### Dual Backend
+
+The judge supports two backends, auto-detected or explicitly set:
+
+| Backend | How it works | Requires |
+|---------|-------------|----------|
+| `cli` (default) | Spawns `claude` CLI with `--output-format text` | Claude CLI installed |
+| `api` | Raw `fetch` to `https://api.anthropic.com/v1/messages` | `ANTHROPIC_API_KEY` env var |
+
+**Auto-detection order**: CLI first → API fallback → skip test.
+
+**Override**: Set `LLM_JUDGE_BACKEND=cli` or `LLM_JUDGE_BACKEND=api`.
+
+### API
+
+```typescript
+import { isJudgeAvailable, judge, assertWithJudge } from '../llm-judge';
+
+// Check availability (CLI or API key present)
+if (!isJudgeAvailable()) {
+  this.skip(); // graceful skip in mocha
+  return;
+}
+
+// Basic judge call
+const verdict = await judge(
+  'The output should contain a file listing with at least one filename',  // criteria
+  actualOutput,                                                            // actual
+  'Agent was asked to list files in a directory containing README.md',     // context (optional)
+);
+// verdict: { pass: boolean, reasoning: string, confidence: number }
+
+// With confidence threshold (default 0.7)
+const verdict = await assertWithJudge(
+  'Response should describe the greet function',
+  agentMessages,
+  { context: 'hello.py contains def greet(name)', minConfidence: 0.8 },
+);
+```
+
+### How It Works
+
+1. Builds a structured prompt with criteria, actual output, and optional context
+2. Asks Claude (Haiku) to evaluate as a test assertion judge
+3. Expects JSON response: `{"pass": true/false, "reasoning": "...", "confidence": 0.0-1.0}`
+4. Validates and returns structured `JudgeVerdict`
+
+The CLI backend unsets `CLAUDECODE` env var to avoid nested session errors when running inside Claude Code.
+
+## Test Spec Files
+
+| File | Phase | Tests | Focus |
+|------|-------|-------|-------|
+| `bterminal.test.ts` | Smoke | ~50 | Basic UI rendering, CSS class selectors |
+| `agent-scenarios.test.ts` | A | 22 | `data-testid` selectors, 7 deterministic scenarios |
+| `phase-b.test.ts` | B | ~15 | Multi-project grid, LLM-judged agent responses |
+| `phase-c.test.ts` | C | 27 | Hardening features (palette, search, notifications, keyboard, settings, health, metrics, context, files) |
+
+### Phase A: Deterministic Agent Scenarios
+
+Uses `data-testid` attributes for reliable selectors. Tests app structure, project rendering, and agent pane states without live agent interaction.
+
+### Phase B: Multi-Project + LLM Judge
+
+Tests multi-project grid rendering, independent tab switching, status bar fleet state. LLM-judged tests (B4, B5) send real prompts to agents and evaluate response quality — these require Claude CLI or API key and are skipped otherwise.
+
+### Phase C: Production Hardening
+
+Tests v3 hardening features: command palette commands (C1), search overlay (C2), notification center (C3), keyboard navigation (C4), settings panel (C5), project health indicators (C6), metrics tab (C7), context tab (C8), files tab with editor (C9), LLM-judged settings (C10), LLM-judged status bar (C11).
+
+## Test Results Tracking (`results-db.ts`)
+
+A lightweight JSON store for tracking test runs and individual step results:
+
+```typescript
+import { ResultsDb } from '../results-db';
+
+const db = new ResultsDb(); // writes to v2/test-results/results.json
+
+db.startRun('run-001', 'v2-mission-control', 'abc123');
+db.recordStep({
+  run_id: 'run-001',
+  scenario_name: 'B4',
+  step_name: 'should send prompt and get meaningful response',
+  status: 'passed',
+  duration_ms: 15000,
+  error_message: null,
+  screenshot_path: null,
+  agent_cost_usd: 0.003,
+});
+db.finishRun('run-001', 'passed', 45000);
+```
+
+## CI Integration (`.github/workflows/e2e.yml`)
+
+The CI pipeline runs on push/PR with path-filtered triggers:
+
+1. **Unit tests** — `npm run test` (vitest)
+2. **Cargo tests** — `cargo test` (with `env -u BTERMINAL_TEST` to prevent env leakage)
+3. **E2E tests** — `xvfb-run npm run test:e2e` (virtual framebuffer for headless WebKit2GTK)
+
+LLM-judged tests are gated on the `ANTHROPIC_API_KEY` secret — they skip gracefully in forks or when the secret is absent.
+
+## Writing New Tests
+
+### Adding a New Scenario
+
+1. Pick the appropriate spec file (or create a new phase file)
+2. Use `data-testid` selectors where possible (more stable than CSS classes)
+3. For DOM queries, use `browser.execute()` to run JS in the app context
+4. For semantic assertions, use `assertWithJudge()` with clear criteria
+
+### Common Helpers
+
+All spec files share similar helper patterns:
+
+```typescript
+// Get project IDs
+const ids: string[] = await browser.execute(() => {
+  const boxes = document.querySelectorAll('[data-testid="project-box"]');
+  return Array.from(boxes).map(b => b.getAttribute('data-project-id') ?? '').filter(Boolean);
+});
+
+// Focus a project
+await browser.execute((id) => {
+  const box = document.querySelector(`[data-project-id="${id}"]`);
+  const header = box?.querySelector('.project-header');
+  if (header) (header as HTMLElement).click();
+}, projectId);
+
+// Switch tab in a project
+await browser.execute((id, idx) => {
+  const box = document.querySelector(`[data-project-id="${id}"]`);
+  const tabs = box?.querySelectorAll('[data-testid="project-tabs"] .ptab');
+  if (tabs && tabs[idx]) (tabs[idx] as HTMLElement).click();
+}, projectId, tabIndex);
+```
+
+### WebDriverIO Config (`wdio.conf.js`)
+
+Key settings:
+
+- **Single session**: `maxInstances: 1` — tauri-driver can't handle parallel sessions
+- **Lifecycle**: `onPrepare` builds debug binary, `beforeSession` spawns tauri-driver with TCP readiness probe, `afterSession` kills tauri-driver
+- **Timeouts**: 60s per test (mocha), 10s waitfor, 30s connection retry
+- **Skip build**: Set `SKIP_BUILD=1` to reuse existing binary
+
+## Troubleshooting
+
+| Problem | Solution |
+|---------|----------|
+| "Callback was not called before unload" | Stale binary — rebuild with `cargo tauri build --debug --no-bundle` |
+| Tests hang on startup | Kill stale `tauri-driver` processes: `pkill -f tauri-driver` |
+| All tests skip LLM judge | Install Claude CLI or set `ANTHROPIC_API_KEY` |
+| SIGUSR2 / exit code 144 | Stale tauri-driver on port 4444 — kill and retry |
+| `BTERMINAL_TEST` leaking to cargo | Run cargo tests with `env -u BTERMINAL_TEST cargo test` |
+| No display available | Use `xvfb-run` or ensure X11/Wayland display is set |
diff --git a/docs/findings.md b/docs/findings.md
index 613ca92..7a8eb0e 100644
--- a/docs/findings.md
+++ b/docs/findings.md
@@ -132,17 +132,17 @@ Zellij uses WASM plugins for extensibility:
 
 ## 6. Frontend Framework Choice
 
-### Why Solid.js
-- **Fine-grained reactivity** — updates only the DOM nodes that changed, not the component tree
+### Why Svelte 5 (revised from initial Solid.js choice)
+- **Fine-grained reactivity** — $state/$derived runes match Solid's signals model
 - **No VDOM** — critical when we have 4-8 panes each streaming data
-- **Small bundle** — ~7KB vs React's ~40KB
-- **JSX familiar** — easy for anyone who knows React
-- **Signals** — perfect for streaming agent state
+- **Small bundle** — ~5KB runtime vs React's ~40KB
+- **Larger ecosystem** — more component libraries, xterm.js wrappers, better tooling
+- **Better TypeScript support** — improved in Svelte 5
 
-### Alternative: Svelte
-- Also no VDOM, also reactive, slightly larger community
-- Slightly more ceremony for stores/state management
-- Would also work, personal preference
+### Why NOT Solid.js (initial choice, revised)
+- Ecosystem too small for production use
+- Fewer component libraries and integrations
+- Svelte 5 runes eliminated the ceremony gap
 
 ### NOT React
 - VDOM reconciliation across 4-8 simultaneously updating panes = CPU waste
diff --git a/docs/multi-machine.md b/docs/multi-machine.md
new file mode 100644
index 0000000..b1fb648
--- /dev/null
+++ b/docs/multi-machine.md
@@ -0,0 +1,323 @@
+# Multi-Machine Support — Architecture & Implementation
+
+**Status: Implemented (Phases A-D complete, 2026-03-06)**
+
+## Overview
+
+Extend BTerminal to manage Claude agent sessions and terminal panes running on **remote machines** over WebSocket, while keeping the local sidecar path unchanged.
+
+## Problem
+
+Current architecture is local-only:
+
+```
+WebView ←→ Rust (Tauri IPC) ←→ Local Sidecar (stdio NDJSON)
+                              ←→ Local PTY (portable-pty)
+```
+
+Target state: BTerminal acts as a **mission control** that observes agents and terminals running on multiple machines (dev servers, cloud VMs, CI runners).
+
+## Design Constraints
+
+1. **Zero changes to local path** — local sidecar/PTY must work identically
+2. **Same NDJSON protocol** — remote and local agents speak the same message format
+3. **No new runtime dependencies** — use Rust's `tokio-tungstenite` (already available via Tauri)
+4. **Graceful degradation** — remote machine goes offline → pane shows disconnected state, reconnects automatically
+5. **Security** — all remote connections authenticated and encrypted (TLS + token)
+
+## Architecture
+
+### Three-Layer Model
+
+```
+┌──────────────────────────────────────────────────────────────────┐
+│  BTerminal (Controller)                                          │
+│                                                                  │
+│  ┌──────────┐    Tauri IPC    ┌──────────────────────────────┐  │
+│  │ WebView  │ ←────────────→  │ Rust Backend                 │  │
+│  │ (Svelte) │                 │                              │  │
+│  └──────────┘                 │  ├── PtyManager (local)      │  │
+│                               │  ├── SidecarManager (local)  │  │
+│                               │  └── RemoteManager ──────────┼──┤
+│                               └──────────────────────────────┘  │
+│                                                                  │
+└──────────────────────────────────────────────────────────────────┘
+        │                                      │
+        │ (local stdio)                        │ (WebSocket wss://)
+        ▼                                      ▼
+  ┌───────────┐                    ┌──────────────────────┐
+  │ Local     │                    │ Remote Machine       │
+  │ Sidecar   │                    │                      │
+  │ (Deno/    │                    │  ┌────────────────┐  │
+  │  Node.js) │                    │  │ bterminal-relay│  │
+  │           │                    │  │ (Rust binary)  │  │
+  └───────────┘                    │  │                │  │
+                                   │  │ ├── PTY mgr   │  │
+                                   │  │ ├── Sidecar mgr│  │
+                                   │  │ └── WS server  │  │
+                                   │  └────────────────┘  │
+                                   └──────────────────────┘
+```
+
+### Components
+
+#### 1. `bterminal-relay` — Remote Agent (Rust binary)
+
+A standalone Rust binary that runs on each remote machine. It:
+
+- Listens on a WebSocket port (default: 9750)
+- Manages local PTYs and claude sidecar processes
+- Forwards NDJSON events to the controller over WebSocket
+- Receives commands (query, stop, resize, write) from the controller
+
+**Why a Rust binary?** Reuses existing `PtyManager` and `SidecarManager` code from `src-tauri/src/`. Extracted into a shared crate.
+
+```
+bterminal-relay/
+├── Cargo.toml        # depends on bterminal-core
+├── src/
+│   └── main.rs       # WebSocket server + auth
+│
+bterminal-core/       # shared crate (extracted from src-tauri)
+├── Cargo.toml
+├── src/
+│   ├── pty.rs        # PtyManager (from v2/src-tauri/src/pty.rs)
+│   ├── sidecar.rs    # SidecarManager (from v2/src-tauri/src/sidecar.rs)
+│   └── lib.rs
+```
+
+#### 2. `RemoteManager` — Controller-Side (in Rust backend)
+
+New module in `v2/src-tauri/src/remote.rs`. Manages WebSocket connections to multiple relays.
+
+```rust
+pub struct RemoteMachine {
+    pub id: String,
+    pub label: String,
+    pub url: String,          // wss://host:9750
+    pub token: String,        // auth token
+    pub status: RemoteStatus, // connected | connecting | disconnected | error
+}
+
+pub enum RemoteStatus {
+    Connected,
+    Connecting,
+    Disconnected,
+    Error(String),
+}
+
+pub struct RemoteManager {
+    machines: Arc<Mutex<Vec<RemoteMachine>>>,
+    connections: Arc<Mutex<HashMap<String, WsConnection>>>,
+}
+```
+
+#### 3. Frontend Adapters — Unified Interface
+
+The frontend doesn't care whether a pane is local or remote. The bridge layer abstracts this:
+
+```typescript
+// adapters/agent-bridge.ts — extended
+export async function queryAgent(options: AgentQueryOptions): Promise<void> {
+  if (options.remote_machine_id) {
+    return invoke('remote_agent_query', { machineId: options.remote_machine_id, options });
+  }
+  return invoke('agent_query', { options });
+}
+```
+
+Same pattern for `pty-bridge.ts` — add optional `remote_machine_id` to all operations.
+
+## Protocol
+
+### WebSocket Wire Format
+
+Same NDJSON as local sidecar, wrapped in an envelope for multiplexing:
+
+```typescript
+// Controller → Relay (commands)
+interface RelayCommand {
+  id: string;                      // request correlation ID
+  type: 'pty_create' | 'pty_write' | 'pty_resize' | 'pty_close'
+      | 'agent_query' | 'agent_stop' | 'sidecar_restart'
+      | 'ping';
+  payload: Record<string, unknown>;
+}
+
+// Relay → Controller (events)
+interface RelayEvent {
+  type: 'pty_data' | 'pty_exit' | 'pty_created'
+      | 'sidecar_message' | 'sidecar_exited'
+      | 'error' | 'pong' | 'ready';
+  sessionId?: string;
+  payload: unknown;
+}
+```
+
+### Authentication
+
+1. **Pre-shared token** — relay starts with `--token <secret>`. Controller sends token in WebSocket upgrade headers (`Authorization: Bearer <token>`).
+2. **TLS required** — relay rejects non-TLS connections in production mode. Dev mode allows `ws://` with `--insecure` flag.
+3. **Token rotation** — future: relay exposes endpoint to rotate token. Controller stores tokens in SQLite settings table.
+
+### Connection Lifecycle
+
+```
+Controller                          Relay
+    │                                 │
+    │── WSS connect ─────────────────→│
+    │── Authorization: Bearer token ──→│
+    │                                 │
+    │←── { type: "ready", ...} ───────│
+    │                                 │
+    │── { type: "ping" } ────────────→│
+    │←── { type: "pong" } ────────────│  (every 15s)
+    │                                 │
+    │── { type: "agent_query", ... }──→│
+    │←── { type: "sidecar_message" }──│  (streaming)
+    │←── { type: "sidecar_message" }──│
+    │                                 │
+    │     (disconnect)                │
+    │── reconnect (exp backoff) ─────→│  (1s, 2s, 4s, 8s, max 30s)
+```
+
+### Reconnection (Implemented)
+
+- Controller reconnects with exponential backoff (1s, 2s, 4s, 8s, 16s, 30s cap)
+- Reconnection runs as an async tokio task spawned on disconnect
+- Uses `attempt_tcp_probe()`: TCP connect only (no WS upgrade), 5s timeout, default port 9750. Avoids allocating per-connection resources (PtyManager, SidecarManager) on the relay during probes.
+- Emits `remote-machine-reconnecting` event (with backoff duration) and `remote-machine-reconnect-ready` when probe succeeds
+- Frontend listens via `onRemoteMachineReconnecting` and `onRemoteMachineReconnectReady` in remote-bridge.ts; machines store sets status to 'reconnecting' and auto-calls `connectMachine()` on ready
+- Cancels if machine is removed or manually reconnected (checks status == "disconnected" && connection == None)
+- On reconnect, relay sends current state snapshot (active sessions, PTY list)
+- Controller reconciles: updates pane states, re-subscribes to streams
+- Active agent sessions continue on relay regardless of controller connection
+
+## Session Persistence Across Reconnects
+
+Key insight: **remote agents keep running even when the controller disconnects**. The relay is autonomous — it doesn't need the controller to operate.
+
+On reconnect:
+1. Relay sends `{ type: "state_sync", activeSessions: [...], activePtys: [...] }`
+2. Controller matches against known panes, updates status
+3. Missed messages are NOT replayed (too complex, marginal value). Agent panes show "reconnected — some messages may be missing" notice
+
+## Frontend Integration
+
+### Pane Model Changes
+
+```typescript
+// stores/layout.svelte.ts
+export interface Pane {
+  id: string;
+  type: 'terminal' | 'agent';
+  title: string;
+  group?: string;
+  remoteMachineId?: string;  // NEW: undefined = local
+}
+```
+
+### Sidebar — Machine Groups
+
+Remote panes auto-group by machine label in the sidebar:
+
+```
+▾ Local
+  ├── Terminal 1
+  └── Agent: fix bug
+
+▾ devbox (192.168.1.50)      ← remote machine
+  ├── SSH session
+  └── Agent: deploy
+
+▾ ci-runner (10.0.0.5)       ← remote machine (disconnected)
+  └── Agent: test suite ⚠️
+```
+
+### Settings Panel
+
+New "Machines" section in settings:
+
+| Field | Type | Notes |
+|-------|------|-------|
+| Label | string | Human-readable name |
+| URL | string | `wss://host:9750` |
+| Token | password | Pre-shared auth token |
+| Auto-connect | boolean | Connect on app launch |
+
+Stored in SQLite `settings` table as JSON: `remote_machines` key.
+
+## Implementation (All Phases Complete)
+
+### Phase A: Extract `bterminal-core` crate [DONE]
+
+- Cargo workspace at v2/ level (v2/Cargo.toml with members: src-tauri, bterminal-core, bterminal-relay)
+- PtyManager and SidecarManager extracted to v2/bterminal-core/
+- EventSink trait (bterminal-core/src/event.rs) abstracts event emission
+- TauriEventSink (src-tauri/src/event_sink.rs) implements EventSink for AppHandle
+- src-tauri pty.rs and sidecar.rs are thin re-export wrappers
+
+### Phase B: Build `bterminal-relay` binary [DONE]
+
+- v2/bterminal-relay/src/main.rs — WebSocket server (tokio-tungstenite)
+- Token auth on WebSocket upgrade (Authorization: Bearer header)
+- CLI: --port (default 9750), --token (required), --insecure (allow ws://)
+- Routes RelayCommand to bterminal-core managers, forwards RelayEvent over WebSocket
+- Rate limiting: 10 failed auth attempts triggers 5-minute lockout
+- Per-connection isolated PtyManager + SidecarManager instances
+- Command response propagation: structured responses (pty_created, pong, error) sent back via shared event channel
+- send_error() helper: all command failures emit RelayEvent with commandId + error message
+- PTY creation confirmation: pty_create command returns pty_created event with session ID and commandId for correlation
+
+### Phase C: Add `RemoteManager` to controller [DONE]
+
+- v2/src-tauri/src/remote.rs — RemoteManager struct with WebSocket client connections
+- 12 Tauri commands: remote_add_machine, remote_remove_machine, remote_connect, remote_disconnect, remote_list_machines, remote_pty_spawn/write/resize/kill, remote_agent_query/stop, remote_sidecar_restart
+- Heartbeat ping every 15s
+- PTY creation event: emits `remote-pty-created` Tauri event with machineId, ptyId, commandId
+- Exponential backoff reconnection on disconnect (1s/2s/4s/8s/16s/30s cap) via `attempt_tcp_probe()` (TCP-only, no WS upgrade)
+- Reconnection events: `remote-machine-reconnecting`, `remote-machine-reconnect-ready`
+
+### Phase D: Frontend integration [DONE]
+
+- v2/src/lib/adapters/remote-bridge.ts — machine management IPC adapter
+- v2/src/lib/stores/machines.svelte.ts — remote machine state store
+- Pane.remoteMachineId field in layout store
+- agent-bridge.ts and pty-bridge.ts route to remote commands when remoteMachineId is set
+- SettingsDialog "Remote Machines" section
+- Sidebar auto-groups remote panes by machine label
+
+### Remaining Work
+
+- [x] Reconnection logic with exponential backoff (1s-30s cap) — implemented in remote.rs
+- [x] Relay command response propagation (pty_created, pong, error events) — implemented in main.rs
+- [ ] Real-world relay testing (2 machines)
+- [ ] TLS/certificate pinning
+
+## Security Considerations
+
+| Threat | Mitigation |
+|--------|-----------|
+| Token interception | TLS required (reject `ws://` without `--insecure`) |
+| Token brute-force | Rate limit auth attempts (5/min), lockout after 10 failures |
+| Relay impersonation | Pin relay certificate fingerprint (future: mTLS) |
+| Command injection | Relay validates all command payloads against schema |
+| Lateral movement | Relay runs as unprivileged user, no shell access beyond PTY/sidecar |
+| Data exfiltration | Agent output streams to controller only, no relay-to-relay traffic |
+
+## Performance Considerations
+
+| Concern | Mitigation |
+|---------|-----------|
+| WebSocket latency | Typical LAN: <1ms. WAN: 20-100ms. Acceptable for agent output (text, not video) |
+| Bandwidth | Agent NDJSON: ~50KB/s peak. Terminal: ~200KB/s peak. Trivial even on slow links |
+| Connection count | Max 10 machines initially (UI constraint, not technical) |
+| Message ordering | Single WebSocket per machine = ordered delivery guaranteed |
+
+## What This Does NOT Cover (Future)
+
+- **Multi-controller** — multiple BTerminal instances observing the same relay (needs pub/sub)
+- **Relay discovery** — automatic detection of relays on LAN (mDNS/Bonjour)
+- **Agent migration** — moving a running agent from one machine to another
+- **Relay-to-relay** — direct communication between remote machines
+- **mTLS** — mutual TLS for enterprise environments (Phase B+ enhancement)
diff --git a/docs/phases.md b/docs/phases.md
index 9acc73d..802f0a6 100644
--- a/docs/phases.md
+++ b/docs/phases.md
@@ -4,14 +4,14 @@ See [task_plan.md](task_plan.md) for architecture decisions, error handling, and
 
 ---
 
-## Phase 1: Project Scaffolding [status: not_started] — MVP
+## Phase 1: Project Scaffolding [status: complete] — MVP
 
-- [ ] Create feature branch `v2-mission-control`
-- [ ] Initialize Tauri 2.x project with Svelte 5 frontend
-- [ ] Project structure (see below)
-- [ ] Basic Tauri window with Catppuccin Mocha CSS variables
-- [ ] Verify Tauri builds and launches on target system
-- [ ] Set up dev scripts (dev, build, lint)
+- [x] Create feature branch `v2-mission-control`
+- [x] Initialize Tauri 2.x project with Svelte 5 frontend
+- [x] Project structure (see below)
+- [x] Basic Tauri window with Catppuccin Mocha CSS variables
+- [x] Verify Tauri builds and launches on target system
+- [x] Set up dev scripts (dev, build, lint)
 
 ### File Structure
 ```
@@ -20,42 +20,68 @@ bterminal-v2/
     src/
       main.rs              # Tauri app entry
       pty.rs               # PTY management (portable-pty, not plugin)
-      sidecar.rs           # Node.js sidecar lifecycle (spawn, restart, health)
+      sidecar.rs           # Sidecar lifecycle (unified .mjs bundle, Deno-first + Node.js fallback)
       watcher.rs           # File watcher for markdown viewer
-      session.rs           # Session persistence (SQLite via rusqlite)
+      session.rs           # Session + SSH session persistence (SQLite via rusqlite)
+      ctx.rs               # Read-only ctx context DB access
     Cargo.toml
   src/
-    App.svelte             # Root layout
+    App.svelte             # Root layout + detached pane mode
     lib/
       components/
         Layout/
           TilingGrid.svelte    # Dynamic tiling manager
           PaneContainer.svelte # Individual pane wrapper
-          PaneHeader.svelte    # Pane title bar with controls
         Terminal/
-          TerminalPane.svelte  # xterm.js terminal pane
+          TerminalPane.svelte  # xterm.js terminal pane (theme-aware)
         Agent/
           AgentPane.svelte     # SDK agent structured output
-          AgentTree.svelte     # Subagent tree visualization
-          ToolCallCard.svelte  # Individual tool call display
+          AgentTree.svelte     # Subagent tree visualization (SVG)
         Markdown/
-          MarkdownPane.svelte  # Live markdown file viewer
+          MarkdownPane.svelte  # Live markdown file viewer (shiki highlighting)
+        Context/
+          ContextPane.svelte   # ctx database viewer (projects, entries, search)
+        SSH/
+          SshDialog.svelte     # SSH session create/edit modal
+          SshSessionList.svelte # SSH session list in sidebar
         Sidebar/
-          SessionList.svelte   # Session browser
+          SessionList.svelte   # Session browser + SSH list
+        StatusBar/
+          StatusBar.svelte     # Global status bar (pane counts, cost)
+        Notifications/
+          ToastContainer.svelte # Toast notification display
+        Settings/
+          SettingsDialog.svelte # Settings modal (shell, cwd, max panes, theme)
       stores/
-        sessions.ts          # Session state ($state runes)
-        agents.ts            # Active agent tracking
-        layout.ts            # Pane layout state
+        sessions.svelte.ts   # Session state ($state runes)
+        agents.svelte.ts     # Active agent tracking
+        layout.svelte.ts     # Pane layout state
+        notifications.svelte.ts # Toast notification state
+        theme.svelte.ts      # Catppuccin theme flavor state
       adapters/
         sdk-messages.ts      # SDK message abstraction layer
         pty-bridge.ts        # PTY IPC wrapper
+        agent-bridge.ts      # Agent IPC wrapper (local + remote routing)
+        claude-bridge.ts     # Claude profiles + skills IPC wrapper
+        settings-bridge.ts   # Settings IPC wrapper
+        ctx-bridge.ts        # ctx database IPC wrapper
+        ssh-bridge.ts        # SSH session IPC wrapper
+        remote-bridge.ts     # Remote machine management IPC wrapper
+        session-bridge.ts    # Session/layout persistence IPC wrapper
+      utils/
+        agent-tree.ts        # Agent tree builder (hierarchy from messages)
+        highlight.ts         # Shiki syntax highlighter (lazy singleton)
+        detach.ts            # Detached pane mode (pop-out windows)
+        updater.ts           # Tauri auto-updater utility
       styles/
-        catppuccin.css       # Theme CSS variables
+        catppuccin.css       # Theme CSS variables (Mocha defaults)
+        themes.ts            # All 4 Catppuccin flavor definitions
     app.css
   sidecar/
-    agent-runner.ts          # Node.js sidecar entry point
+    agent-runner.ts          # Sidecar source (compiled to .mjs by esbuild)
+    dist/
+      agent-runner.mjs       # Bundled sidecar (runs on both Deno and Node.js)
     package.json             # Agent SDK dependency
-    esbuild.config.ts        # Bundle to single file
   package.json
   svelte.config.js
   vite.config.ts
@@ -66,7 +92,7 @@ bterminal-v2/
 
 ---
 
-## Phase 2: Terminal Pane + Layout [status: not_started] — MVP
+## Phase 2: Terminal Pane + Layout [status: complete] — MVP
 
 ### Layout (responsive)
 
@@ -86,92 +112,219 @@ bterminal-v2/
 +--------+-------------------------+
 ```
 
-- [ ] CSS Grid layout with sidebar + main area + optional right panel
-- [ ] Responsive breakpoints (ultrawide / standard / narrow)
-- [ ] Pane resize via drag handles (use CSS `resize` or lightweight lib)
-- [ ] Layout presets: 1-col, 2-col, 3-col, 2x2, master+stack
-- [ ] Save/restore layout to SQLite
-- [ ] Keyboard: Ctrl+1-4 focus pane, Ctrl+Shift+arrows move
+- [x] CSS Grid layout with sidebar + main area + optional right panel
+- [x] Responsive breakpoints (ultrawide / standard / narrow)
+- [x] Pane resize via drag handles (splitter overlays in TilingGrid with mouse drag, min/max 10%/90%)
+- [x] Layout presets: 1-col, 2-col, 3-col, 2x2, master+stack
+- [ ] Save/restore layout to SQLite (Phase 4)
+- [x] Keyboard: Ctrl+1-4 focus pane, Ctrl+N new terminal
 
 ### Terminal
-- [ ] xterm.js with Canvas addon (explicit — no WebGL dependency)
-- [ ] Catppuccin Mocha theme for xterm.js
-- [ ] PTY spawn from Rust (portable-pty), stream to frontend via Tauri events
-- [ ] Terminal resize -> PTY resize
-- [ ] Copy/paste (Ctrl+Shift+C/V)
-- [ ] SSH session: spawn `ssh` command in PTY
-- [ ] Local shell: spawn user's $SHELL
-- [ ] Claude Code CLI: spawn `claude` in PTY (fallback mode)
+- [x] xterm.js with Canvas addon (explicit — no WebGL dependency)
+- [x] Catppuccin Mocha theme for xterm.js
+- [x] PTY spawn from Rust (portable-pty), stream to frontend via Tauri events
+- [x] Terminal resize -> PTY resize (100ms debounce)
+- [x] Copy/paste (Ctrl+Shift+C/V) — via attachCustomKeyEventHandler
+- [x] SSH session: spawn `ssh` command in PTY (via shell args)
+- [x] Local shell: spawn user's $SHELL
+- [x] Claude Code CLI: spawn `claude` in PTY (via shell args)
 
 **Milestone: After Phase 2, we have a working multi-pane terminal.** Usable as a daily driver even without agent features.
 
 ---
 
-## Phase 3: Agent SDK Integration [status: not_started] — MVP
+## Phase 3: Agent SDK Integration [status: complete] — MVP
 
-- [ ] Node.js sidecar: thin wrapper around Agent SDK `query()`
-- [ ] Sidecar communication: Rust spawns Node.js, stdio NDJSON
-- [ ] Sidecar lifecycle: spawn on demand, detect crash, restart
-- [ ] SDK message adapter (abstraction layer)
-- [ ] Agent pane: renders structured messages
-  - Text -> markdown rendered
-  - Tool calls -> collapsible cards (tool name + input + output)
-  - Subagent spawn -> tree node + optional new pane
-  - Errors -> highlighted error card
-  - Cost/tokens -> pane header metrics
-- [ ] Auto-scroll with scroll-lock on user scroll-up
-- [ ] Agent status indicator (running/thinking/waiting/done/error)
-- [ ] Start/stop/cancel agent from UI
-- [ ] Session resume (SDK `resume: sessionId`)
+### Backend
+- [x] Node.js/Deno sidecar: uses `@anthropic-ai/claude-agent-sdk` query() function (migrated from raw CLI spawning due to piped stdio hang bug #6775)
+- [x] Sidecar communication: Rust spawns Node.js, stdio NDJSON
+- [x] Sidecar lifecycle: auto-start on app launch, shutdown on exit
+- [x] Sidecar lifecycle: detect crash, offer restart in UI (agent_restart command + restart button)
+- [x] Tauri commands: agent_query, agent_stop, agent_ready, agent_restart
+
+### Frontend
+- [x] SDK message adapter: parses stream-json into 9 typed AgentMessage types (abstraction layer)
+- [x] Agent bridge: Tauri IPC adapter (invoke + event listeners)
+- [x] Agent dispatcher: singleton routing sidecar events to store, crash detection
+- [x] Agent store: session state, message history, cost tracking (Svelte 5 $state)
+- [x] Agent pane: renders structured messages
+  - [x] Text -> plain text (markdown rendering deferred)
+  - [x] Tool calls -> collapsible cards (tool name + input)
+  - [x] Tool results -> collapsible cards
+  - [x] Thinking -> collapsible details
+  - [x] Init -> model badge
+  - [x] Cost -> USD/tokens/turns/duration summary
+  - [x] Errors -> highlighted error card
+  - [x] Subagent spawn -> auto-creates child agent pane with parent/child navigation (Phase 7)
+- [x] Agent status indicator (starting/running/done/error)
+- [x] Start/stop agent from UI (prompt form + stop button)
+- [x] Auto-scroll with scroll-lock on user scroll-up
+- [x] Session resume (follow-up prompt in AgentPane, resume_session_id passed to SDK)
+- [x] Keyboard: Ctrl+Shift+N new agent
+- [x] Sidebar: agent session button
 
 **Milestone: After Phase 3, we have the core differentiator.** SDK agents run in structured panes alongside raw terminals.
 
 ---
 
-## Phase 4: Session Management + Markdown Viewer [status: not_started] — MVP
+## Phase 4: Session Management + Markdown Viewer [status: complete] — MVP
 
 ### Sessions
-- [ ] SQLite persistence for sessions (rusqlite)
-- [ ] Session types: SSH, Claude CLI, Agent SDK, Local Shell
-- [ ] Session CRUD in sidebar
-- [ ] Session groups/folders
-- [ ] Remember last layout on restart
+- [x] SQLite persistence for sessions (rusqlite with bundled feature)
+- [x] Session types: terminal, agent, markdown (SSH via terminal args)
+- [x] Session CRUD: save, delete, update_title, touch (last_used_at)
+- [x] Session groups/folders — group_name column, setPaneGroup, grouped sidebar with collapsible headers
+- [x] Remember last layout on restart (preset + pane_ids in layout_state table)
+- [x] Auto-restore panes on app startup (restoreFromDb in layout store)
 
 ### Markdown Viewer
-- [ ] File watcher (notify crate) -> Tauri events -> frontend
-- [ ] Markdown rendering (marked.js or remark)
-- [ ] Syntax highlighting (Shiki)
-- [ ] Open from sidebar or from agent output file references
-- [ ] Debounce file watcher (200ms)
+- [x] File watcher (notify crate v6) -> Tauri events -> frontend
+- [x] Markdown rendering (marked.js)
+- [x] Syntax highlighting (Shiki) — added in Phase 5 (highlight.ts, 13 preloaded languages)
+- [x] Open from sidebar (file picker button "M")
+- [x] Catppuccin-themed markdown styles (h1-h3, code, pre, tables, blockquotes)
+- [x] Live reload on file change
 
 **Milestone: After Phase 4 = MVP ship.** Full session management, structured agent panes, terminal panes, markdown viewer.
 
 ---
 
-## Phase 5: Agent Tree + Polish [status: not_started] — Post-MVP
+## Phase 5: Agent Tree + Polish [status: complete] — Post-MVP
 
-- [ ] Agent tree visualization (SVG, compact horizontal layout)
-- [ ] Click tree node -> focus agent pane
-- [ ] Aggregate cost per subtree
-- [ ] Global status bar (total cost, active agents, uptime)
-- [ ] Notification system (agent done, error)
-- [ ] Global keyboard shortcuts
-- [ ] Settings dialog
-- [ ] ctx integration (port from v1)
+- [x] Agent tree visualization (SVG, compact horizontal layout) — AgentTree.svelte + agent-tree.ts utility
+- [x] Click tree node -> scroll to message (handleTreeNodeClick in AgentPane, scrollIntoView smooth)
+- [x] Aggregate cost per subtree (subtreeCost displayed in yellow below each tree node label)
+- [x] Terminal copy/paste (Ctrl+Shift+C/V via attachCustomKeyEventHandler)
+- [x] Terminal theme hot-swap (onThemeChange callback registry in theme.svelte.ts, TerminalPane subscribes)
+- [x] Pane drag-resize handles (splitter overlays in TilingGrid with mouse drag)
+- [x] Session resume (follow-up prompt, resume_session_id to SDK)
+- [x] Global status bar (terminal/agent counts, active agents pulse, token/cost totals) — StatusBar.svelte
+- [x] Notification system (toast: success/error/warning/info, auto-dismiss 4s, max 5) — notifications.svelte.ts + ToastContainer.svelte
+- [x] Agent dispatcher toast integration (agent complete, error, sidecar crash notifications)
+- [x] Global keyboard shortcuts — Ctrl+W close focused pane, Ctrl+, open settings
+- [x] Settings dialog (default shell, cwd, max panes, theme flavor) — SettingsDialog.svelte + settings-bridge.ts
+- [x] Settings backend — settings table in SQLite (session.rs), Tauri commands settings_get/set/list (lib.rs)
+- [x] ctx integration — read-only access to ~/.claude-context/context.db (ctx.rs, ctx-bridge.ts, ContextPane.svelte)
+- [x] SSH session management — CRUD in SQLite (SshSession struct, SshDialog.svelte, SshSessionList.svelte, ssh-bridge.ts)
+- [x] Catppuccin theme flavors — Latte/Frappe/Macchiato/Mocha selectable (themes.ts, theme.svelte.ts)
+- [x] Detached pane mode — pop-out terminal/agent into standalone windows (detach.ts, App.svelte)
+- [x] Syntax highlighting — Shiki integration for markdown + agent messages (highlight.ts, shiki dep)
 
 ---
 
-## Phase 6: Packaging + Distribution [status: not_started] — Post-MVP
+## Phase 6: Packaging + Distribution [status: complete] — Post-MVP
 
-- [ ] install.sh v2 (check Node.js, install Tauri runtime deps)
-- [ ] AppImage build (single file, works everywhere)
-- [ ] .deb package (Debian/Ubuntu)
-- [ ] GitHub Actions CI for building releases
-- [ ] Auto-update mechanism (Tauri updater)
-- [ ] Migrate bterminal.svg icon
-- [ ] README update
+- [x] install-v2.sh — build-from-source installer with dependency checks (Node.js 20+, Rust 1.77+, system libs)
+  - Checks: WebKit2GTK, GTK3, GLib, libayatana-appindicator, librsvg, openssl, build-essential, pkg-config, curl, wget, FUSE
+  - Prompts to install missing packages via apt
+  - Builds with `npx tauri build`, installs binary as `bterminal-v2` in `~/.local/bin/`
+  - Creates desktop entry and installs SVG icon
+- [x] Tauri bundle configuration — targets: `["deb", "appimage"]`, category: DeveloperTool
+  - .deb depends: libwebkit2gtk-4.1-0, libgtk-3-0, libayatana-appindicator3-1
+  - AppImage: bundleMediaFramework disabled
+- [x] Icons regenerated from bterminal.svg — RGBA PNGs (32x32, 128x128, 128x128@2x, 512x512, .ico)
+- [x] GitHub Actions release workflow (`.github/workflows/release.yml`)
+  - Triggered on `v*` tags, Ubuntu 22.04 runner
+  - Caches Rust and npm dependencies
+  - Builds .deb + AppImage, uploads as GitHub Release artifacts
+- [x] Build verified: .deb (4.3 MB), AppImage (103 MB)
+- [x] Auto-updater plugin integrated (tauri-plugin-updater Rust + @tauri-apps/plugin-updater npm + updater.ts)
+- [x] Auto-update latest.json generation in CI (version, platform URL, signature from .sig file)
+- [x] release.yml: TAURI_SIGNING_PRIVATE_KEY env vars passed to build step
+- [x] Auto-update signing key generated, pubkey set in tauri.conf.json
+- [x] TAURI_SIGNING_PRIVATE_KEY secret set in GitHub repo settings via `gh secret set`
+
+---
+
+## Phase 7: Agent Teams / Subagent Support [status: complete] — Post-MVP
+
+- [x] Agent store parent/child hierarchy — parentSessionId, parentToolUseId, childSessionIds fields on AgentSession
+- [x] Agent store functions — findChildByToolUseId(), getChildSessions(), parent-aware createAgentSession()
+- [x] Agent dispatcher subagent detection — SUBAGENT_TOOL_NAMES Set ('Agent', 'Task', 'dispatch_agent')
+- [x] Agent dispatcher message routing — parentId-bearing messages routed to child panes via toolUseToChildPane Map
+- [x] Agent dispatcher pane spawning — spawnSubagentPane() creates child session + layout pane, auto-grouped under parent
+- [x] AgentPane parent navigation — SUB badge + button to focus parent agent
+- [x] AgentPane children bar — clickable chips per child subagent with status colors (running/done/error)
+- [x] SessionList subagent icon — '↳' for subagent panes
+- [x] Subagent cost aggregation — getTotalCost() recursive helper in agents.svelte.ts, total cost shown in parent pane done-bar
+- [x] Dispatcher tests for subagent routing — 10 tests covering spawn, dedup, child message routing, init/cost forwarding, fallbacks (28 total dispatcher tests)
+- [ ] Test with CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1
 
 ### System Requirements
 - Node.js 20+ (for Agent SDK sidecar)
+- Rust 1.77+ (for building from source)
 - WebKit2GTK 4.1+ (Tauri runtime)
 - Linux x86_64 (primary target)
+
+---
+
+## Multi-Machine Support (Phases A-D) [status: complete]
+
+Architecture designed in [multi-machine.md](multi-machine.md). Implementation extends BTerminal to manage agents and terminals on remote machines over WebSocket.
+
+### Phase A: Extract `bterminal-core` crate [status: complete]
+- [x] Created Cargo workspace at v2/ level (v2/Cargo.toml with members)
+- [x] Extracted PtyManager and SidecarManager into shared `bterminal-core` crate
+- [x] Created EventSink trait to abstract Tauri event emission (bterminal-core/src/event.rs)
+- [x] TauriEventSink in src-tauri/src/event_sink.rs implements EventSink
+- [x] src-tauri pty.rs and sidecar.rs now thin re-exports from bterminal-core
+
+### Phase B: Build `bterminal-relay` binary [status: complete]
+- [x] WebSocket server using tokio-tungstenite with token auth
+- [x] CLI flags: --port, --token, --insecure (clap)
+- [x] Routes RelayCommand to PtyManager/SidecarManager, forwards RelayEvent over WebSocket
+- [x] Rate limiting on auth failures (10 attempts, 5min lockout)
+- [x] Per-connection isolated PTY + sidecar managers
+- [x] Command response propagation: structured responses (pty_created, pong, error) via shared event channel
+- [x] send_error() helper for consistent error reporting with commandId correlation
+- [x] PTY creation confirmation: pty_created event with session ID and commandId
+
+### Phase C: Add `RemoteManager` to controller [status: complete]
+- [x] New remote.rs module in src-tauri — WebSocket client connections to relay instances
+- [x] Machine lifecycle: add/remove/connect/disconnect
+- [x] 12 new Tauri commands for remote operations
+- [x] Heartbeat ping every 15s
+- [x] PTY creation event: emits remote-pty-created Tauri event with machineId, ptyId, commandId
+- [x] Exponential backoff reconnection on disconnect (1s/2s/4s/8s/16s/30s cap)
+- [x] attempt_tcp_probe() function: TCP-only probe (5s timeout, default port 9750) — avoids allocating per-connection resources on relay during probes
+- [x] Reconnection events: remote-machine-reconnecting, remote-machine-reconnect-ready
+
+### Phase D: Frontend integration [status: complete]
+- [x] remote-bridge.ts adapter for machine management + remote events
+- [x] machines.svelte.ts store for remote machine state
+- [x] Layout store: Pane.remoteMachineId field
+- [x] agent-bridge.ts and pty-bridge.ts route to remote commands when remoteMachineId is set
+- [x] SettingsDialog "Remote Machines" section (add/remove/connect/disconnect)
+- [x] Sidebar auto-groups remote panes by machine label
+
+### Remaining Work
+- [x] Reconnection logic with exponential backoff — implemented in remote.rs
+- [x] Relay command response propagation — implemented in bterminal-relay main.rs
+- [ ] Real-world relay testing (2 machines)
+- [ ] TLS/certificate pinning
+
+---
+
+## Extras: Claude Profiles & Skill Discovery [status: complete]
+
+### Claude Profile / Account Switching
+- [x] Tauri command claude_list_profiles(): reads ~/.config/switcher/profiles/ directories
+- [x] Profile metadata from profile.toml (email, subscription_type, display_name)
+- [x] Config dir resolution: ~/.config/switcher-claude/{name}/ or fallback ~/.claude/
+- [x] Default profile fallback when no switcher profiles exist
+- [x] Profile selector dropdown in AgentPane toolbar (shown when >1 profile)
+- [x] Selected profile's config_dir passed as claude_config_dir -> CLAUDE_CONFIG_DIR env override
+
+### Skill Discovery & Autocomplete
+- [x] Tauri command claude_list_skills(): reads ~/.claude/skills/ (dirs with SKILL.md or .md files)
+- [x] Tauri command claude_read_skill(path): reads skill file content
+- [x] Frontend adapter: claude-bridge.ts (ClaudeProfile, ClaudeSkill interfaces, listProfiles/listSkills/readSkill)
+- [x] Skill autocomplete in AgentPane: `/` prefix triggers menu, arrow keys navigate, Tab/Enter select
+- [x] expandSkillPrompt(): reads skill content, injects as prompt with optional user args
+
+### Extended AgentQueryOptions
+- [x] Rust struct (bterminal-core/src/sidecar.rs): setting_sources, system_prompt, model, claude_config_dir, additional_directories
+- [x] Sidecar JSON passthrough (both agent-runner.ts and agent-runner-deno.ts)
+- [x] SDK query() options: settingSources defaults to ['user', 'project'], systemPrompt, model, additionalDirectories
+- [x] CLAUDE_CONFIG_DIR env injection for multi-account support
+- [x] Frontend AgentQueryOptions interface (agent-bridge.ts) updated with new fields
diff --git a/docs/progress-archive.md b/docs/progress-archive.md
new file mode 100644
index 0000000..a2532ab
--- /dev/null
+++ b/docs/progress-archive.md
@@ -0,0 +1,273 @@
+# BTerminal v2 — Progress Log (Archive: 2026-03-05 to 2026-03-06 early)
+
+> Archived from [progress.md](progress.md). Covers research, Phases 1-6, polish, testing, agent teams, and subagent support.
+
+## Session: 2026-03-05
+
+### Research Phase (complete)
+- [x] Analyzed current BTerminal v1 codebase (2092 lines Python, GTK3+VTE)
+- [x] Queried Memora — no existing BTerminal memories
+- [x] Researched Claude Agent SDK — found structured streaming, subagent tracking, hooks
+- [x] Researched Tauri + xterm.js ecosystem — found 4+ working projects
+- [x] Researched terminal latency benchmarks — xterm.js acceptable for AI output
+- [x] Researched 32:9 ultrawide layout patterns
+- [x] Evaluated GTK4 vs Tauri vs pure Rust — Tauri wins for this use case
+- [x] Created task_plan.md with 8 phases
+- [x] Created findings.md with 7 research areas
+
+### Technology Decision (complete)
+- Decision: **Tauri 2.x + Solid.js + Claude Agent SDK + xterm.js**
+- Rationale documented in task_plan.md Phase 0
+
+### Adversarial Review (complete)
+- [x] Spawned devil's advocate agent to attack the plan
+- [x] Identified 5 fatal/critical issues:
+  1. Node.js sidecar requirement unacknowledged
+  2. SDK 0.2.x instability — need abstraction layer
+  3. Three-tier observation overengineered — simplified to two-tier
+  4. Solid.js ecosystem too small — switched to Svelte 5
+  5. Missing: packaging, error handling, testing, responsive design
+- [x] Revised plan (Rev 2) incorporating all corrections
+- [x] Added error handling strategy table
+- [x] Added testing strategy table
+- [x] Defined MVP boundary (Phases 1-4)
+- [x] Added responsive layout requirement (1920px degraded mode)
+
+### Phase 1 Scaffolding (complete)
+- [x] Created feature branch `v2-mission-control`
+- [x] Initialized Tauri 2.x + Svelte 5 project in `v2/` directory
+- [x] Rust backend stubs: main.rs, lib.rs, pty.rs, sidecar.rs, watcher.rs, session.rs
+- [x] Svelte frontend: App.svelte with Catppuccin Mocha CSS variables, component stubs
+- [x] Node.js sidecar scaffold: agent-runner.ts with NDJSON communication pattern
+- [x] Tauri builds and launches (cargo build --release verified)
+- [x] Dev scripts: npm run dev, npm run build, npm run tauri dev/build
+- [x] 17 operational rules added to `.claude/rules/`
+- [x] Project meta files: CLAUDE.md, .claude/CLAUDE.md, TODO.md, CHANGELOG.md
+- [x] Documentation structure: docs/README.md, task_plan.md, phases.md, findings.md, progress.md
+
+### Phase 2: Terminal Pane + Layout (complete)
+- [x] Rust PTY backend with portable-pty (PtyManager: spawn, write, resize, kill)
+- [x] PTY reader thread emitting Tauri events (pty-data-{id}, pty-exit-{id})
+- [x] Tauri commands: pty_spawn, pty_write, pty_resize, pty_kill
+- [x] xterm.js terminal pane with Canvas addon (explicit, no WebGL)
+- [x] Catppuccin Mocha theme for xterm.js (16 ANSI colors)
+- [x] FitAddon with ResizeObserver + 100ms debounce
+- [x] PTY bridge adapter (spawnPty, writePty, resizePty, killPty, onPtyData, onPtyExit)
+- [x] CSS Grid tiling layout with 5 presets (1-col, 2-col, 3-col, 2x2, master-stack)
+- [x] Layout store with Svelte 5 $state runes and auto-preset selection
+- [x] Sidebar with session list, layout preset selector, new terminal button
+- [x] Keyboard shortcuts: Ctrl+N new terminal, Ctrl+1-4 focus pane
+- [x] PaneContainer with header bar (title, status, close)
+- [x] Empty state welcome screen with Ctrl+N hint
+- [x] npm dependencies: @xterm/xterm, @xterm/addon-canvas, @xterm/addon-fit
+- [x] Cargo dependencies: portable-pty, uuid
+
+### Phase 3: Agent SDK Integration (complete)
+- [x] Rust SidecarManager: spawn Node.js, stdio NDJSON, query/stop/shutdown (sidecar.rs, 218 lines)
+- [x] Node.js agent-runner: spawns `claude -p --output-format stream-json`, manages sessions (agent-runner.ts, 176 lines)
+- [x] Tauri commands: agent_query, agent_stop, agent_ready in lib.rs
+- [x] Sidecar auto-start on app launch
+- [x] SDK message adapter: full stream-json parser with 9 typed message types (sdk-messages.ts, 234 lines)
+- [x] Agent bridge: Tauri IPC adapter for sidecar communication (agent-bridge.ts, 53 lines)
+- [x] Agent dispatcher: routes sidecar events to agent store (agent-dispatcher.ts, 87 lines)
+- [x] Agent store: session state with messages, cost tracking (agents.svelte.ts, 91 lines)
+- [x] AgentPane component: prompt input, message rendering, stop button, cost display (AgentPane.svelte, 420 lines)
+- [x] UI integration: Ctrl+Shift+N for new agent, sidebar agent button, TilingGrid routing
+
+Architecture decision: Initially used `claude` CLI with `--output-format stream-json`. Migrated to `@anthropic-ai/claude-agent-sdk` query() due to CLI piped stdio hang bug (#6775). SDK outputs same message format, so adapter unchanged.
+
+### Bug Fix: Svelte 5 Rune File Extensions (2026-03-06)
+- [x] Diagnosed blank screen / "rune_outside_svelte" runtime error
+- [x] Root cause: store files used `.ts` extension but contain Svelte 5 `$state`/`$derived` runes, which only work in `.svelte` and `.svelte.ts` files
+- [x] Renamed: `layout.ts` -> `layout.svelte.ts`, `agents.ts` -> `agents.svelte.ts`, `sessions.ts` -> `sessions.svelte.ts`
+- [x] Updated all import paths in 5 files to use `.svelte` suffix (e.g., `from './stores/layout.svelte'`)
+
+### Phase 3 Polish (2026-03-06)
+- [x] Sidecar crash detection: dispatcher listens for sidecar-exited event, marks running sessions as error
+- [x] Restart UI: "Restart Sidecar" button in AgentPane error bar, calls agent_restart command
+- [x] Auto-scroll lock: scroll handler disables auto-scroll when user scrolls >50px from bottom, "Scroll to bottom" button appears
+
+### Phase 4: Session Management + Markdown Viewer (2026-03-06)
+- [x] rusqlite 0.31 (bundled) + dirs 5 + notify 6 added to Cargo.toml
+- [x] SessionDb: SQLite with WAL mode, sessions table + layout_state singleton
+- [x] Session CRUD: list, save, delete, update_title, touch (7 Tauri commands)
+- [x] Frontend session-bridge.ts: typed invoke wrappers for all session/layout commands
+- [x] Layout store wired to persistence: addPane/removePane/focusPane/setPreset all persist
+- [x] restoreFromDb() on app startup restores panes in layout order
+- [x] FileWatcherManager: notify crate watches files, emits Tauri "file-changed" events
+- [x] MarkdownPane component: marked.js rendering, Catppuccin-themed styles, live reload
+- [x] Sidebar "M" button opens file picker for .md/.markdown/.txt files
+- [x] TilingGrid routes markdown pane type to MarkdownPane component
+
+### Phase 5: Agent Tree + Polish (2026-03-06, complete)
+- [x] Agent tree visualization (SVG): AgentTree.svelte component with horizontal tree layout, bezier edges, status-colored nodes; agent-tree.ts utility (buildAgentTree, countTreeNodes, subtreeCost)
+- [x] Agent tree toggle in AgentPane: collapsible tree view shown when tool_call messages exist
+- [x] Global status bar: StatusBar.svelte showing terminal/agent pane counts, active agents with pulse animation, total tokens and cost
+- [x] Notification system: notifications.svelte.ts store (notify, dismissNotification, max 5 toasts, 4s auto-dismiss) + ToastContainer.svelte (slide-in animation, color-coded by type)
+- [x] Agent dispatcher notifications: toast on agent_stopped (success), agent_error (error), sidecar crash (error), cost result (success with cost/turns)
+- [x] Settings dialog: SettingsDialog.svelte modal (default shell, cwd, max panes, theme flavor) with settings-bridge.ts adapter
+- [x] Settings backend: settings table (key/value) in session.rs, Tauri commands settings_get/set/list in lib.rs
+- [x] Keyboard shortcuts: Ctrl+W close focused pane, Ctrl+, open settings dialog
+- [x] CSS grid update: app.css grid-template-rows '1fr' -> '1fr auto' for status bar row
+- [x] App.svelte: integrated StatusBar, ToastContainer, SettingsDialog components
+
+### Phase 6: Packaging + Distribution (2026-03-06)
+- [x] Created install-v2.sh — build-from-source installer with 6-step dependency check process
+- [x] Updated v2/src-tauri/tauri.conf.json: bundle targets ["deb", "appimage"]
+- [x] Regenerated all icons in v2/src-tauri/icons/ from bterminal.svg as RGBA PNGs
+- [x] Created .github/workflows/release.yml — CI workflow triggered on v* tags
+- [x] Build verified: .deb (4.3 MB), AppImage (103 MB) both built successfully
+
+### Phase 5 continued: SSH, ctx, themes, detached mode, auto-updater (2026-03-06)
+- [x] ctx integration: Rust ctx.rs, 5 Tauri commands, ctx-bridge.ts adapter, ContextPane.svelte
+- [x] SSH session management: SshSession struct, ssh-bridge.ts, SshDialog.svelte, SshSessionList.svelte
+- [x] Catppuccin theme flavors: Latte/Frappe/Macchiato/Mocha selectable
+- [x] Detached pane mode: pop-out windows via URL params
+- [x] Syntax highlighting: Shiki lazy singleton (13 languages)
+- [x] Tauri auto-updater plugin integrated
+- [x] AgentPane markdown rendering with Shiki highlighting
+
+### Session: 2026-03-06 (continued) — Polish, Testing, Extras
+
+#### Terminal Copy/Paste + Theme Hot-Swap
+- [x] Copy/paste in TerminalPane via Ctrl+Shift+C/V
+- [x] Theme hot-swap: onThemeChange() callback registry
+
+#### Agent Tree Enhancements
+- [x] Click tree node -> scroll to message, subtree cost display
+
+#### Session Resume
+- [x] Follow-up prompt input, resume_session_id passed to SDK
+
+#### Pane Drag-Resize Handles
+- [x] Splitter overlays in TilingGrid with mouse drag (min 10% / max 90%)
+
+#### Auto-Update Workflow Enhancement
+- [x] release.yml: signing key env vars, latest.json generation
+
+#### Deno Sidecar Evaluation
+- [x] Created agent-runner-deno.ts proof-of-concept
+
+#### Testing Infrastructure
+- [x] Vitest + Cargo tests: 104 vitest + 29 cargo tests, all passing
+
+### Session: 2026-03-06 (continued) — Session Groups, Auto-Update Key, Deno Sidecar, Tests
+
+#### Auto-Update Signing Key
+- [x] Generated Tauri signing keypair (minisign), set pubkey in tauri.conf.json
+
+#### Session Groups/Folders
+- [x] group_name column, setPaneGroup, grouped sidebar with collapsible headers
+
+#### Deno Sidecar Integration (upgraded from PoC)
+- [x] SidecarCommand struct, Deno-first resolution, Node.js fallback
+
+#### E2E/Integration Tests
+- [x] layout.test.ts (30), agent-bridge.test.ts (11), agent-dispatcher.test.ts (18), sdk-messages.test.ts (25)
+- [x] Total: 104 vitest tests + 29 cargo tests
+
+### Session: 2026-03-06 (continued) — Agent Teams / Subagent Support
+
+#### Agent Teams Frontend Support
+- [x] Parent/child hierarchy in agent store, subagent detection in dispatcher
+- [x] spawnSubagentPane(), toolUseToChildPane routing, parent/child navigation in AgentPane
+- [x] 10 new dispatcher tests for subagent routing (28 total, 114 vitest overall)
+
+#### Subagent Cost Aggregation
+- [x] getTotalCost() recursive helper, total cost shown in parent pane
+
+#### TAURI_SIGNING_PRIVATE_KEY
+- [x] Set via `gh secret set` on DexterFromLab/BTerminal GitHub repo
+
+### Session: 2026-03-06 (continued) — Multi-Machine Architecture Design
+
+#### Multi-Machine Support Architecture
+- [x] Designed full multi-machine architecture in docs/multi-machine.md (303 lines)
+- [x] Three-layer model: BTerminal (controller) + bterminal-relay (remote binary) + unified frontend
+- [x] WebSocket NDJSON protocol: RelayCommand/RelayEvent envelope wrapping existing sidecar format
+- [x] Authentication: pre-shared token + TLS, rate limiting, lockout
+- [x] Autonomous relay model: agents keep running when controller disconnects
+- [x] Reconnection with exponential backoff (1s-30s), state_sync on reconnect
+- [x] 4-phase implementation plan: A (extract bterminal-core crate), B (relay binary), C (RemoteManager), D (frontend)
+- [x] Updated TODO.md and docs/task_plan.md to reference the design
+
+### Session: 2026-03-06 (continued) — Multi-Machine Implementation (Phases A-D)
+
+#### Phase A: bterminal-core crate extraction
+- [x] Created Cargo workspace at v2/ level (v2/Cargo.toml, workspace members: src-tauri, bterminal-core, bterminal-relay)
+- [x] Extracted PtyManager into v2/bterminal-core/src/pty.rs
+- [x] Extracted SidecarManager into v2/bterminal-core/src/sidecar.rs
+- [x] Created EventSink trait (v2/bterminal-core/src/event.rs) to abstract event emission
+- [x] TauriEventSink (v2/src-tauri/src/event_sink.rs) implements EventSink for Tauri AppHandle
+- [x] src-tauri/src/pty.rs and sidecar.rs now thin re-export wrappers
+- [x] Cargo.lock moved from src-tauri/ to workspace root (v2/)
+
+#### Phase B: bterminal-relay binary
+- [x] New Rust binary at v2/bterminal-relay/ with WebSocket server (tokio-tungstenite)
+- [x] Token auth via Authorization: Bearer header on WebSocket upgrade
+- [x] CLI flags: --port (default 9750), --token (required), --insecure (allow ws://)
+- [x] Routes RelayCommand types (pty_create/write/resize/close, agent_query/stop, sidecar_restart, ping)
+- [x] Forwards RelayEvent types (pty_data/exit, sidecar_message/exited, error, pong, ready)
+- [x] Rate limiting: 10 failed auth attempts triggers 5-minute lockout
+- [x] Per-connection isolated PtyManager + SidecarManager instances
+
+#### Phase C: RemoteManager in controller
+- [x] New v2/src-tauri/src/remote.rs module — RemoteManager struct
+- [x] WebSocket client connections to relay instances (tokio-tungstenite)
+- [x] RemoteMachine struct: id, label, url, token, status (Connected/Connecting/Disconnected/Error)
+- [x] Machine lifecycle: add_machine, remove_machine, connect, disconnect
+- [x] 12 new Tauri commands: remote_add_machine, remote_remove_machine, remote_connect, remote_disconnect, remote_list_machines, remote_pty_spawn/write/resize/kill, remote_agent_query/stop, remote_sidecar_restart
+- [x] Heartbeat ping every 15s to detect stale connections
+
+#### Phase D: Frontend integration
+- [x] v2/src/lib/adapters/remote-bridge.ts — IPC adapter for machine management + remote events
+- [x] v2/src/lib/stores/machines.svelte.ts — Svelte 5 store for remote machine state
+- [x] Layout store: added remoteMachineId?: string to Pane interface
+- [x] agent-bridge.ts: routes to remote_agent_query/stop when pane has remoteMachineId
+- [x] pty-bridge.ts: routes to remote_pty_spawn/write/resize/kill when pane has remoteMachineId
+- [x] SettingsDialog: new "Remote Machines" section (add/remove/connect/disconnect UI)
+- [x] SessionList sidebar: auto-groups remote panes by machine label
+
+#### Verification
+- cargo check --workspace: clean (0 errors)
+- vitest: 114/114 tests passing
+- svelte-check: clean (0 errors)
+
+#### New dependencies added
+- bterminal-core: serde, serde_json, log, portable-pty, uuid (extracted from src-tauri)
+- bterminal-relay: tokio, tokio-tungstenite, clap, env_logger, futures-util
+- src-tauri: tokio-tungstenite, tokio, futures-util, uuid (added for RemoteManager)
+
+### Session: 2026-03-06 (continued) — Relay Hardening & Reconnection
+
+#### Relay Command Response Propagation
+- [x] Shared event channel between EventSink and command response sender (sink_tx clone in bterminal-relay)
+- [x] send_error() helper function: all command failures now emit RelayEvent with commandId + error message instead of just logging
+- [x] ping command: now sends pong response via event channel (was a no-op)
+- [x] pty_create: returns pty_created event with session ID and commandId for correlation
+- [x] All error paths (pty_write, pty_resize, pty_close, agent_query, agent_stop, sidecar_restart) use send_error()
+
+#### RemoteManager Reconnection
+- [x] Exponential backoff reconnection in remote.rs: spawns async tokio task on disconnect
+- [x] Backoff schedule: 1s, 2s, 4s, 8s, 16s, 30s (capped)
+- [x] attempt_tcp_probe() function: TCP-only connect probe (5s timeout, default port 9750) — avoids allocating per-connection resources on relay
+- [x] Emits remote-machine-reconnecting (with backoffSecs) and remote-machine-reconnect-ready Tauri events
+- [x] Cancellation: stops if machine removed (not in HashMap) or manually reconnected (status != disconnected)
+- [x] Fixed scoping: disconnection cleanup uses inner block to release mutex before emitting event
+
+#### RemoteManager PTY Creation Confirmation
+- [x] Handles pty_created event type from relay: emits remote-pty-created Tauri event with machineId, ptyId, commandId
+
+### Session: 2026-03-06 (continued) — Reconnection Hardening
+
+#### TCP Probe Refactor
+- [x] Replaced attempt_ws_connect() with attempt_tcp_probe() in remote.rs: TCP-only connect (no WS upgrade), 5s timeout, default port 9750
+- [x] Avoids allocating per-connection resources (PtyManager, SidecarManager) on the relay during reconnection probes
+- [x] Probe no longer needs auth token — only checks TCP reachability
+
+#### Frontend Reconnection Listeners
+- [x] Added onRemoteMachineReconnecting() listener in remote-bridge.ts: receives machineId + backoffSecs
+- [x] Added onRemoteMachineReconnectReady() listener in remote-bridge.ts: receives machineId when probe succeeds
+- [x] machines.svelte.ts: reconnecting handler sets machine status to 'reconnecting', shows toast with backoff duration
+- [x] machines.svelte.ts: reconnect-ready handler auto-calls connectMachine() to re-establish full WebSocket connection
+- [x] Updated docs/multi-machine.md to reflect TCP probe and frontend listener changes
diff --git a/docs/progress.md b/docs/progress.md
index 4d35770..0873c1d 100644
--- a/docs/progress.md
+++ b/docs/progress.md
@@ -1,37 +1,249 @@
 # BTerminal v2 — Progress Log
 
-## Session: 2026-03-05
+> Earlier sessions (2026-03-05 to 2026-03-06 multi-machine): see [progress-archive.md](progress-archive.md)
 
-### Research Phase (complete)
-- [x] Analyzed current BTerminal v1 codebase (2092 lines Python, GTK3+VTE)
-- [x] Queried Memora — no existing BTerminal memories
-- [x] Researched Claude Agent SDK — found structured streaming, subagent tracking, hooks
-- [x] Researched Tauri + xterm.js ecosystem — found 4+ working projects
-- [x] Researched terminal latency benchmarks — xterm.js acceptable for AI output
-- [x] Researched 32:9 ultrawide layout patterns
-- [x] Evaluated GTK4 vs Tauri vs pure Rust — Tauri wins for this use case
-- [x] Created task_plan.md with 8 phases
-- [x] Created findings.md with 7 research areas
+### Session: 2026-03-09 — AgentPane + MarkdownPane UI Redesign
 
-### Technology Decision (complete)
-- Decision: **Tauri 2.x + Solid.js + Claude Agent SDK + xterm.js**
-- Rationale documented in task_plan.md Phase 0
+#### Tribunal-Elected Design (S-3-R4, 88% confidence)
+- [x] AgentPane full rewrite: sans-serif root font, tool call/result pairing via `$derived.by` toolResultMap, hook message collapsing, context window meter, cost bar minimized, session summary styling
+- [x] Two-phase scroll anchoring (`$effect.pre` + `$effect`)
+- [x] Tool-aware output truncation (Bash 500, Read/Write 50, Glob/Grep 20, default 30 lines)
+- [x] Colors softened via `color-mix(in srgb, var(--ctp-*) 65%, var(--ctp-surface1) 35%)`
+- [x] MarkdownPane: container query wrapper, shared responsive padding variable
+- [x] catppuccin.css: `--bterminal-pane-padding-inline: clamp(0.75rem, 3.5cqi, 2rem)`
+- [x] 139/139 vitest passing, 0 new TypeScript errors
+- [ ] Visual verification in dev mode (pending)
 
-### Adversarial Review (complete)
-- [x] Spawned devil's advocate agent to attack the plan
-- [x] Identified 5 fatal/critical issues:
-  1. Node.js sidecar requirement unacknowledged
-  2. SDK 0.2.x instability — need abstraction layer
-  3. Three-tier observation overengineered → simplified to two-tier
-  4. Solid.js ecosystem too small → switched to Svelte 5
-  5. Missing: packaging, error handling, testing, responsive design
-- [x] Revised plan (Rev 2) incorporating all corrections
-- [x] Added error handling strategy table
-- [x] Added testing strategy table
-- [x] Defined MVP boundary (Phases 1-4)
-- [x] Added responsive layout requirement (1920px degraded mode)
+### Session: 2026-03-06 (continued) — Sidecar Env Var Bug Fix
+
+#### CLAUDE* Environment Variable Leak (critical fix)
+- [x] Diagnosed silent hang in agent sessions when BTerminal launched from Claude Code terminal
+- [x] Root cause: Claude Code sets ~8 CLAUDE* env vars for nesting/sandbox detection
+- [x] Fixed both sidecar runners to filter out all keys starting with 'CLAUDE'
+
+### Session: 2026-03-06 (continued) — Sidecar SDK Migration
+
+#### Migration from CLI Spawning to Agent SDK
+- [x] Diagnosed root cause: claude CLI v2.1.69 hangs with piped stdio (bug #6775)
+- [x] Migrated both runners to @anthropic-ai/claude-agent-sdk query() function
+- [x] Added build:sidecar script (esbuild bundle, SDK included)
+- [x] SDK options: permissionMode configurable, allowDangerouslySkipPermissions conditional
+
+#### Bug Found and Fixed
+- [x] AgentPane onDestroy killed running sessions on layout remounts (fixed: moved to TilingGrid onClose)
+
+### Session: 2026-03-06 (continued) — Permission Mode, AgentPane Bug Fix, SDK Bundling
+
+#### Permission Mode Passthrough
+- [x] permission_mode field flows Rust -> sidecar -> SDK, defaults to 'bypassPermissions'
+
+#### AgentPane onDestroy Bug Fix
+- [x] Stop-on-close moved from AgentPane onDestroy to TilingGrid onClose handler
+
+#### SDK Bundling Fix
+- [x] SDK bundled into agent-runner.mjs (no external dependency at runtime)
+
+### Session: 2026-03-07 — Unified Sidecar Bundle
+
+#### Sidecar Resolution Simplification
+- [x] Consolidated to single pre-built bundle (dist/agent-runner.mjs) running on both Deno and Node.js
+- [x] resolve_sidecar_command() checks runtime availability upfront, prefers Deno
+- [x] agent-runner-deno.ts retained in repo but not used by SidecarManager
+
+### Session: 2026-03-07 (continued) — Rust-Side CLAUDE* Env Var Stripping
+
+#### Dual-Layer Env Var Stripping
+- [x] Rust SidecarManager uses env_clear() + envs(clean_env) before spawn (primary defense)
+- [x] JS-side stripping retained as defense-in-depth
+
+### Session: 2026-03-07 (continued) — Claude CLI Path Detection
+
+#### pathToClaudeCodeExecutable for SDK
+- [x] Added findClaudeCli() to agent-runner.ts (Node.js): checks ~/.local/bin/claude, ~/.claude/local/claude, /usr/local/bin/claude, /usr/bin/claude, then falls back to `which claude`/`where claude`
+- [x] Added findClaudeCli() to agent-runner-deno.ts (Deno): same candidate paths, uses Deno.statSync() + Deno.Command("which")
+- [x] Both runners now pass pathToClaudeCodeExecutable to SDK query() options
+- [x] Early error: if Claude CLI not found, agent_error emitted immediately instead of cryptic SDK failure
+- [x] CLI path resolved once at sidecar startup, logged for debugging
+
+### Session: 2026-03-07 (continued) — Claude Profiles & Skill Discovery
+
+#### Claude Profile / Account Switching (switcher-claude integration)
+- [x] New Tauri commands: claude_list_profiles(), claude_list_skills(), claude_read_skill(), pick_directory()
+- [x] claude_list_profiles() reads ~/.config/switcher/profiles/ for profile directories with profile.toml metadata
+- [x] Config dir resolution: ~/.config/switcher-claude/{name}/ or fallback ~/.claude/
+- [x] extract_toml_value() simple TOML parser for profile metadata (email, subscription_type, display_name)
+- [x] Always includes "default" profile if no switcher profiles found
+
+#### Skill Discovery & Autocomplete
+- [x] claude_list_skills() reads ~/.claude/skills/ directory (directories with SKILL.md or standalone .md files)
+- [x] Description extracted from first non-heading, non-empty line (max 120 chars)
+- [x] claude_read_skill(path) reads full skill file content
+- [x] New frontend adapter: v2/src/lib/adapters/claude-bridge.ts (ClaudeProfile, ClaudeSkill interfaces)
+
+#### AgentPane Session Toolbar
+- [x] Working directory input (cwdInput) — editable text field, replaces fixed cwd prop
+- [x] Profile/account selector dropdown (shown when >1 profile available)
+- [x] Selected profile's config_dir passed as claude_config_dir in AgentQueryOptions
+- [x] Skill autocomplete menu: type `/` to trigger, arrow keys navigate, Tab/Enter select, Escape dismiss
+- [x] expandSkillPrompt(): reads skill content via readSkill(), prepends to prompt with optional user args
+
+#### Extended AgentQueryOptions (full stack passthrough)
+- [x] New fields in Rust AgentQueryOptions struct: setting_sources, system_prompt, model, claude_config_dir, additional_directories
+- [x] Sidecar QueryMessage interface updated with matching fields
+- [x] Both sidecar runners (agent-runner.ts, agent-runner-deno.ts) pass new fields to SDK query()
+- [x] CLAUDE_CONFIG_DIR injected into cleanEnv when claudeConfigDir provided (multi-account support)
+- [x] settingSources defaults to ['user', 'project'] (loads CLAUDE.md and project settings)
+- [x] Frontend AgentQueryOptions interface updated in agent-bridge.ts
+
+### Session: 2026-03-07 (continued) — v3 Mission Control Planning
+
+#### v3 Architecture Planning
+- [x] Created docs/v3-task_plan.md — core concept, user requirements, architecture questions
+- [x] Created docs/v3-findings.md — codebase reuse analysis (what to keep/replace/drop)
+- [x] Created docs/v3-progress.md — v3-specific progress log
+- [x] Launched 3 adversarial architecture agents (Architect, Devil's Advocate, UX+Perf Specialist)
+- [x] Collect adversarial agent findings
+- [x] Produce final architecture plan
+- [x] Create v3 implementation phases
+
+### Session: 2026-03-07 (continued) — v3 Mission Control MVP Implementation (Phases 1-5)
+
+#### Phase 1: Data Model + Config
+- [x] Created v2/src/lib/types/groups.ts (ProjectConfig, GroupConfig, GroupsFile interfaces)
+- [x] Created v2/src-tauri/src/groups.rs (Rust structs + load/save groups.json + default_groups())
+- [x] Added groups_load, groups_save Tauri commands to lib.rs
+- [x] SQLite migrations in session.rs: project_id column, agent_messages table, project_agent_state table
+- [x] Created v2/src/lib/adapters/groups-bridge.ts (IPC wrapper)
+- [x] Created v2/src/lib/stores/workspace.svelte.ts (replaces layout.svelte.ts for v3, Svelte 5 runes)
+- [x] Added --group CLI argument parsing in main.rs
+- [x] 24 vitest tests for workspace store + 7 cargo tests for groups
+
+#### Phase 2: Project Box Shell
+- [x] Created 12 new Workspace components in v2/src/lib/components/Workspace/
+- [x] GlobalTabBar, ProjectGrid, ProjectBox, ProjectHeader, CommandPalette, DocsTab, ContextTab, SettingsTab
+- [x] Rewrote App.svelte (no sidebar, no TilingGrid — GlobalTabBar + tab content + StatusBar)
+
+#### Phase 3: Claude Session Integration
+- [x] Created ClaudeSession.svelte wrapping AgentPane per-project
+
+#### Phase 4: Terminal Tabs
+- [x] Created TerminalTabs.svelte with shell/SSH/agent tab types
+
+#### Phase 5: Team Agents Panel
+- [x] Created TeamAgentsPanel.svelte + AgentCard.svelte
+
+#### Bug Fix
+- [x] Fixed AgentPane Svelte 5 event modifier: on:click -> onclick
+
+#### Verification
+- All 138 vitest + 36 cargo tests pass, vite build succeeds
+
+### Session: 2026-03-07 (continued) — v3 Phases 6-10 Completion
+
+#### Phase 6: Session Continuity
+- [x] Added persistSessionForProject() to agent-dispatcher (saves state + messages to SQLite on complete)
+- [x] Added registerSessionProject() + sessionProjectMap for session->project persistence routing
+- [x] ClaudeSession restoreMessagesFromRecords() restores cached messages on mount
+- [x] Added getAgentSession() export to agents store
+
+#### Phase 7: Workspace Teardown
+- [x] Added clearAllAgentSessions() to agents store
+- [x] switchGroup() calls clearAllAgentSessions() + resets terminal tabs
+- [x] Updated workspace.test.ts with clearAllAgentSessions mock
+
+#### Phase 10: Dead Component Removal + Polish
+- [x] Deleted 7 dead v2 components (~1,836 lines): TilingGrid, PaneContainer, PaneHeader, SessionList, SshSessionList, SshDialog, SettingsDialog
+- [x] Removed empty directories: Layout/, Sidebar/, Settings/, SSH/
+- [x] Rewrote StatusBar for workspace store (group name, project count, "BTerminal v3")
+- [x] Fixed subagent routing: project-scoped sessions skip layout pane (render in TeamAgentsPanel)
+- [x] Updated v3-task_plan.md to mark all 10 phases complete
+
+#### Verification
+- All 138 vitest + 36 cargo tests pass, vite build succeeds
+
+### Session: 2026-03-07 (continued) — Multi-Theme System
+
+#### Theme System Generalization (7 Editor Themes)
+- [x] Generalized CatppuccinFlavor to ThemeId union type (11 themes)
+- [x] Added 7 editor themes: VSCode Dark+, Atom One Dark, Monokai, Dracula, Nord, Solarized Dark, GitHub Dark
+- [x] Added ThemePalette, ThemeMeta, THEME_LIST types; deprecated old Catppuccin-only types
+- [x] Theme store: getCurrentTheme()/setTheme() with deprecated wrappers for backwards compat
+- [x] SettingsTab: optgroup-based theme selector, fixed input overflow with min-width:0
+- [x] All themes map to same --ctp-* CSS vars — zero component changes needed
+
+#### Verification
+- All 138 vitest + 35 cargo tests pass
+
+### Session: 2026-03-07 (continued) — Deep Dark Theme Group
+
+#### 6 New Deep Dark Themes
+- [x] Added Tokyo Night, Gruvbox Dark, Ayu Dark, Poimandres, Vesper, Midnight to themes.ts
+- [x] Extended ThemeId from 11 to 17 values, THEME_LIST from 11 to 17 entries
+- [x] New "Deep Dark" theme group (3rd group alongside Catppuccin and Editor)
+- [x] Midnight is pure OLED black (#000000), Ayu Dark near-black (#0b0e14), Vesper warm dark (#101010)
+- [x] All 6 themes map to same 26 --ctp-* CSS vars — zero component changes needed
+
+### Session: 2026-03-07 (continued) — Custom Theme Dropdown
+
+#### SettingsTab Theme Picker Redesign
+- [x] Replaced native `<select>` with custom themed dropdown in SettingsTab.svelte
+- [x] Trigger: color swatch (base) + label + arrow; menu: grouped sections with styled headers
+- [x] Options show color swatch + label + 4 accent dots (red/green/blue/yellow) via getPalette()
+- [x] Click-outside and Escape to close; aria-haspopup/aria-expanded for a11y
+- [x] Uses --ctp-* CSS vars — fully themed with active theme
+
+### Session: 2026-03-07 (continued) — Global Font Controls
+
+#### SettingsTab Font Controls + Layout Restructure
+- [x] Added font family select (9 monospace fonts + Default) with live CSS var preview
+- [x] Added font size +/- stepper (8-24px range) with live CSS var preview
+- [x] Restructured global settings: 2-column grid layout with labels above controls (replaced inline rows)
+- [x] Added --ui-font-family and --ui-font-size CSS custom properties to catppuccin.css
+- [x] app.css body rule now uses CSS vars instead of hardcoded font values
+- [x] initTheme() in theme.svelte.ts restores saved font settings on startup (try/catch, non-fatal)
+- [x] Font settings persisted as 'font_family' and 'font_size' keys in SQLite settings table
+
+### Session: 2026-03-07 (continued) — SettingsTab Global Settings Redesign
+
+#### Font Settings Split (UI Font + Terminal Font)
+- [x] Split single font into UI font (sans-serif: System Sans-Serif, Inter, Roboto, etc.) and Terminal font (monospace: JetBrains Mono, Fira Code, etc.)
+- [x] Each font dropdown renders preview text in its own typeface
+- [x] Independent size steppers (8-24px) for UI and Terminal font
+- [x] Setting keys changed: font_family/font_size -> ui_font_family/ui_font_size + term_font_family/term_font_size
+
+#### SettingsTab Layout + CSS Updates
+- [x] Rewrote global settings: single-column layout, "Appearance" + "Defaults" subsections
+- [x] All dropdowns are custom themed (no native `<select>` anywhere)
+- [x] Added --term-font-family and --term-font-size CSS vars to catppuccin.css
+- [x] Updated initTheme() to restore 4 font settings instead of 2
+
+### Session: 2026-03-08 — CSS Relative Units Rule
+- [x] Created `.claude/rules/18-relative-units.md` — enforces rem/em for layout CSS (px only for icons/borders)
+- [x] Converted GlobalTabBar.svelte styles from px to rem (rail width, button size, gap, padding, border-radius)
+- [x] Converted App.svelte sidebar header styles from px to rem (padding, close button, border-radius)
+- [x] Changed GlobalTabBar rail-btn color from --ctp-overlay1 to --ctp-subtext0
+
+### Session: 2026-03-09 — AgentPane Collapsibles, Aspect Ratio, Desktop Integration
+
+#### AgentPane Collapsible Messages
+- [x] Text messages (`msg.type === 'text'`) wrapped in `<details open>` — open by default, collapsible
+- [x] Cost summary (`cost.result`) wrapped in `<details>` — collapsed by default, expandable
+- [x] CSS: `.msg-text-collapsible` and `.msg-summary-collapsible` with preview text
+
+#### Project Max Aspect Ratio Setting
+- [x] New `project_max_aspect` SQLite setting (float, default 1.0, range 0.3–3.0)
+- [x] ProjectGrid: `max-width: calc(100vh * var(--project-max-aspect, 1))` on `.project-slot`
+- [x] SettingsTab: stepper UI in Appearance section
+- [x] App.svelte: restore on startup via getSetting()
+
+#### Desktop Integration
+- [x] install-v2.sh: added `StartupWMClass=bterminal` to .desktop template
+- [x] GNOME auto-move extension compatible
+
+#### No-Implicit-Push Rule
+- [x] Created `.claude/rules/52-no-implicit-push.md` — never push unless explicitly asked
 
 ### Next Steps
-- [ ] Present plan to user for review and decision
-- [ ] Create feature branch
-- [ ] Begin Phase 1: Project scaffolding
+- [ ] Real-world relay testing (2 machines)
+- [ ] TLS/certificate pinning for relay connections
+- [ ] Test agent teams with CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1
diff --git a/docs/provider-adapter/findings.md b/docs/provider-adapter/findings.md
new file mode 100644
index 0000000..de4c480
--- /dev/null
+++ b/docs/provider-adapter/findings.md
@@ -0,0 +1,62 @@
+# Agent Provider Adapter — Findings
+
+## Architecture Exploration (2026-03-11)
+
+### Claude-Specific Coupling Severity Map
+
+Full codebase exploration of 13+ files revealed coupling at 4 severity levels:
+
+#### CRITICAL (hardcoded SDK, must abstract)
+
+| File | Coupling | Impact |
+|------|----------|--------|
+| `sidecar/agent-runner.ts` | Imports `@anthropic-ai/claude-agent-sdk`, calls `query()`, hardcoded `findClaudeCli()` | Entire sidecar is Claude-only. Must become `claude-runner.ts`. Other providers get own runners. |
+| `bterminal-core/src/sidecar.rs` | `AgentQueryOptions` struct has no `provider` field. `SidecarCommand` hardcodes `agent-runner.mjs` path. | Must add `provider: String` field. Runner selection must be provider-based. |
+| `src/lib/adapters/sdk-messages.ts` | `parseMessage()` assumes Claude SDK JSON format (assistant/user/result types, subagent tool names like `dispatch_agent`) | Must become `claude-messages.ts`. Other providers get own parsers. Registry selects by provider. |
+
+#### HIGH (TS mirror types, provider-specific commands)
+
+| File | Coupling | Impact |
+|------|----------|--------|
+| `src/lib/adapters/agent-bridge.ts` | `AgentQueryOptions` interface mirrors Rust struct — no provider field. `queryAgent()` passes options directly. | Add `provider` field. Options shape stays generic (provider_config blob). |
+| `src-tauri/src/lib.rs` | `claude_list_profiles`, `claude_list_skills`, `claude_read_skill` commands are Claude-specific. | Keep as-is — they're provider-specific commands, not generic agent commands. UI gates by capability. |
+| `src/lib/adapters/claude-bridge.ts` | `listClaudeProfiles()`, `listClaudeSkills()` — provider-specific adapter. | Stays as `claude-bridge.ts`. Other providers get own bridges. Provider-bridge.ts for generic routing. |
+
+#### MEDIUM (provider-aware routing, UI rendering)
+
+| File | Coupling | Impact |
+|------|----------|--------|
+| `src/lib/agent-dispatcher.ts` | `handleAgentMessage()` calls `parseMessage()` (Claude-specific). Subagent tool names hardcoded (`dispatch_agent`). | Route through message adapter registry. Subagent detection becomes provider-capability. |
+| `src/lib/components/Agent/AgentPane.svelte` | Profile selector, skill autocomplete, Claude-specific tool names in rendering logic. | Gate by `ProviderCapabilities`. No `if(provider==='claude')` — use `capabilities.hasProfiles`. |
+| `src/lib/components/Workspace/ClaudeSession.svelte` | Name says "Claude" but logic is mostly generic (session management, prompt, AgentPane). | Rename to `AgentSession.svelte`. Add provider prop. |
+
+#### LOW (mostly generic already)
+
+| File | Coupling | Impact |
+|------|----------|--------|
+| `src/lib/stores/agents.svelte.ts` | AgentMessage type is already generic (text, tool_call, tool_result). No Claude-specific logic. | No changes needed. Common AgentMessage type stays. |
+| `src/lib/stores/health.svelte.ts` | Tracks activity/cost/context per project. Provider-agnostic. | No changes needed. |
+| `src/lib/stores/conflicts.svelte.ts` | File overlap detection. Provider-agnostic (operates on tool_call file paths). | No changes needed. |
+| `bterminal-relay/` | Forwards AgentQueryOptions as-is. No provider logic. | No changes needed (will forward `provider` field transparently). |
+
+### Key Design Insights
+
+1. **Sidecar is the natural boundary**: Each provider needs its own JS runner because SDKs are incompatible (Claude Agent SDK vs Codex CLI vs Ollama REST). The Rust sidecar manager selects which runner to spawn based on `provider` field.
+
+2. **Message format is the main divergence**: Claude SDK emits structured JSON (assistant/user/result with specific fields). Codex CLI has different output format. Ollama uses OpenAI-compatible streaming. Per-provider message adapters normalize to common AgentMessage.
+
+3. **Settings are per-provider + per-project**: Global defaults (API keys, model preferences) are per-provider. Project-level setting is just "which provider to use" (with override for model). Current SettingsTab has room for a collapsible Providers section without needing tabs.
+
+4. **Capability flags eliminate provider switches**: Instead of `if (provider === 'claude') showProfiles()`, use `if (capabilities.hasProfiles) showProfiles()`. This means adding a new provider only requires registering its capabilities — no UI code changes.
+
+5. **env var stripping is provider-specific**: Claude needs CLAUDE* vars stripped (nesting detection). Codex may need CODEX* stripped. Ollama needs nothing stripped. This is part of provider config, not generic logic.
+
+### Risk Assessment
+
+| Risk | Likelihood | Mitigation |
+|------|-----------|------------|
+| Rename breaks imports across 20+ files | High | Do renames one-at-a-time with full grep verification. Run tests after each. |
+| AgentQueryOptions Rust/TS mismatch | Medium | Add provider field to both simultaneously. Default to 'claude'. |
+| Message parser regression | Medium | sdk-messages.ts has 25 tests. Copy tests to claude-messages.ts test file. All must pass. |
+| Settings persistence migration | Low | New settings keys (provider defaults) — no migration needed, just new keys. |
+| UI regression from capability gating | Medium | Start with Claude capabilities = all true. Verify AgentPane renders identically. |
diff --git a/docs/provider-adapter/progress.md b/docs/provider-adapter/progress.md
new file mode 100644
index 0000000..a9d3a24
--- /dev/null
+++ b/docs/provider-adapter/progress.md
@@ -0,0 +1,95 @@
+# Agent Provider Adapter — Progress
+
+## Session Log
+
+### 2026-03-11 — Planning Phase
+
+**Duration:** ~30 min
+
+**What happened:**
+1. Explored 13+ files across Rust backend, TypeScript bridges, Svelte UI, and JS sidecar to map Claude-specific coupling
+2. Classified coupling into 4 severity levels (CRITICAL/HIGH/MEDIUM/LOW)
+3. Ran /ultra-think for deep architectural analysis — evaluated 3 design options for sidecar routing, message adapters, and settings UI
+4. Made 6 architecture decisions (PA-1 through PA-6)
+5. Created 3-phase implementation plan (16 + 5 + 3 tasks)
+6. Created planning files: task_plan.md, findings.md, progress.md
+
+**Architecture decisions made:**
+- PA-1: Per-provider sidecar binaries (not single multi-SDK bundle)
+- PA-2: Generic provider_config blob in AgentQueryOptions
+- PA-3: Per-provider message adapter files → common AgentMessage type
+- PA-4: Provider selection per-project with global default
+- PA-5: Capability flags drive UI rendering (not provider ID checks)
+- PA-6: Providers section in SettingsTab scroll (not inner tabs)
+
+**Status:** Planning complete. Ready for Phase 1 implementation.
+
+### 2026-03-11 — Implementation (All 3 Phases)
+
+**Duration:** ~60 min
+
+**What happened:**
+
+**Phase 1 — Core Abstraction Layer (16 tasks):**
+1. Created provider types (ProviderId, ProviderCapabilities, ProviderMeta, ProviderSettings)
+2. Created Svelte 5 rune-based provider registry (registry.svelte.ts)
+3. Created Claude provider meta constant (claude.ts)
+4. Renamed sdk-messages.ts → claude-messages.ts, updated 13+ import references
+5. Created message adapter registry (message-adapters.ts) with per-provider routing
+6. Updated Rust AgentQueryOptions with `provider` and `provider_config` fields (serde defaults for backward compat)
+7. Updated agent-bridge.ts TypeScript options
+8. Renamed agent-runner.ts → claude-runner.ts, rebuilt dist bundle
+9. Added provider field to ProjectConfig (groups.ts)
+10. Renamed ClaudeSession.svelte → AgentSession.svelte with provider awareness
+11. Updated agent-dispatcher.ts with sessionProviderMap for provider-based message routing
+12. Updated AgentPane.svelte with capability-driven rendering (hasProfiles, hasSkills, supportsResume gates)
+13. Created provider-bridge.ts (generic adapter delegating to provider-specific bridges)
+14. Registered CLAUDE_PROVIDER in App.svelte onMount
+15. Updated all test mocks (dispatcher test: adaptMessage mock with provider param)
+16. Verified: 202 vitest + 42 cargo tests pass
+
+**Phase 2 — Settings UI (5 tasks):**
+1. Added "Providers" section to SettingsTab with collapsible per-provider config panels
+2. Each panel: enabled toggle, default model input, capabilities badge display
+3. Added per-project provider dropdown in project cards (conditional on >1 provider)
+4. Provider settings persisted as JSON blob via `provider_settings` settings key
+5. AgentPane already capability-aware from Phase 1
+
+**Phase 3 — Sidecar Routing (3 tasks):**
+1. Refactored resolve_sidecar_command() → resolve_sidecar_for_provider(provider) — looks for `{provider}-runner.mjs`
+2. query() validates provider runner exists before sending message
+3. Extracted strip_provider_env_var() — strips CLAUDE*/CODEX*/OLLAMA* env vars (whitelists CLAUDE_CODE_EXPERIMENTAL_*)
+
+**Status:** All 3 phases complete. 202 vitest + 42 cargo tests pass. Zero regression.
+
+### 2026-03-11 — Provider Runners (Codex + Ollama)
+
+**Duration:** ~45 min
+
+**What happened:**
+
+**Research:**
+1. Researched OpenAI Codex CLI programmatic interface (SDK, NDJSON stream format, thread events, sandbox/approval modes, session resume)
+2. Researched Ollama REST API (/api/chat, NDJSON streaming, tool calling, token counts, health check)
+
+**Codex Provider (3 files):**
+1. Created providers/codex.ts — ProviderMeta (gpt-5.4 default, hasSandbox=true, supportsResume=true, no profiles/skills/cost)
+2. Created adapters/codex-messages.ts — adaptCodexMessage() maps ThreadEvents to AgentMessage[] (agent_message→text, reasoning→thinking, command_execution→Bash tool pair, file_change→Write/Edit/Bash per change, mcp_tool_call→server:tool, web_search→WebSearch, turn.completed→cost with tokens)
+3. Created sidecar/codex-runner.ts — @openai/codex-sdk wrapper (dynamic import, graceful failure, sandbox/approval mapping, CODEX_API_KEY auth, session resume via thread ID)
+
+**Ollama Provider (3 files):**
+1. Created providers/ollama.ts — ProviderMeta (qwen3:8b default, hasModelSelection only, all other capabilities false)
+2. Created adapters/ollama-messages.ts — adaptOllamaMessage() maps synthesized chunk events (text, thinking from Qwen3, done→cost with eval_duration/token counts, always $0)
+3. Created sidecar/ollama-runner.ts — Direct HTTP to localhost:11434/api/chat (zero deps, health check, NDJSON stream parsing, configurable host/model/num_ctx/think)
+
+**Registration + Build:**
+1. Registered CODEX_PROVIDER + OLLAMA_PROVIDER in App.svelte onMount
+2. Registered adaptCodexMessage + adaptOllamaMessage in message-adapters.ts
+3. Updated build:sidecar script to build all 3 runners via esbuild
+
+**Tests:**
+- 19 new tests for codex-messages.ts (all event types)
+- 11 new tests for ollama-messages.ts (all event types)
+- 256 vitest + 42 cargo tests pass. Zero regression.
+
+**Status:** Provider runners complete. Both providers infrastructure-ready (will work when CLI/server installed).
diff --git a/docs/provider-adapter/task_plan.md b/docs/provider-adapter/task_plan.md
new file mode 100644
index 0000000..03528d1
--- /dev/null
+++ b/docs/provider-adapter/task_plan.md
@@ -0,0 +1,134 @@
+# Agent Provider Adapter — Task Plan
+
+## Goal
+
+Multi-provider agent support (Claude Code, Codex CLI, Ollama) via adapter pattern. Claude Code remains primary and fully functional. Zero regression.
+
+## Architecture Decisions
+
+| # | Date | Decision | Rationale |
+|---|------|----------|-----------|
+| PA-1 | 2026-03-11 | Per-provider sidecar binaries (not single multi-SDK bundle) | Independent testing, no bloat, clean separation. SidecarCommand already abstracts binary path. |
+| PA-2 | 2026-03-11 | Generic provider_config blob in AgentQueryOptions (not discriminated union) | Rust passes through without parsing. TypeScript uses discriminated unions for compile-time safety. Minimal Rust changes. |
+| PA-3 | 2026-03-11 | Per-provider message adapter files → common AgentMessage type | sdk-messages.ts becomes claude-messages.ts. Registry selects parser by provider. Store/UI unchanged. |
+| PA-4 | 2026-03-11 | Provider selection per-project with global default | ProjectConfig.provider field (default: 'claude'). Matches real workflow. |
+| PA-5 | 2026-03-11 | Capability flags drive UI rendering (not provider ID checks) | ProviderCapabilities interface. AgentPane checks hasProfiles/hasSkills/etc. No hardcoded if(provider==='claude'). |
+| PA-6 | 2026-03-11 | Providers section in SettingsTab scroll (not inner tabs) | Current sections aren't long enough for tabs. Collapsible per-provider config panels. |
+
+## Phases
+
+### Phase 1: Core Abstraction Layer (no functional change)
+
+**Goal:** Insert abstraction boundary. Claude remains the only registered provider. Zero user-visible change.
+
+| # | Task | Files | Status |
+|---|------|-------|--------|
+| 1.1 | Create provider types | NEW: `src/lib/providers/types.ts` | done |
+| 1.2 | Create provider registry | NEW: `src/lib/providers/registry.svelte.ts` | done |
+| 1.3 | Create Claude provider meta | NEW: `src/lib/providers/claude.ts` | done |
+| 1.4 | Rename sdk-messages.ts → claude-messages.ts | RENAME + update imports | done |
+| 1.5 | Create message adapter registry | NEW: `src/lib/adapters/message-adapters.ts` | done |
+| 1.6 | Update Rust AgentQueryOptions | MOD: `bterminal-core/src/sidecar.rs` | done |
+| 1.7 | Update agent-bridge.ts options shape | MOD: `src/lib/adapters/agent-bridge.ts` | done |
+| 1.8 | Rename agent-runner.ts → claude-runner.ts | RENAME + update build script | done |
+| 1.9 | Add provider field to ProjectConfig | MOD: `src/lib/types/groups.ts` | done |
+| 1.10 | Rename ClaudeSession.svelte → AgentSession.svelte | RENAME + update imports | done |
+| 1.11 | Update agent-dispatcher provider routing | MOD: `src/lib/agent-dispatcher.ts` | done |
+| 1.12 | Update AgentPane for capability-driven rendering | MOD: `src/lib/components/Agent/AgentPane.svelte` | done |
+| 1.13 | Rename claude-bridge.ts → provider-bridge.ts | RENAME + genericize | done |
+| 1.14 | Update Rust lib.rs commands | MOD: `src-tauri/src/lib.rs` | done |
+| 1.15 | Update all tests | MOD: test files | done |
+| 1.16 | Verify: 202 vitest + 42 cargo tests pass | — | done |
+
+### Phase 2: Settings UI
+
+| # | Task | Files | Status |
+|---|------|-------|--------|
+| 2.1 | Add Providers section to SettingsTab | MOD: `SettingsTab.svelte` | done |
+| 2.2 | Per-provider collapsible config panels | MOD: `SettingsTab.svelte` | done |
+| 2.3 | Per-project provider dropdown | MOD: `SettingsTab.svelte` | done |
+| 2.4 | Persist provider settings | MOD: `settings-bridge.ts` | done |
+| 2.5 | Provider-aware AgentPane | MOD: `AgentPane.svelte` | done |
+
+### Phase 3: Sidecar Routing
+
+| # | Task | Files | Status |
+|---|------|-------|--------|
+| 3.1 | SidecarManager provider-based runner selection | MOD: `bterminal-core/src/sidecar.rs` | done |
+| 3.2 | Per-provider runner discovery | MOD: `bterminal-core/src/sidecar.rs` | done |
+| 3.3 | Provider-specific env var stripping | MOD: `bterminal-core/src/sidecar.rs` | done |
+
+## Type System
+
+### ProviderQueryOptions (TypeScript → Rust → Sidecar)
+
+```
+Frontend (typed):
+  AgentQueryOptions {
+    provider: ProviderId        // 'claude' | 'codex' | 'ollama'
+    session_id: string
+    prompt: string
+    model?: string
+    max_turns?: number
+    provider_config: Record<string, unknown>  // provider-specific
+  }
+         ↓ (Tauri invoke)
+Rust (generic):
+  AgentQueryOptions {
+    provider: String
+    session_id: String
+    prompt: String
+    model: Option<String>
+    max_turns: Option<u32>
+    provider_config: serde_json::Value
+  }
+         ↓ (stdin NDJSON)
+Sidecar (provider-specific):
+  claude-runner.ts parses provider_config as ClaudeProviderConfig
+  codex-runner.ts parses provider_config as CodexProviderConfig
+  ollama-runner.ts parses provider_config as OllamaProviderConfig
+```
+
+### Message Flow (Sidecar → Frontend)
+
+```
+Sidecar stdout (NDJSON, provider-specific format)
+         ↓
+Rust SidecarManager (pass-through, adds sessionId)
+         ↓
+agent-dispatcher.ts
+  → message-adapters.ts registry
+    → claude-messages.ts (if provider=claude)
+    → codex-messages.ts (if provider=codex, future)
+    → ollama-messages.ts (if provider=ollama, future)
+  → AgentMessage (common type)
+         ↓
+agents.svelte.ts store (unchanged)
+         ↓
+AgentPane.svelte (renders AgentMessage, capability-driven)
+```
+
+## File Inventory
+
+### New Files (Phase 1)
+- `v2/src/lib/providers/types.ts`
+- `v2/src/lib/providers/registry.svelte.ts`
+- `v2/src/lib/providers/claude.ts`
+- `v2/src/lib/adapters/message-adapters.ts`
+
+### Renamed Files (Phase 1)
+- `sdk-messages.ts` → `claude-messages.ts`
+- `agent-runner.ts` → `claude-runner.ts`
+- `ClaudeSession.svelte` → `AgentSession.svelte`
+- `claude-bridge.ts` → `provider-bridge.ts` (genericized)
+
+### Modified Files (Phase 1)
+- `bterminal-core/src/sidecar.rs` — AgentQueryOptions struct
+- `src-tauri/src/lib.rs` — command handlers
+- `src/lib/adapters/agent-bridge.ts` — options interface
+- `src/lib/agent-dispatcher.ts` — provider routing
+- `src/lib/components/Agent/AgentPane.svelte` — capability checks
+- `src/lib/components/Workspace/ProjectBox.svelte` — import rename
+- `src/lib/types/groups.ts` — ProjectConfig.provider field
+- `package.json` — build:sidecar script path
+- Test files — import path updates
diff --git a/docs/task_plan.md b/docs/task_plan.md
index 75e4c49..908c114 100644
--- a/docs/task_plan.md
+++ b/docs/task_plan.md
@@ -3,7 +3,7 @@
 ## Goal
 Redesign BTerminal from a GTK3 terminal emulator into a **multi-session Claude agent dashboard** optimized for 32:9 ultrawide (5120x1440). Simultaneous visibility of all active sessions, agent tree visualization, inline markdown rendering, maximum information density.
 
-## Status: PLANNING (Rev 2 — post-adversarial review)
+## Status: Phases 1-7 + Multi-Machine (A-D) + Profiles/Skills Complete — Rev 6
 
 ---
 
@@ -74,12 +74,13 @@ The Agent SDK cannot run in Rust or the webview. Solution:
 └─────────────────────────────────────────────────────┘
 ```
 
-- Rust spawns Node.js child process on demand (when user starts an SDK agent session)
+- Rust spawns Node.js/Deno child process on app launch (auto-start in setup, Deno-first)
 - Communication: stdio with newline-delimited JSON (simple, no socket server)
-- Node.js process runs a thin wrapper that calls `query()` and forwards messages
+- Node.js/Deno process uses `@anthropic-ai/claude-agent-sdk` query() function which handles claude subprocess management internally
+- SDK messages forwarded as-is via NDJSON — same format as CLI stream-json
 - If sidecar crashes: detect via process exit, show error in UI, offer restart
-- **Packaging:** Bundle the sidecar JS as a single file (esbuild bundle). Require Node.js 20+ as system dependency. Document in install.sh.
-- **Future:** Could replace Node.js with Deno (single binary, no npm) for better packaging.
+- **Packaging:** Bundle the sidecar JS + SDK as a single file (esbuild bundle, SDK included). Require Node.js 20+ as system dependency. Document in install.sh.
+- **Unified bundle:** Single pre-built agent-runner.mjs works with both Deno and Node.js. SidecarCommand struct abstracts runtime. Deno preferred (faster startup). Falls back to Node.js.
 
 ### SDK Abstraction Layer
 
@@ -103,10 +104,11 @@ When SDK changes its message format, only the adapter needs updating.
 
 ## Implementation Phases
 
-See [phases.md](phases.md) for the full phased implementation plan (Phases 1-6).
+See [phases.md](phases.md) for the full phased implementation plan.
 
 - **MVP:** Phases 1-4 (scaffolding, terminal+layout, agent SDK, session mgmt+markdown)
-- **Post-MVP:** Phases 5-6 (agent tree, polish, packaging)
+- **Post-MVP:** Phases 5-7 (agent tree, polish, packaging, agent teams)
+- **Multi-Machine:** Phases A-D (bterminal-core extraction, relay binary, RemoteManager, frontend)
 
 ---
 
@@ -123,12 +125,43 @@ See [phases.md](phases.md) for the full phased implementation plan (Phases 1-6).
 | SDK abstraction layer | SDK is 0.2.x, 127 versions in 5 months. Must insulate UI from wire format changes | 2026-03-05 |
 | MVP = Phases 1-4 | Ship usable tool before tackling tree viz, packaging, polish | 2026-03-05 |
 | Canvas addon (not WebGL) | WebKit2GTK has no WebGL. Explicit Canvas addon avoids silent fallback | 2026-03-05 |
+| claude CLI over Agent SDK query() | SUPERSEDED — initially used `claude -p --output-format stream-json` to avoid SDK dep. CLI hangs with piped stdio (bug #6775). Migrated to `@anthropic-ai/claude-agent-sdk` query() which handles subprocess internally | 2026-03-06 |
+| Agent SDK migration | Replaced raw CLI spawning with @anthropic-ai/claude-agent-sdk query(). SDK handles subprocess management, auth, nesting detection. Messages same format as stream-json so adapter unchanged. AbortController for session stop. | 2026-03-06 |
+| `.svelte.ts` for rune stores | Svelte 5 `$state`/`$derived` runes require `.svelte.ts` extension (not `.ts`). Compiler silently passes `.ts` but runes fail at runtime. All store files must use `.svelte.ts`. | 2026-03-06 |
+| SQLite settings table for app config | Key-value `settings` table in session.rs for persisting user preferences (shell, cwd, max panes). Simple and extensible without schema migrations. | 2026-03-06 |
+| Toast notifications over persistent log | Ephemeral toasts (4s auto-dismiss, max 5) for agent events rather than a persistent notification log. Keeps UI clean; persistent logs can be added later if needed. | 2026-03-06 |
+| Build-from-source installer over pre-built binaries | install-v2.sh checks deps and builds locally. Pre-built binaries via GitHub Actions CI (.deb + AppImage on v* tags). Auto-update deferred until signing key infrastructure is set up. | 2026-03-06 |
+| ctx read-only access from Rust | Open ~/.claude-context/context.db with SQLITE_OPEN_READ_ONLY. Never write — ctx CLI owns the schema. Separate CtxDb struct in ctx.rs with Option<Connection> for graceful absence. | 2026-03-06 |
+| SSH via PTY shell args | SSH sessions spawn TerminalPane with shell=/usr/bin/ssh and args=[-p, port, [-i, keyfile], user@host]. No special SSH library — PTY handles it natively. | 2026-03-06 |
+| Catppuccin 4 flavors at runtime | CSS variables overridden at runtime. onThemeChange() callback registry in theme.svelte.ts allows open terminals to hot-swap themes. | 2026-03-06 |
+| Detached pane via URL params | Pop-out windows use ?detached=1&type=terminal URL params. App.svelte conditionally renders single pane without sidebar/grid chrome. Simple, no IPC needed. | 2026-03-06 |
+| Shiki over highlight.js | Shiki provides VS Code-grade syntax highlighting with Catppuccin theme. Lazy singleton pattern avoids repeated WASM init. 13 languages preloaded. | 2026-03-06 |
+| Vitest for frontend tests | Vitest over Jest — zero-config with Vite, same transform pipeline, faster. Test config in vite.config.ts. | 2026-03-06 |
+| Deno sidecar evaluation | Proof-of-concept agent-runner-deno.ts created. Deno compiles to single binary (better packaging). Same NDJSON protocol. Not yet integrated. | 2026-03-06 |
+| Splitter overlays for pane resize | Fixed-position divs outside CSS Grid (avoids layout interference). Mouse drag updates customColumns/customRows state. Resets on preset change. | 2026-03-06 |
+| Unified sidecar bundle | Single agent-runner.mjs works with both Deno and Node.js. resolve_sidecar_command() checks runtime availability upfront, prefers Deno (faster startup). Only .mjs bundled in tauri.conf.json resources. agent-runner-deno.ts removed from bundle. | 2026-03-07 |
+| Session groups/folders | group_name column in sessions table with ALTER TABLE migration. Pane.group field in layout store. Collapsible group headers in sidebar. Right-click to set group. | 2026-03-06 |
+| Auto-update signing key | Generated minisign keypair. Pubkey set in tauri.conf.json. Private key for TAURI_SIGNING_PRIVATE_KEY GitHub secret. | 2026-03-06 |
+| Agent teams: frontend routing only | Subagent panes created by frontend dispatcher, not separate sidecar processes. Parent sidecar handles all messages; routing uses SDK's parentId field. Avoids process explosion for nested subagents. | 2026-03-06 |
+| SUBAGENT_TOOL_NAMES detection | Detect subagent spawn by tool_call name ('Agent', 'Task', 'dispatch_agent'). Simple Set lookup, easily extensible. | 2026-03-06 |
+| Cargo workspace at v2/ level | Extract bterminal-core shared crate for PtyManager + SidecarManager. Workspace members: src-tauri, bterminal-core, bterminal-relay. Enables code reuse between Tauri app and relay binary. | 2026-03-06 |
+| EventSink trait for event abstraction | Generic trait (emit method) decouples PtyManager/SidecarManager from Tauri. TauriEventSink wraps AppHandle; relay uses WebSocket EventSink. | 2026-03-06 |
+| bterminal-relay as standalone binary | Rust binary with WebSocket server for remote machine management. Token auth + rate limiting. Per-connection isolated managers. | 2026-03-06 |
+| RemoteManager WebSocket client | Controller-side WebSocket client in remote.rs. Manages connections to multiple relays with heartbeat ping. 12 new Tauri commands for remote operations. | 2026-03-06 |
+| Frontend remote routing via remoteMachineId | Pane.remoteMachineId field determines local vs remote. Bridge adapters route to appropriate Tauri commands transparently. | 2026-03-06 |
+| Permission mode passthrough | AgentQueryOptions.permission_mode flows Rust -> sidecar -> SDK. Defaults to 'bypassPermissions', supports 'default'. Enables non-bypass agent sessions. | 2026-03-06 |
+| Stop-on-close in TilingGrid, not AgentPane | Removed onDestroy stopAgent() from AgentPane (fired on layout remounts). Stop logic moved to TilingGrid onClose handler — only fires on explicit user close. | 2026-03-06 |
+| Bundle SDK into sidecar | Removed --external flag from esbuild build:sidecar. SDK bundled into agent-runner.mjs — no runtime dependency on node_modules. | 2026-03-06 |
+| pathToClaudeCodeExecutable | Auto-detect Claude CLI path at sidecar startup via findClaudeCli() (checks common paths + `which`). Pass to SDK query() options. Early error if CLI not found. | 2026-03-07 |
+| Claude profiles (switcher-claude) | Read ~/.config/switcher/profiles/ for multi-account support. Profile selector in AgentPane toolbar when >1 profile. Selected profile's config_dir passed as CLAUDE_CONFIG_DIR to SDK env. | 2026-03-07 |
+| Skill discovery & autocomplete | Read ~/.claude/skills/ for skill files. `/` prefix triggers autocomplete in prompt textarea. Skill content read and injected as prompt. | 2026-03-07 |
+| Extended AgentQueryOptions | Added setting_sources, system_prompt, model, claude_config_dir, additional_directories to full stack (Rust struct -> sidecar JSON -> SDK options). settingSources defaults to ['user', 'project']. | 2026-03-07 |
 
 ## Open Questions
 
-1. **Node.js or Deno for sidecar?** Node.js has the SDK package. Deno would be a single binary (better packaging) but needs SDK compatibility testing. → Start Node.js, evaluate Deno later.
-2. **Multi-machine support?** Remote agents via WebSocket. Phase 7+ feature.
-3. **Agent Teams integration?** Experimental Anthropic feature. Natural fit but adds complexity. Phase 7+.
+1. **Node.js or Deno for sidecar?** Resolved: Single pre-built agent-runner.mjs runs on both Deno and Node.js. SidecarCommand struct in sidecar.rs abstracts the runtime choice. Deno preferred (faster startup). Falls back to Node.js. Both use `@anthropic-ai/claude-agent-sdk` query() bundled into the .mjs file.
+2. **Multi-machine support?** Resolved: Implemented (Phases A-D complete). See [multi-machine.md](multi-machine.md) for architecture. bterminal-core crate extracted, bterminal-relay binary built, RemoteManager + frontend integration done. Reconnection with exponential backoff implemented. Remaining: real-world testing, TLS.
+3. **Agent Teams integration?** Phase 7 — frontend routing implemented (subagent pane spawning, parent/child navigation). Needs real-world testing with CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1.
 4. **Electron escape hatch threshold?** If Canvas xterm.js proves >50ms latency on target system with 4 panes, switch to Electron. Benchmark in Phase 2.
 
 ## Error Handling Strategy
@@ -155,4 +188,9 @@ See [phases.md](phases.md) for the full phased implementation plan (Phases 1-6).
 
 ## Errors Encountered
 
-(none yet)
+| Error | Cause | Fix | Date |
+|---|---|---|---|
+| Blank screen, "rune_outside_svelte" runtime error | Store files used `.ts` extension but contain Svelte 5 `$state`/`$derived` runes. Runes only work in `.svelte` and `.svelte.ts` files. Compiler silently passes but fails at runtime. | Renamed stores to `.svelte.ts`, updated all import paths to use `.svelte` suffix | 2026-03-06 |
+| Agent sessions produce no output (silent hang) | Claude CLI v2.1.69 hangs when spawned via child_process.spawn() with piped stdio. Known bug: github.com/anthropics/claude-code/issues/6775 | Migrated sidecar from raw CLI spawning to `@anthropic-ai/claude-agent-sdk` query() function. SDK handles subprocess management internally. | 2026-03-06 |
+| CLAUDE* env vars leak to sidecar | When BTerminal launched from Claude Code terminal, CLAUDE* env vars trigger nesting detection in sidecar | Dual-layer stripping: Rust SidecarManager uses env_clear()+envs(clean_env) before spawn (primary), JS runner strips via SDK env option (defense-in-depth) | 2026-03-07 |
+| Running agents killed on pane remount | AgentPane.svelte onDestroy called stopAgent() on component unmount, including layout changes and remounts — not just explicit close. | Removed onDestroy from AgentPane. Moved stop-on-close to TilingGrid onClose handler which only fires on explicit user action. | 2026-03-06 |
diff --git a/docs/v3-findings.md b/docs/v3-findings.md
new file mode 100644
index 0000000..5036167
--- /dev/null
+++ b/docs/v3-findings.md
@@ -0,0 +1,62 @@
+# BTerminal v3 — Research Findings
+
+## Adversarial Review Results (2026-03-07)
+
+### Agent: Architect (Advocate)
+- Proposed full component tree, data model, 10-phase plan
+- JSON config at `~/.config/bterminal/groups.json`
+- Single shared sidecar (multiplexed sessions)
+- ClaudeSession + TeamAgentsPanel split from AgentPane
+- SQLite tables: agent_messages, project_agent_state
+- MVP at Phase 5
+
+### Agent: Devil's Advocate
+- Found 12 issues, 4 critical:
+  1. xterm.js 4-instance ceiling (hard OOM wall)
+  2. Single sidecar SPOF
+  3. Layout store has no workspace concept
+  4. 384px per project unusable on 1920px
+- Recommended: fix workspace concept, xterm budget, UI density, persistence before anything else
+- Proposed suspend/resume ring buffer for terminals
+- Proposed per-project sidecar pool (max 3) — deferred to v3.1
+
+### Agent: UX + Performance Specialist
+- Wireframes for 5120px (5 projects) and 1920px (3 projects)
+- Adaptive project count: `Math.floor(width / 520)`
+- xterm budget: lazy-init + scrollback serialization
+- RAF batching for 5 concurrent streams
+- <100ms workspace switch via serialize/unmount/remount
+- Memory budget: ~225MB total (within WebKit2GTK limits)
+- Team panel: inline >2560px, overlay <2560px
+- Command palette: Ctrl+K, floating overlay, fuzzy search
+
+## Codebase Reuse Analysis
+
+### Survives (with modifications)
+- TerminalPane.svelte — add suspend/resume lifecycle
+- MarkdownPane.svelte — unchanged
+- AgentTree.svelte — reused inside ClaudeSession
+- ContextPane.svelte — extracted to workspace tab
+- StatusBar.svelte — modified for per-project costs
+- ToastContainer.svelte — unchanged
+- agents.svelte.ts — add projectId field
+- theme.svelte.ts — unchanged
+- notifications.svelte.ts — unchanged
+- All adapters (agent-bridge, pty-bridge, claude-bridge, sdk-messages, session-bridge, ctx-bridge, ssh-bridge)
+- All Rust backend (sidecar, pty, session, ctx, watcher)
+- highlight.ts, agent-tree.ts utils
+
+### Replaced
+- layout.svelte.ts → workspace.svelte.ts
+- TilingGrid.svelte → ProjectGrid.svelte
+- PaneContainer.svelte → ProjectBox.svelte
+- SessionList.svelte → ProjectHeader + command palette
+- SettingsDialog.svelte → SettingsTab.svelte
+- AgentPane.svelte → ClaudeSession.svelte + TeamAgentsPanel.svelte
+- App.svelte → full rewrite
+
+### Dropped (v3.0)
+- Detached pane mode (doesn't fit workspace model)
+- Drag-resize splitters (project boxes have fixed internal layout)
+- Layout presets (1-col, 2-col, etc.) — replaced by adaptive project count
+- Remote machine integration (deferred to v3.1, elevated to project level)
diff --git a/docs/v3-progress.md b/docs/v3-progress.md
new file mode 100644
index 0000000..c8c1734
--- /dev/null
+++ b/docs/v3-progress.md
@@ -0,0 +1,1076 @@
+# BTerminal v3 — Progress Log
+
+### Session: 2026-03-07 — Architecture Planning + MVP Implementation (Phases 1-5)
+
+#### Phase: Adversarial Design Review
+- [x] Launch 3 architecture agents (Architect, Devil's Advocate, UX+Performance Specialist)
+- [x] Collect findings — 12 issues identified, all resolved
+- [x] Produce final architecture plan in docs/v3-task_plan.md
+- [x] Create 10-phase implementation plan
+
+#### Phase 1: Data Model + Config
+- [x] Created `v2/src/lib/types/groups.ts` — TypeScript interfaces (ProjectConfig, GroupConfig, GroupsFile)
+- [x] Created `v2/src-tauri/src/groups.rs` — Rust structs + load/save groups.json
+- [x] Added `groups_load`, `groups_save` Tauri commands to lib.rs
+- [x] SQLite migrations in session.rs: project_id column, agent_messages table, project_agent_state table
+- [x] Created `v2/src/lib/adapters/groups-bridge.ts` (IPC wrapper)
+- [x] Created `v2/src/lib/stores/workspace.svelte.ts` (replaces layout.svelte.ts, Svelte 5 runes)
+- [x] Added `--group` CLI argument parsing in main.rs
+- [x] Wrote 24 vitest tests for workspace store (workspace.test.ts)
+- [x] Wrote cargo tests for groups load/save/default
+
+#### Phase 2: Project Box Shell
+- [x] Created GlobalTabBar.svelte (Sessions | Docs | Context | Settings)
+- [x] Created ProjectGrid.svelte (flex + scroll-snap container)
+- [x] Created ProjectBox.svelte (CSS grid: header | session-area | terminal-area)
+- [x] Created ProjectHeader.svelte (icon + name + status dot + accent color)
+- [x] Rewrote App.svelte (GlobalTabBar + tab content + StatusBar, no sidebar/TilingGrid)
+- [x] Created CommandPalette.svelte (Ctrl+K overlay with fuzzy search)
+- [x] Created DocsTab.svelte (markdown file browser per project)
+- [x] Created ContextTab.svelte (wrapper for ContextPane)
+- [x] Created SettingsTab.svelte (per-project + global settings editor)
+- [x] CSS for responsive project count + Catppuccin accent colors
+
+#### Phase 3: Claude Session Integration
+- [x] Created ClaudeSession.svelte (wraps AgentPane, passes project cwd/profile/config_dir)
+
+#### Phase 4: Terminal Tabs
+- [x] Created TerminalTabs.svelte (tab bar + content, shell/SSH/agent tab types)
+
+#### Phase 5: Team Agents Panel
+- [x] Created TeamAgentsPanel.svelte (right panel for subagents)
+- [x] Created AgentCard.svelte (compact subagent view: status, messages, cost)
+
+#### Bug Fix
+- [x] Fixed AgentPane Svelte 5 event modifier syntax: `on:click` -> `onclick` (Svelte 5 requires lowercase event attributes)
+
+#### Verification
+- All 138 vitest tests pass (114 existing + 24 new workspace tests)
+- All 36 cargo tests pass (29 existing + 7 new groups tests)
+- Vite build succeeds
+
+### Session: 2026-03-07 — Phases 6-10 Completion
+
+#### Phase 6: Session Continuity
+- [x] Added `persistSessionForProject()` to agent-dispatcher — saves agent state + messages to SQLite on session complete
+- [x] Added `registerSessionProject()` — maps sessionId -> projectId for persistence routing
+- [x] Added `sessionProjectMap` (Map<string, string>) in agent-dispatcher
+- [x] Updated ClaudeSession.svelte: `restoreMessagesFromRecords()` restores cached messages into agent store on mount
+- [x] ClaudeSession loads previous state via `loadProjectAgentState()`, restores session ID and messages
+- [x] Added `getAgentSession()` export to agents store
+
+#### Phase 7: Workspace Teardown on Group Switch
+- [x] Added `clearAllAgentSessions()` to agents store (clears sessions array)
+- [x] Updated `switchGroup()` in workspace store to call `clearAllAgentSessions()` + reset terminal tabs
+- [x] Updated workspace.test.ts to mock `clearAllAgentSessions`
+
+#### Phase 10: Dead Component Removal + Polish
+- [x] Deleted `TilingGrid.svelte` (328 lines), `PaneContainer.svelte` (113 lines), `PaneHeader.svelte` (44 lines)
+- [x] Deleted `SessionList.svelte` (374 lines), `SshSessionList.svelte` (263 lines), `SshDialog.svelte` (281 lines), `SettingsDialog.svelte` (433 lines)
+- [x] Removed empty directories: Layout/, Sidebar/, Settings/, SSH/
+- [x] Rewrote StatusBar.svelte for workspace store (group name, project count, agent count, "BTerminal v3" label)
+- [x] Fixed subagent routing in agent-dispatcher: project-scoped sessions skip layout pane creation (subagents render in TeamAgentsPanel instead)
+- [x] Updated v3-task_plan.md to mark all 10 phases complete
+
+#### Verification
+- All 138 vitest tests pass (including updated workspace tests with clearAllAgentSessions mock)
+- All 36 cargo tests pass
+- Vite build succeeds
+- ~1,836 lines of dead code removed
+
+### Session: 2026-03-07 — SettingsTab Global Settings + Cleanup
+
+#### SettingsTab Global Settings Section
+- [x] Added "Global" section to SettingsTab.svelte with three settings:
+  - Theme flavor dropdown (Catppuccin Latte/Frappe/Macchiato/Mocha) via `setFlavor()` from theme store
+  - Default shell text input (persisted via `setSetting('default_shell', ...)`)
+  - Default CWD text input (persisted via `setSetting('default_cwd', ...)`)
+- [x] Global settings load on mount via `getSetting()` from settings-bridge
+- [x] Added imports: `onMount`, `getSetting`/`setSetting`, `getCurrentFlavor`/`setFlavor`, `CatppuccinFlavor` type
+
+#### A11y Fixes
+- [x] Changed project field labels from `<div class="project-field"><label>` to wrapping `<label class="project-field"><span class="field-label">` pattern — proper label/input association
+- [x] Global settings use `id`/`for` label association (e.g., `id="theme-flavor"`, `id="default-shell"`)
+
+#### CSS Cleanup
+- [x] Removed unused `.project-field label` selector (replaced by `.field-label`)
+- [x] Simplified `.project-field input[type="text"], .project-field input:not([type])` to `.project-field input:not([type="checkbox"])`
+
+#### Rust Cleanup (committed separately)
+- [x] Removed dead `update_ssh_session()` method from session.rs and its test
+- [x] Fixed stale TilingGrid comment in AgentPane.svelte
+
+### Session: 2026-03-07 — Multi-Theme System (7 Editor Themes)
+
+#### Theme System Generalization
+- [x] Generalized `CatppuccinFlavor` type to `ThemeId` union type (11 values)
+- [x] Added 7 new editor themes: VSCode Dark+, Atom One Dark, Monokai, Dracula, Nord, Solarized Dark, GitHub Dark
+- [x] Added `ThemePalette` interface (26-color slots) — all themes map to same slots
+- [x] Added `ThemeMeta` interface (id, label, group, isDark) for UI metadata
+- [x] Added `THEME_LIST: ThemeMeta[]` with group metadata ('Catppuccin' or 'Editor')
+- [x] Added `ALL_THEME_IDS: ThemeId[]` derived from THEME_LIST for validation
+- [x] Deprecated `CatppuccinFlavor`, `CatppuccinPalette`, `FLAVOR_LABELS`, `ALL_FLAVORS` (kept as backwards compat aliases)
+
+#### Theme Store Updates
+- [x] `getCurrentTheme(): ThemeId` replaces `getCurrentFlavor()` as primary getter
+- [x] `setTheme(theme: ThemeId)` replaces `setFlavor()` as primary setter
+- [x] `initTheme()` validates saved theme against `ALL_THEME_IDS`
+- [x] Deprecated `getCurrentFlavor()` and `setFlavor()` with delegation wrappers
+
+#### SettingsTab Theme Selector
+- [x] Theme dropdown uses `<optgroup>` per theme group (Catppuccin, Editor)
+- [x] `themeGroups` derived from `THEME_LIST` using Map grouping
+- [x] `handleThemeChange()` replaces direct `setFlavor()` call
+- [x] Fixed input overflow in `.setting-row` with `min-width: 0`
+
+#### Design Decision
+All editor themes map to the same `--ctp-*` CSS custom property names (26 vars). This means every component works unchanged — no component-level theme awareness needed. Each theme provides its own mapping of colors to the 26 semantic slots.
+
+#### Verification
+- All 138 vitest + 35 cargo tests pass
+
+### Session: 2026-03-07 — Deep Dark Theme Group (6 Themes)
+
+#### New Theme Group: Deep Dark
+- [x] Added 6 new "Deep Dark" themes to `v2/src/lib/styles/themes.ts`:
+  - Tokyo Night (base: #1a1b26)
+  - Gruvbox Dark (base: #1d2021)
+  - Ayu Dark (base: #0b0e14, near-black)
+  - Poimandres (base: #1b1e28)
+  - Vesper (base: #101010, warm dark)
+  - Midnight (base: #000000, pure OLED black)
+- [x] Extended `ThemeId` union type from 11 to 17 values
+- [x] Added `THEME_LIST` entries with `group: 'Deep Dark'`
+- [x] Added all 6 palette definitions (26 colors each) mapped to --ctp-* slots
+- [x] Total themes: 17 across 3 groups (Catppuccin 4, Editor 7, Deep Dark 6)
+
+#### Verification
+- No test changes needed — theme palettes are data-only, no logic changes
+
+### Session: 2026-03-07 — Custom Theme Dropdown
+
+#### SettingsTab Theme Picker Redesign
+- [x] Replaced native `<select>` with custom themed dropdown in SettingsTab.svelte
+- [x] Dropdown trigger shows color swatch (base color from getPalette()) + theme label + arrow indicator
+- [x] Dropdown menu groups themes by category (Catppuccin/Editor/Deep Dark) with styled uppercase headers
+- [x] Each option shows: color swatch + label + 4 accent color dots (red/green/blue/yellow)
+- [x] Active theme highlighted with surface0 background + bold text
+- [x] Click-outside handler and Escape key to close dropdown
+- [x] Uses --ctp-* CSS vars throughout — fully themed with any active theme
+- [x] Added `getPalette` import from themes.ts for live color rendering
+- [x] Added aria-haspopup/aria-expanded attributes for accessibility
+
+#### Verification
+- No test changes needed — UI-only change, no logic changes
+
+### Session: 2026-03-07 — Theme Dropdown CSS Polish
+
+#### SettingsTab Dropdown Sizing Fix
+- [x] Set `min-width: 180px` on `.theme-dropdown` container (was `min-width: 0`) to prevent trigger from collapsing
+- [x] Set `min-width: 280px` on `.theme-options` dropdown menu (was `right: 0`) to ensure full theme names visible
+- [x] Increased `max-height` from 320px to 400px on dropdown menu for better scrolling experience
+- [x] Added `white-space: nowrap` on `.theme-option-label` (was `min-width: 0`) to prevent label text wrapping
+
+#### Verification
+- No test changes needed — CSS-only change
+
+### Session: 2026-03-07 — Global Font Controls
+
+#### SettingsTab Font Family + Font Size Controls
+- [x] Added font family `<select>` with 9 monospace font options (JetBrains Mono, Fira Code, Cascadia Code, Source Code Pro, IBM Plex Mono, Hack, Inconsolata, Ubuntu Mono, monospace) + "Default" option
+- [x] Added font size +/- stepper control with numeric input (range 8-24px)
+- [x] Both controls apply live preview via CSS custom properties (`--ui-font-family`, `--ui-font-size`)
+- [x] Both settings persisted to SQLite via settings-bridge (`font_family`, `font_size` keys)
+- [x] `handleFontFamilyChange()` and `handleFontSizeChange()` functions with validation
+
+#### SettingsTab Layout Restructure
+- [x] Restructured global settings from inline `.setting-row` (label left, control right) to 2-column `.global-grid` with `.setting-field` (label above control)
+- [x] Labels now uppercase, 0.7rem, subtext0 color — consistent compact labeling
+- [x] All inputs/selects use consistent styling (surface0 bg, surface1 border, 4px radius)
+
+#### CSS Typography Variables
+- [x] Added `--ui-font-family` and `--ui-font-size` to catppuccin.css `:root` (defaults: JetBrains Mono fallback chain, 13px)
+- [x] Updated `app.css` body rule to use CSS vars instead of hardcoded font values
+
+#### Theme Store Font Restoration
+- [x] Extended `initTheme()` in `theme.svelte.ts` to load and apply saved `font_family` and `font_size` settings on startup
+- [x] Font restoration wrapped in try/catch — failures are non-fatal (CSS defaults apply)
+
+#### Verification
+- No test changes needed — UI/CSS-only changes, no logic changes
+
+### Session: 2026-03-07 — Settings Drawer Conversion
+
+#### Settings Tab to Drawer
+- [x] Converted Settings from a full-page tab to a collapsible side drawer
+- [x] GlobalTabBar now has 3 tabs (Sessions/Docs/Context) + gear icon toggle for settings drawer
+- [x] App.svelte renders SettingsTab in an `<aside>` drawer (right side, 32em width, semi-transparent backdrop)
+- [x] Drawer close: Escape key, click-outside (backdrop), close button (X icon)
+- [x] Gear icon in GlobalTabBar highlights blue when drawer is open (active state)
+- [x] GlobalTabBar accepts props: `settingsOpen`, `ontoggleSettings`
+- [x] Removed 'settings' from WorkspaceTab union type (now 'sessions' | 'docs' | 'context')
+- [x] Alt+1..3 for tabs (was Alt+1..4), Ctrl+, toggles drawer (was setActiveTab('settings'))
+- [x] SettingsTab padding reduced (12px 16px), max-width removed, flex:1 for drawer context
+
+#### Verification
+- All 138 vitest tests pass
+
+### Session: 2026-03-08 — VSCode-Style Sidebar Redesign
+
+#### UI Layout Redesign (Top Tab Bar -> Left Sidebar)
+- [x] Redesigned GlobalTabBar.svelte from horizontal tab bar to vertical icon rail (36px wide)
+  - 4 SVG icon buttons: Sessions (grid), Docs (document), Context (clock), Settings (gear)
+  - Each button uses SVG path from `icons` record mapped by WorkspaceTab
+  - Props renamed: `settingsOpen` -> `expanded`, `ontoggleSettings` -> `ontoggle`
+  - `handleTabClick()` manages toggle: clicking active tab collapses drawer
+- [x] Rewrote App.svelte layout from vertical (top tab bar + content area + settings drawer) to horizontal (icon rail + sidebar panel + workspace)
+  - `.main-row` flex container: GlobalTabBar | sidebar-panel (28em, max 50%) | workspace
+  - ProjectGrid always visible in main workspace (not inside tab content)
+  - Sidebar panel renders active tab content (Sessions/Docs/Context/Settings)
+  - Panel header with title + close button
+  - Removed backdrop overlay, drawer is inline sidebar not overlay
+- [x] Re-added 'settings' to WorkspaceTab union type (was removed when settings was a drawer)
+- [x] SettingsTab CSS: changed `flex: 1` to `height: 100%` for sidebar panel context
+- [x] Updated keyboard shortcuts:
+  - Alt+1..4 (was Alt+1..3): switch tabs + open drawer, toggle if same tab
+  - Ctrl+B (new): toggle sidebar open/closed
+  - Ctrl+, : open settings panel (toggle if already active)
+  - Escape: close drawer
+- [x] State variables renamed: `settingsOpen` -> `drawerOpen`, `toggleSettings()` -> `toggleDrawer()`
+- [x] Added `panelTitles` record for drawer header labels
+
+#### Design Decisions
+- VSCode-style sidebar chosen for: always-visible workspace, progressive disclosure, familiar UX
+- Settings as regular tab (not special drawer) simplifies code and mental model
+- Icon rail at 36px minimizes horizontal space cost
+- No backdrop overlay — sidebar is inline, not modal
+
+#### Verification
+- All 138 vitest tests pass
+- svelte-check clean (only 2 third-party esrap warnings)
+
+### Session: 2026-03-07 — SettingsTab Global Settings Redesign
+
+#### Font Settings Split (UI Font + Terminal Font)
+- [x] Split single font setting into UI font (sans-serif options) and Terminal font (monospace options)
+- [x] UI font dropdown: System Sans-Serif, Inter, Roboto, Open Sans, Lato, Noto Sans, Source Sans 3, IBM Plex Sans, Ubuntu + Default
+- [x] Terminal font dropdown: JetBrains Mono, Fira Code, Cascadia Code, Source Code Pro, IBM Plex Mono, Hack, Inconsolata, Ubuntu Mono, monospace + Default
+- [x] Each font dropdown renders preview text in its own typeface
+- [x] Size steppers (8-24px) for both UI and Terminal font independently
+- [x] Changed setting keys: font_family -> ui_font_family, font_size -> ui_font_size, + new term_font_family, term_font_size
+
+#### SettingsTab Layout Redesign
+- [x] Rewrote global settings as single-column layout with labels above controls
+- [x] Split into "Appearance" subsection (theme, UI font, terminal font) and "Defaults" subsection (shell, CWD)
+- [x] All dropdowns now use reusable custom themed dropdowns (no native `<select>` anywhere)
+
+#### CSS + Theme Store Updates
+- [x] Added `--term-font-family` and `--term-font-size` CSS custom properties to catppuccin.css
+- [x] Updated `initTheme()` in theme.svelte.ts: loads 4 font settings (ui_font_family, ui_font_size, term_font_family, term_font_size) instead of 2
+- [x] UI font fallback changed from monospace to sans-serif
+
+#### Verification
+- No test changes needed — UI/CSS-only changes, no logic changes
+
+### Session: 2026-03-08 — CSS Relative Units Rule
+
+#### New Rule: 18-relative-units.md
+- [x] Created `.claude/rules/18-relative-units.md` enforcing rem/em for layout CSS
+- [x] Pixels allowed only for icon sizes, borders/outlines, box shadows
+- [x] Exception: --ui-font-size/--term-font-size CSS vars store px (xterm.js API requirement)
+- [x] Added rule #18 to `.claude/CLAUDE.md` rule index
+
+#### CSS Conversions
+- [x] GlobalTabBar.svelte: rail width 36px -> 2.75rem, button 28px -> 2rem, gap 2px -> 0.25rem, padding 6px 4px -> 0.5rem 0.375rem, border-radius 4px -> 0.375rem
+- [x] App.svelte: sidebar header padding 8px 12px -> 0.5rem 0.75rem, close button 22px -> 1.375rem, border-radius 4px -> 0.25rem
+- [x] Also changed GlobalTabBar rail-btn color from --ctp-overlay1 to --ctp-subtext0 for better contrast
+
+### Session: 2026-03-08 — Content-Driven Sidebar Width
+
+#### Sidebar Panel Sizing
+- [x] Changed `.sidebar-panel` from fixed `width: 28em` to `width: max-content` with `min-width: 16em` and `max-width: 50%`
+- [x] Changed `.sidebar-panel` and `.panel-content` from `overflow: hidden` to `overflow-y: auto` — hidden was blocking content from driving parent width
+- [x] Each tab component now defines its own `min-width: 22em` (SettingsTab, ContextTab, DocsTab)
+
+#### Additional px → rem Conversions
+- [x] SettingsTab.svelte: padding 12px 16px → 0.75rem 1rem
+- [x] DocsTab.svelte: file-picker 220px → 14em, picker-title padding → rem, file-btn padding → rem, empty/loading padding → rem
+- [x] ContextPane.svelte: font-size, padding, margin, gap converted from px to rem; added `white-space: nowrap` on `.ctx-header`/`.ctx-error` for intrinsic width measurement
+
+#### Fix: Sidebar Drawer Content-Driven Width
+- [x] Root cause found: `#app` in `app.css` had leftover v2 grid layout (`display: grid; grid-template-columns: var(--sidebar-width) 1fr`) constraining `.app-shell` to 260px first column
+- [x] Removed v2 grid + both media queries from `#app` — v3 `.app-shell` manages its own flexbox layout
+- [x] Added JS `$effect` in App.svelte: measures content width via `requestAnimationFrame` + `querySelectorAll` for nowrap elements, headings, inputs, tab-specific selectors; `panelWidth` state drives inline `style:width`
+- [x] Verified all 4 tabs scale to content: Sessions ~473px, Settings ~322px, Context ~580px, Docs varies by content
+- [x] Investigation path: CSS intrinsic sizing (max-content, fit-content) failed due to column-flex circular dependency → JS measurement approach → discovered inline style set but rendered width wrong → Playwright inspection revealed parent `.main-row` only 260px → traced to `#app` grid layout
+
+### Session: 2026-03-08 — Native Directory Picker
+
+#### tauri-plugin-dialog Integration
+- [x] Added `tauri-plugin-dialog` Rust crate + `@tauri-apps/plugin-dialog` npm package
+- [x] Registered plugin in lib.rs (`tauri_plugin_dialog::init()`)
+- [x] Removed stub `pick_directory` Tauri command (always returned None)
+- [x] Added `browseDirectory()` helper in SettingsTab.svelte using `open({ directory: true })`
+- [x] Added folder browse button (folder SVG icon) to: Default CWD, existing project CWD, Add Project path
+- [x] Styled `.input-with-browse` layout (flex row, themed browse button)
+- [x] Fixed nested input theme: `.setting-field .input-with-browse input` selector for dark background
+- [x] Fixed dialog not opening: added `"dialog:default"` permission to `v2/src-tauri/capabilities/default.json` — Tauri IPC security blocked invoke() without capability
+- [x] Verified via Playwright: error was `Cannot read properties of undefined (reading 'invoke')` in browser context (expected — Tauri IPC only exists in WebView), confirming code is correct
+- [x] Clean rebuild required after capability changes (cached binary doesn't pick up new permissions)
+
+#### Modal + Dark-Themed Dialog
+- [x] Root cause: `tauri-plugin-dialog` skips `set_parent(&window)` on Linux via `cfg(any(windows, target_os = "macos"))` gate in commands.rs — dialog not modal
+- [x] Root cause: native GTK file chooser uses system GTK theme, not app's CSS theme — dialog appears light
+- [x] Fix: custom `pick_directory` Tauri command using `rfd::AsyncFileDialog` directly with `.set_parent(&window)` — modal on Linux
+- [x] Fix: `std::env::set_var("GTK_THEME", "Adwaita:dark")` at start of `run()` in lib.rs — dark-themed dialog
+- [x] Added `rfd = { version = "0.16", default-features = false, features = ["gtk3"] }` as direct dep — MUST disable defaults to avoid gtk3+xdg-portal feature conflict
+- [x] Switched SettingsTab from `@tauri-apps/plugin-dialog` `open()` to `invoke<string | null>('pick_directory')`
+
+### Session: 2026-03-08 — Project Workspace Layout Redesign + Icon Fix
+
+#### Icon Fix
+- [x] Replaced Nerd Font codepoints (`\uf120`) with emoji (`📁` default) — Nerd Font not installed, showed "?"
+- [x] Added emoji picker grid (24 project-relevant emoji, 8-column popup) in SettingsTab instead of plain text input
+- [x] Removed `font-family: 'NerdFontsSymbols Nerd Font'` from ProjectHeader and TerminalTabs
+
+#### ProjectBox Layout Redesign
+- [x] Switched ProjectBox from flex to CSS grid (`grid-template-rows: auto 1fr auto`) — header | session | terminal zones
+- [x] Terminal area: explicit `height: 16rem` instead of collapsing to content
+- [x] Session area: `min-height: 0` for proper flex child overflow
+
+#### AgentPane Prompt Layout
+- [x] Prompt area anchored to bottom (`justify-content: flex-end`) instead of vertical center
+- [x] Removed `max-width: 600px` constraint on form and toolbar — uses full panel width
+- [x] Toolbar sits directly above textarea
+
+#### CSS px → rem Conversions
+- [x] ProjectGrid.svelte: gap 4px → 0.25rem, padding 4px → 0.25rem, min-width 480px → 30rem
+- [x] TerminalTabs.svelte: tab bar, tabs, close/add buttons all converted to rem
+- [x] ProjectBox.svelte: min-width 480px → 30rem
+
+### Session: 2026-03-08 — Project-Level Tabs + Clean AgentPane
+
+#### ProjectHeader Info Bar
+- [x] Added CWD path display (ellipsized from START via `direction: rtl` + `text-overflow: ellipsis`)
+- [x] Added profile name as info-only text (right side of header)
+- [x] Home dir shortening: `/home/user/foo` → `~/foo`
+
+#### Project-Level Tab Bar
+- [x] Added tab bar in ProjectBox below header: Claude | Files | Context
+- [x] Content area switches between ClaudeSession, ProjectFiles, ContextPane based on selected tab
+- [x] CSS grid updated to 4 rows: `auto auto 1fr auto` (header | tabs | content | terminal)
+- [x] TeamAgentsPanel still renders alongside ClaudeSession in Claude tab
+
+#### ProjectFiles Component (NEW)
+- [x] Created `ProjectFiles.svelte` — project-scoped markdown file viewer
+- [x] Accepts `cwd` + `projectName` props (not workspace store)
+- [x] File picker sidebar (10rem) + MarkdownPane content area
+- [x] Auto-selects priority file or first file
+
+#### AgentPane Cleanup
+- [x] Removed entire session toolbar (DIR/ACC interactive inputs + all CSS)
+- [x] Added `profile` prop — resolved via `listProfiles()` to get config_dir
+- [x] CWD passed as prop from parent (project.cwd), no longer editable in pane
+- [x] Clean chat interface: prompt (bottom-anchored) + messages + send button
+- [x] ClaudeSession now passes `project.profile` to AgentPane
+
+#### Verification
+- All 138 vitest tests pass
+- Vite build succeeds
+
+### Session: 2026-03-08 — Security Audit Fixes + OTEL Telemetry
+
+#### Security Audit Fixes
+- [x] Fixed all CRITICAL (5) + HIGH (4) findings — path traversal, race conditions, memory leaks, listener leaks, transaction safety
+- [x] Fixed all MEDIUM (6) findings — runtime type guards, ANTHROPIC_* env stripping, timestamp mismatch, async lock, error propagation
+- [x] Fixed all LOW (8) findings — input validation, mutex poisoning, log warnings, payload validation
+- [x] 3 false positives dismissed with rationale
+- [x] 172/172 tests pass (138 vitest + 34 cargo)
+
+#### OTEL Telemetry Implementation
+- [x] Added 6 Rust deps: tracing, tracing-subscriber, opentelemetry 0.28, opentelemetry_sdk 0.28, opentelemetry-otlp 0.28, tracing-opentelemetry 0.29
+- [x] Created `v2/src-tauri/src/telemetry.rs` — TelemetryGuard, layer composition, OTLP export via BTERMINAL_OTLP_ENDPOINT env var
+- [x] Integrated into lib.rs: TelemetryGuard in AppState, init before Tauri builder
+- [x] Instrumented 10 Tauri commands with `#[tracing::instrument]`: pty_spawn, pty_kill, agent_query/stop/restart, remote_connect/disconnect/agent_query/agent_stop/pty_spawn
+- [x] Added `frontend_log` Tauri command for frontend→Rust tracing bridge
+- [x] Created `v2/src/lib/adapters/telemetry-bridge.ts` — `tel.info/warn/error/debug/trace()` convenience API
+- [x] Wired agent dispatcher lifecycle events: agent_started, agent_stopped, agent_error, sidecar_crashed, cost metrics
+- [x] Created Docker compose stack: `docker/tempo/` — Tempo (4317/4318/3200) + Grafana (port 9715)
+
+### Session: 2026-03-08 — Teardown Race Fix + px→rem Conversion
+
+#### Workspace Teardown Race Fix
+- [x] Added `pendingPersistCount` counter + `waitForPendingPersistence()` export in agent-dispatcher.ts
+- [x] `persistSessionForProject()` increments/decrements counter in try/finally
+- [x] `switchGroup()` in workspace.svelte.ts now awaits `waitForPendingPersistence()` before clearing state
+- [x] SettingsTab.svelte switchGroup onclick handler made async with await
+- [x] Added test for `waitForPendingPersistence` in agent-dispatcher.test.ts
+- [x] Added mock for `waitForPendingPersistence` in workspace.test.ts
+- [x] Last open HIGH audit finding resolved (workspace teardown race)
+
+#### px→rem Conversion (Rule 18 Compliance)
+- [x] Converted ~100 px layout violations to rem across 10 components
+- [x] AgentPane.svelte (~35 violations: font-size, padding, gap, margin, max-height, border-radius)
+- [x] ToastContainer.svelte, CommandPalette.svelte, TeamAgentsPanel.svelte, AgentCard.svelte
+- [x] StatusBar.svelte, AgentTree.svelte, TerminalPane.svelte, AgentPreviewPane.svelte, SettingsTab.svelte
+- [x] Icon/decorative dot dimensions kept as px per rule 18
+- [x] 139 vitest + 34 cargo tests pass, vite build succeeds
+
+### Session: 2026-03-08 — E2E Testing Infrastructure
+
+#### WebdriverIO + tauri-driver Setup
+- [x] Installed @wdio/cli, @wdio/local-runner, @wdio/mocha-framework, @wdio/spec-reporter (v9.24.0)
+- [x] Created wdio.conf.js with tauri-driver lifecycle hooks (onPrepare builds debug binary, beforeSession/afterSession spawns/kills tauri-driver)
+- [x] Created tsconfig.json for e2e test TypeScript compilation
+- [x] Created smoke.test.ts with 6 tests: app title, status bar, version text, sidebar rail, workspace area, sidebar toggle
+- [x] Added `test:e2e` npm script (`wdio run tests/e2e/wdio.conf.js`)
+- [x] Updated README.md with complete setup instructions and CI guide
+- [x] Key decision: WebdriverIO over Playwright (Playwright cannot control Tauri/WebKit2GTK apps)
+- [x] Prerequisites: tauri-driver (cargo install), webkit2gtk-driver (apt), display server or xvfb-run
+
+#### E2E Fixes (wdio v9 + tauri-driver compatibility)
+- [x] Fixed wdio v9 BiDi: added `wdio:enforceWebDriverClassic: true` — wdio v9 injects webSocketUrl:true which tauri-driver rejects
+- [x] Removed `browserName: 'wry'` from capabilities (not needed in wdio, only Selenium)
+- [x] Fixed binary path: Cargo workspace target is v2/target/debug/, not v2/src-tauri/target/debug/
+- [x] Fixed tauri-plugin-log panic: telemetry::init() registers tracing-subscriber before plugin-log → removed tauri-plugin-log entirely (redundant with telemetry::init())
+- [x] Removed tauri-plugin-log from Cargo.toml dependency
+
+#### E2E Coverage Expansion (25 tests, single spec file)
+- [x] Consolidated 4 spec files into single bterminal.test.ts — Tauri creates one app session per spec file; after first spec completes, app closes and subsequent specs get "invalid session id"
+- [x] Added Workspace & Projects tests (8): project grid, project boxes, header with name, 3 project tabs, active highlight, tab switching, status bar counts
+- [x] Added Settings Panel tests (6): settings tab, sections, theme dropdown, dropdown open+options, group list, close button
+- [x] Added Keyboard Shortcuts tests (5): Ctrl+K command palette, Ctrl+, settings, Ctrl+B sidebar, Escape close, palette group list
+- [x] Fixed WebDriver clicks on Svelte 5 components: `element.click()` doesn't reliably trigger onclick inside complex components via WebKit2GTK/tauri-driver — use `browser.execute()` for JS-level clicks
+- [x] Fixed CSS text-transform: `.ptab` getText() returns uppercase — use `.toLowerCase()` for comparison
+- [x] Fixed element scoping: `browser.$('.ptab')` returns ALL tabs across project boxes — scope via `box.$('.ptab')`
+- [x] Fixed keyboard focus: `browser.execute(() => document.body.focus())` before sending shortcuts
+- [x] Removed old individual spec files (smoke.test.ts, keyboard.test.ts, settings.test.ts, workspace.test.ts)
+- [x] All 25 E2E tests pass (9s runtime after build)
+
+### Session: 2026-03-10 — Tab System Overhaul
+
+#### Tab Renames + New Tabs
+- [x] Renamed Claude → Model, Files → Docs in ProjectBox
+- [x] Added 3 new tabs: Files (directory browser), SSH (connection manager), Memory (knowledge explorer)
+- [x] Implemented PERSISTED-EAGER (Model/Docs/Context — display:flex/none) vs PERSISTED-LAZY (Files/SSH/Memory — {#if everActivated} + display:flex/none) mount strategy
+- [x] Tab type union: 'model' | 'docs' | 'context' | 'files' | 'ssh' | 'memories'
+
+#### Files Tab (FilesTab.svelte)
+- [x] VSCode-style tree sidebar (14rem) + content viewer
+- [x] Rust list_directory_children command: lazy expansion, hidden files skipped, dirs-first sort
+- [x] Rust read_file_content command: FileContent tagged union (Text/Binary/TooLarge), 10MB gate, 30+ language mappings
+- [x] Frontend files-bridge.ts adapter (DirEntry, FileContent types)
+- [x] Shiki syntax highlighting for code files, image display via convertFileSrc, emoji file icons
+
+#### SSH Tab (SshTab.svelte)
+- [x] CRUD panel for SSH connections using existing ssh-bridge.ts/SshSession model
+- [x] Launch button spawns terminal tab in Model tab's TerminalTabs section via addTerminalTab()
+
+#### Memory Tab (MemoriesTab.svelte)
+- [x] Pluggable MemoryAdapter interface (memory-adapter.ts): name, available, list(), search(), get()
+- [x] Adapter registry: registerMemoryAdapter(), getDefaultAdapter(), getAvailableAdapters()
+- [x] UI: search bar, tag display, expandable cards, adapter switcher, placeholder when no adapter
+
+#### Context Tab Repurpose (ContextTab.svelte)
+- [x] Replaced ContextPane (ctx database viewer) with LLM context window visualization
+- [x] Tribunal debate for design (S-1-R4 winner at 82% confidence)
+- [x] Stats bar: input/output tokens, cost, turns, duration
+- [x] Segmented token meter: CSS flex bar with color-coded categories (assistant/thinking/tool calls/tool results)
+- [x] File references: extracted from tool_call messages, colored op badges
+- [x] Turn breakdown: collapsible message groups by user prompt
+- [x] Token estimation via ~4 chars/token heuristic
+- [x] Wired into ProjectBox (replaces ContextPane, passes sessionId)
+- [x] Sub-tab navigation: Overview | AST | Graph
+- [x] AST tab: per-turn SVG conversation trees (Thinking/Response/ToolCall/File nodes, bezier edges, token counts)
+- [x] Graph tab: bipartite tool→file DAG (tools left, files right, curved edges, count badges)
+- [x] Compaction detection: sdk-messages.ts adapts `compact_boundary` system messages → `CompactionContent` type
+- [x] Stats bar compaction pill: yellow count badge with tooltip (last trigger, tokens removed)
+- [x] AST compaction boundaries: red "Compacted" nodes inserted between turns at compaction points
+
+#### FilesTab Fixes & CodeMirror Editor
+- [x] Fixed HTML nesting error: `<button>` inside `<button>` → `<div role="tab">`
+- [x] Fixed Svelte 5 $state proxy reactivity: look up tab from reactive array before setting content
+- [x] CodeEditor.svelte: CodeMirror 6 with 15 lazy-loaded language modes, Catppuccin theme
+- [x] Dirty tracking, Ctrl+S save, save-on-blur setting (files_save_on_blur in SettingsTab)
+- [x] write_file_content Rust command (safety: existing files only)
+
+#### Project Health Dashboard (S-3 — Mission Control)
+- [x] health.svelte.ts store: per-project ActivityState (running/idle/stalled), burn rate ($/hr EMA), context pressure (% of model limit), attention scoring
+- [x] StatusBar → Mission Control bar: running/idle/stalled counts, $/hr burn rate, "needs attention" priority queue dropdown
+- [x] ProjectHeader health indicators: status dot (color-coded), context pressure badge, burn rate badge
+- [x] session_metrics SQLite table: per-project historical metrics (100-row retention)
+- [x] Rust commands: session_metric_save, session_metrics_load
+- [x] TypeScript bridge: SessionMetric interface, saveSessionMetric(), loadSessionMetrics()
+- [x] agent-dispatcher wiring: recordActivity, recordToolDone, recordTokenSnapshot, sessionStartTimes, metric persistence on completion
+- [x] ClaudeSession: trackProject() on session create/restore
+- [x] App.svelte: startHealthTick()/stopHealthTick() lifecycle
+- [x] workspace.svelte.ts: clearHealthTracking() on group switch
+
+#### Verification
+- [x] svelte-check: 0 new errors (only pre-existing esrap type errors)
+- [x] vitest: 139/139 tests pass
+- [x] cargo test: 34/34 pass
+
+### Session: 2026-03-11 — S-1 Phase 1.5: Conflict Detection Enhancements
+
+#### Bash Write Detection
+- [x] BASH_WRITE_PATTERNS regex array in tool-files.ts: >, >>, sed -i, tee [-a], cp dest, mv dest, chmod/chown
+- [x] extractBashWritePaths() helper with /dev/null and flag-target filtering
+- [x] Write detection prioritized over read detection for ambiguous commands (cat file > out)
+- [x] extractWritePaths() now captures Bash writes alongside Write/Edit
+
+#### Acknowledge/Dismiss Conflicts
+- [x] acknowledgeConflicts(projectId) API in conflicts.svelte.ts — marks current conflicts as acknowledged
+- [x] acknowledgedFiles Map state — suppresses badge until new session writes to acknowledged file
+- [x] ProjectHeader conflict badge → clickable button with ✕ (stopPropagation, hover darkens)
+- [x] Ack auto-cleared when new session writes to previously-acknowledged file
+
+#### Worktree-Aware Conflict Suppression
+- [x] sessionWorktrees Map in conflicts store — tracks worktree path per session (null = main tree)
+- [x] setSessionWorktree(sessionId, path) API
+- [x] areInDifferentWorktrees() / hasRealConflict() — suppresses conflicts between sessions in different worktrees
+- [x] extractWorktreePath(tc) in tool-files.ts — detects Agent/Task isolation:"worktree" and EnterWorktree
+- [x] agent-dispatcher.ts wiring: registers worktree paths from tool_call events
+- [x] useWorktrees?: boolean field on ProjectConfig (groups.ts) for future per-project setting
+
+#### Verification
+- [x] vitest: 194/194 tests pass (+24 new: 5 extractWorktreePath, 10 bash write, 9 acknowledge/worktree)
+- [x] cargo test: 34/34 pass
+
+### Session: 2026-03-11 — S-1 Phase 2: Filesystem Write Detection
+
+#### Rust Backend — ProjectFsWatcher
+- [x] New module `v2/src-tauri/src/fs_watcher.rs` — per-project recursive inotify watchers via notify crate v6
+- [x] Debouncing (100ms per-file), ignored dirs (.git/, node_modules/, target/, etc.)
+- [x] Emits `fs-write-detected` Tauri events with FsWritePayload { project_id, file_path, timestamp_ms }
+- [x] Two Tauri commands: `fs_watch_project`, `fs_unwatch_project`
+- [x] ProjectFsWatcher added to AppState, initialized in setup()
+- [x] 5 Rust unit tests for path filtering (should_ignore_path)
+
+#### Frontend Bridge
+- [x] New `v2/src/lib/adapters/fs-watcher-bridge.ts` — fsWatchProject(), fsUnwatchProject(), onFsWriteDetected()
+
+#### External Write Detection (conflicts store)
+- [x] EXTERNAL_SESSION_ID = '__external__' sentinel for non-agent writers
+- [x] agentWriteTimestamps Map — tracks when agents write files (for timing heuristic)
+- [x] recordExternalWrite(projectId, filePath, timestampMs) — 2s grace window suppresses agent's own writes
+- [x] getExternalConflictCount(projectId) — counts external-only conflicts
+- [x] FileConflict.isExternal flag, ProjectConflicts.externalConflictCount field
+- [x] clearAllConflicts/clearProjectConflicts clear timestamp state
+
+#### Health Store Integration
+- [x] externalConflictCount added to ProjectHealth interface
+- [x] Attention reason includes "(N external)" note when external conflicts present
+
+#### UI Updates
+- [x] ProjectBox $effect: starts/stops fs watcher per project CWD, listens for events, calls recordExternalWrite
+- [x] ProjectHeader: split conflict badge into orange "ext write" badge + red "agent conflict" badge
+- [x] Toast notification on new external write conflict
+
+#### Verification
+- [x] vitest: 202/202 tests pass (+8 new external write tests)
+- [x] cargo test: 39/39 pass (+5 new fs_watcher tests)
+
+### Session: 2026-03-11 — Files Tab: PDF Viewer + CSV Table View
+
+#### PDF Viewer
+- [x] Added pdfjs-dist@5.5.207 dependency (WebKit2GTK has no built-in PDF viewer)
+- [x] Created PdfViewer.svelte — canvas-based multi-page renderer
+- [x] Zoom controls (0.5x–3x, 25% steps), HiDPI-aware (devicePixelRatio scaling)
+- [x] Reads PDF via convertFileSrc() → pdfjs (no new Rust commands needed)
+- [x] Page shadow, themed toolbar, error handling
+
+#### CSV Table View
+- [x] Created CsvTable.svelte — RFC 4180 CSV parser (no external dependency)
+- [x] Auto-detects delimiter (comma, semicolon, tab)
+- [x] Sortable columns (numeric-aware), sticky header, row numbers
+- [x] Row hover, text truncation at 20rem, themed via --ctp-* vars
+
+#### FilesTab Routing
+- [x] Binary+pdf → PdfViewer (via isPdfExt check)
+- [x] Text+csv → CsvTable (via isCsvLang check)
+- [x] Updated file icons: 📕 PDF, 📊 CSV
+- [x] Both viewers are read-only
+
+#### Verification
+- [x] vitest: 202/202 tests pass (no regressions)
+- [x] Vite build: clean
+- [x] cargo check: clean
+
+### Session: 2026-03-11 — S-2 Session Anchors
+
+#### Implementation
+- [x] Created types/anchors.ts — AnchorType, SessionAnchor, AnchorSettings, budget constants
+- [x] Created adapters/anchors-bridge.ts — 5 Tauri IPC functions (save, load, delete, clear, updateType)
+- [x] Created stores/anchors.svelte.ts — Svelte 5 rune store (per-project anchor management)
+- [x] Created utils/anchor-serializer.ts — observation masking, turn grouping, token estimation
+- [x] Created utils/anchor-serializer.test.ts — 17 tests (4 describe blocks)
+- [x] Added session_anchors SQLite table + SessionAnchorRecord struct + 5 CRUD methods (session.rs)
+- [x] Added 5 Tauri commands for anchor persistence (lib.rs)
+- [x] Auto-anchor logic in agent-dispatcher.ts on first compaction event per project
+- [x] Re-injection in AgentPane.startQuery() via system_prompt field
+- [x] Pin button on AgentPane text messages
+- [x] Anchor section in ContextTab: budget meter, promote/demote, remove
+
+#### Verification
+- [x] vitest: 219/219 tests pass (+17 new anchor tests)
+- [x] cargo test: 42/42 pass (+3 new session_anchors tests)
+
+### Session: 2026-03-11 — Configurable Anchor Budget + Truncation Fix
+
+#### Research-backed truncation fix
+- [x] Removed 500-char assistant text truncation in anchor-serializer.ts
+- [x] Research consensus (JetBrains NeurIPS 2025, SWE-agent, OpenDev ACC): reasoning must never be truncated, only tool outputs get masked
+
+#### Configurable anchor budget scale
+- [x] Added AnchorBudgetScale type ('small'|'medium'|'large'|'full') with preset map (2K/6K/12K/20K)
+- [x] Added anchorBudgetScale? field to ProjectConfig (persisted in groups.json)
+- [x] Updated getAnchorSettings() to resolve budget from scale
+- [x] Added 4-stop range slider to SettingsTab per-project settings
+- [x] Updated ContextTab to derive budget from anchorBudgetScale prop
+- [x] Updated agent-dispatcher to look up project's budget scale
+
+#### Cleanup
+- [x] Removed Ollama-specific warning toast from AgentPane (budget slider handles generically)
+- [x] Removed unused notify import from AgentPane
+
+#### Verification
+- [x] vitest: 219/219 tests pass (no regressions)
+- [x] cargo test: 42/42 pass (no regressions)
+
+### Session: 2026-03-11 — S-1 Phase 3: Worktree Isolation Per Project
+
+#### UI toggle
+- [x] Added 'Worktree Isolation' checkbox to SettingsTab per-project card (card-field-row CSS layout)
+- [x] ProjectConfig.useWorktrees? already existed — wired to toggle
+
+#### Spawn with worktree flag
+- [x] Added worktree_name: Option<String> to AgentQueryOptions (Rust sidecar.rs)
+- [x] Added worktree_name?: string to TS AgentQueryOptions (agent-bridge.ts)
+- [x] Sidecar JSON passes worktreeName field to claude-runner.ts
+- [x] claude-runner.ts passes extraArgs: { worktree: name } to SDK query() (maps to --worktree CLI flag)
+- [x] AgentPane: added useWorktrees prop, passes worktree_name=sessionId when enabled
+- [x] AgentSession: passes useWorktrees={project.useWorktrees} to AgentPane
+- [x] Rebuilt sidecar bundle (claude-runner.mjs)
+
+#### CWD-based worktree detection
+- [x] Added detectWorktreeFromCwd() to agent-dispatcher.ts (matches .claude/.codex/.cursor worktree patterns)
+- [x] Init event handler now calls setSessionWorktree() when CWD contains worktree path
+- [x] Dual detection: CWD-based (primary) + tool_call-based extractWorktreePath (subagent fallback)
+
+#### Tests
+- [x] Added 7 new tests to agent-dispatcher.test.ts (detectWorktreeFromCwd unit tests + init CWD integration)
+- [x] vitest: 226/226 tests pass
+- [x] cargo test: 42/42 pass
+
+### Session: 2026-03-11 — Provider Runners (Codex + Ollama)
+
+#### Codex Provider
+- [x] providers/codex.ts — ProviderMeta (gpt-5.4, hasSandbox, supportsResume)
+- [x] adapters/codex-messages.ts — adaptCodexMessage (ThreadEvents → AgentMessage[])
+- [x] sidecar/codex-runner.ts — @openai/codex-sdk wrapper (dynamic import, graceful failure)
+- [x] adapters/codex-messages.test.ts — 19 tests
+
+#### Ollama Provider
+- [x] providers/ollama.ts — ProviderMeta (qwen3:8b, modelSelection only)
+- [x] adapters/ollama-messages.ts — adaptOllamaMessage (streaming chunks → AgentMessage[])
+- [x] sidecar/ollama-runner.ts — Direct HTTP to localhost:11434 (zero deps)
+- [x] adapters/ollama-messages.test.ts — 11 tests
+
+#### Registration + Build
+- [x] App.svelte: register CODEX_PROVIDER + OLLAMA_PROVIDER
+- [x] message-adapters.ts: register codex + ollama adapters
+- [x] package.json: build:sidecar builds all 3 runners
+- [x] vitest: 256/256 tests pass
+- [x] cargo test: 42/42 pass
+
+### 2026-03-11 — Register Memora Adapter
+
+**Duration:** ~15 min
+
+**What happened:**
+Registered a concrete MemoraAdapter that bridges the MemoryAdapter interface to the Memora SQLite database. Direct read-only SQLite access (no MCP/CLI dependency at runtime).
+
+#### Rust Backend
+- [x] memora.rs — MemoraDb struct (read-only SQLite, Option<Connection>, graceful absence)
+- [x] list() with tag filtering via json_each() + IN clause
+- [x] search() via FTS5 MATCH on memories_fts, optional tag join
+- [x] get() by ID
+- [x] 4 Tauri commands: memora_available, memora_list, memora_search, memora_get
+- [x] 7 cargo tests (missing-db error paths)
+
+#### TypeScript Bridge + Adapter
+- [x] memora-bridge.ts — IPC wrappers + MemoraAdapter class implementing MemoryAdapter
+- [x] App.svelte — registers MemoraAdapter on mount with async availability check
+- [x] memora-bridge.test.ts — 16 tests (IPC + adapter)
+
+#### Results
+- [x] vitest: 272/272 tests pass
+- [x] cargo test: 49/49 pass
+
+### 2026-03-11 — Configurable Stall Threshold
+
+**Duration:** ~10 min
+
+**What happened:**
+Made the hardcoded 15-minute stall threshold configurable per-project via a range slider in SettingsTab (5–60 min, step 5).
+
+#### Changes
+- [x] groups.ts — Added `stallThresholdMin?: number` to ProjectConfig
+- [x] health.svelte.ts — Replaced hardcoded constant with per-project `stallThresholds` Map + `setStallThreshold()` API, fallback to DEFAULT_STALL_THRESHOLD_MS (15 min)
+- [x] SettingsTab.svelte — Range slider per project card (5–60 min, step 5, default 15)
+- [x] ProjectBox.svelte — `$effect` syncs `project.stallThresholdMin` → `setStallThreshold()` on mount/change
+
+#### Results
+- [x] No test changes — UI/config wiring only
+- [x] vitest: 272/272 tests pass
+- [x] cargo test: 49/49 pass
+
+### 2026-03-11 — Nemesis Security Audit + Reconnect Loop Fix
+
+**Duration:** ~15 min
+
+**What happened:**
+Ran nemezis-audit on Rust backend. 0 verified exploitable findings, 10 recon targets identified (all previously known from 2026-03-08 security audit). Fixed Priority 8 reconnect loop race condition.
+
+#### Nemesis Audit
+- [x] Ran nemezis orchestrator on v2/src-tauri (Rust backend, 496s, $0.57)
+- [x] 0 verified findings, 10 attack surface targets in recon hit list
+- [x] All targets match previous 2026-03-08 security audit — no new vulnerabilities
+
+#### Reconnect Loop Fix
+- [x] remote.rs — Added `cancelled: Arc<AtomicBool>` to RemoteMachine struct
+- [x] remove_machine() and disconnect() set cancelled=true before aborting tasks
+- [x] connect() resets cancelled=false for new connections
+- [x] Reconnect loop checks flag at top of each iteration, exits immediately when set
+
+#### Results
+- [x] cargo check: clean
+- [x] cargo test: 49/49 pass
+
+### Session 2026-03-11 (SOLID Phase 1 Refactoring)
+
+#### SOLID Analysis
+- [x] Ran /solid on full v2 codebase (TypeScript + Rust)
+- [x] Identified 3 critical, 5 high, 5 medium issues; 8 good-practice modules
+
+#### Phase 1 Refactoring — High-impact, Low-risk
+- [x] **AttentionScorer extraction**: scoreAttention() pure function from health.svelte.ts → utils/attention-scorer.ts (14 tests)
+- [x] **Shared type guards**: str()/num() from 3 adapter copies → utils/type-guards.ts
+- [x] **lib.rs command module split**: 976 → 170 lines, 48 commands → 11 domain modules under commands/
+- [x] Skipped withRemoteSupport() HOF — parameter shapes differ, 3-line duplication doesn't justify abstraction
+
+#### Results
+- [x] vitest: 286/286 pass (14 new attention-scorer tests)
+- [x] cargo check: clean
+- [x] cargo test: 49/49 pass
+
+### Session 2026-03-11 (SOLID Phase 2 Refactoring)
+
+#### agent-dispatcher.ts Split (496→260 lines)
+- [x] Extracted utils/worktree-detection.ts — detectWorktreeFromCwd() pure function (17 lines, 5 tests)
+- [x] Extracted utils/session-persistence.ts — session maps + persistSessionForProject (107 lines)
+- [x] Extracted utils/auto-anchoring.ts — triggerAutoAnchor (48 lines)
+- [x] Extracted utils/subagent-router.ts — spawnSubagentPane + SUBAGENT_TOOL_NAMES (73 lines)
+- [x] Dispatcher is now thin coordinator with re-exports for backward compat
+
+#### session.rs Split (1,008 lines → 7 sub-modules)
+- [x] session/mod.rs — SessionDb struct + open() + migrate() + re-exports (153 lines)
+- [x] session/sessions.rs — Session CRUD (9 tests)
+- [x] session/layout.rs — LayoutState save/load (3 tests)
+- [x] session/settings.rs — Settings CRUD (5 tests)
+- [x] session/ssh.rs — SshSession CRUD (4 tests)
+- [x] session/agents.rs — AgentMessageRecord + ProjectAgentState
+- [x] session/metrics.rs — SessionMetric save/load
+- [x] session/anchors.rs — SessionAnchorRecord CRUD
+- [x] conn field: pub(in crate::session) for sub-module access
+
+#### Results
+- [x] vitest: 286/286 pass (5 worktree tests moved to new file)
+- [x] cargo check: clean
+- [x] cargo test: 49/49 pass
+
+### Session 2026-03-11 (SOLID Phase 3 — Branded Types)
+
+#### Implementation
+- [x] Introduced SessionId/ProjectId branded types (types/ids.ts)
+- [x] Applied branded types to conflicts.svelte.ts and health.svelte.ts Map keys
+- [x] Branded sessionId at sidecar boundary in agent-dispatcher
+- [x] Applied branded types at Svelte component call sites
+
+#### Results
+- [x] cargo check: clean
+- [x] vitest: 286/286 pass
+
+### Session 2026-03-11 — Multi-Agent Orchestration System
+
+#### btmsg Group Agent Messenger CLI
+- [x] Created btmsg CLI tool — inter-agent messaging (inbox, send, reply, contacts, history, channels)
+- [x] btmsg graph command — visual agent hierarchy with status
+- [x] Admin role (tier 0), channel messaging (create/list/send/history), mark-read, global feed
+
+#### btmsg Rust Backend + Tauri Bridge
+- [x] Created btmsg.rs module — SQLite-backed messaging (shared DB: ~/.local/share/bterminal/btmsg.db)
+- [x] 8+ Tauri commands: btmsg_inbox, btmsg_send, btmsg_read, btmsg_contacts, btmsg_feed, btmsg_channels, etc.
+- [x] CommsTab: sidebar chat interface with activity feed, DMs, channels (Ctrl+M)
+
+#### Agent Unification (Tier 1 → ProjectBoxes)
+- [x] agentToProject() converter in groups.ts — Tier 1 agents rendered as full ProjectBoxes
+- [x] getAllWorkItems() in workspace store combines agents + projects for ProjectGrid
+- [x] GroupAgentsPanel: click-to-navigate agent cards to their ProjectBox
+
+#### Agent System Prompts
+- [x] Created utils/agent-prompts.ts — generateAgentPrompt() builds comprehensive introductory context
+  - Sections: Identity, Environment, Team hierarchy, btmsg docs, bttask docs, Custom context, Workflow
+  - Role-specific workflows (Manager: check inbox → review board → coordinate; Architect: code review focus; Tester: write/run tests)
+- [x] AgentSession builds system prompt: Tier 1 gets full generated prompt, Tier 2 gets custom context
+
+#### BTMSG_AGENT_ID Environment Passthrough (5-layer chain)
+- [x] agent-bridge.ts: added extra_env?: Record<string,string> to AgentQueryOptions
+- [x] bterminal-core/sidecar.rs: added extra_env: HashMap<String,String> with #[serde(default)]
+- [x] claude-runner.ts: extraEnv merged into cleanEnv after provider var stripping
+- [x] codex-runner.ts: same extraEnv pattern
+- [x] AgentSession injects { BTMSG_AGENT_ID: project.id } for agent projects
+
+#### Tier 1 Agent Config in SettingsTab
+- [x] Agent cards: icon + name + role badge + enable toggle + CWD + model + wake interval (manager)
+- [x] Custom Context textarea per agent (appended to auto-generated prompt)
+- [x] Collapsible preview of full generated introductory prompt
+- [x] updateAgent() function in workspace store for Tier 1 config persistence
+
+#### Custom Context for Tier 2 Projects
+- [x] Custom Context textarea in SettingsTab project cards
+- [x] Stored as project.systemPrompt, passed through AgentSession → AgentPane
+
+#### Periodic System Prompt Re-injection
+- [x] AgentSession: 1-hour timer (REINJECTION_INTERVAL_MS = 3,600,000ms)
+- [x] Checks every 60s if elapsed > 1 hour, sets contextRefreshPrompt
+- [x] AgentPane: autoPrompt prop consumed only when agent is idle (done/error state)
+- [x] Different refresh messages: Tier 1 (check inbox + task board), Tier 2 (review instructions)
+
+#### bttask Kanban Backend + UI
+- [x] Created bttask.rs — Task/TaskComment structs, 6 operations (list, comments, update_status, create, delete, add_comment)
+- [x] Created commands/bttask.rs — 6 Tauri commands registered in lib.rs
+- [x] Created bttask-bridge.ts — TypeScript IPC adapter
+- [x] Created TaskBoardTab.svelte — Kanban board with 5 columns (todo/progress/review/done/blocked)
+  - Task creation form (title, description, priority)
+  - Expandable task detail with status actions, comments, delete
+  - 5-second polling
+  - Pending count badge
+
+#### ArchitectureTab (PlantUML Diagrams)
+- [x] Created ArchitectureTab.svelte — PlantUML diagram viewer/editor
+  - Sidebar with diagram list + new diagram form (4 templates: Class, Sequence, State, Component)
+  - PlantUML source editor + SVG preview via plantuml.com server (~h hex encoding)
+  - Stores .puml files in .architecture/ directory
+  - Read/write via files-bridge.ts
+
+#### TestingTab (Selenium + Automated Tests)
+- [x] Created TestingTab.svelte — dual-mode component
+  - Selenium mode: screenshot gallery (.selenium/screenshots/), session log viewer, 3s polling
+  - Tests mode: discovers test files in standard dirs (tests/, test/, spec/, __tests__/, e2e/), file content viewer
+
+#### Role-Specific Tabs in ProjectBox
+- [x] Extended ProjectTab type: added 'tasks' | 'architecture' | 'selenium' | 'tests'
+- [x] Conditional tab buttons: Manager→Tasks, Architect→Arch, Tester→Selenium+Tests
+- [x] PERSISTED-LAZY rendering via {#if everActivated[tab]} pattern
+- [x] .ptab-role CSS class (mauve accent color for agent-specific tabs)
+
+#### Bug Fix
+- [x] Fixed FileContent type case: 'text' → 'Text' in ArchitectureTab and TestingTab (files-bridge uses capital T)
+
+#### Verification
+- [x] cargo check: clean (bttask module + commands)
+- [x] svelte-check: 0 project errors
+- [x] Sidecar rebuilt with extraEnv support
+
+### Night Integration Session — Bug Fixes for dexter_changes (2026-03-11)
+
+Reviewed and integrated Dexter's multi-agent orchestration branch (dexter_changes, ~6,500 lines, 36 files). Fast-forward merged. Fixed 5 critical bugs + 2 hardening improvements.
+
+#### Critical Bug Fixes
+- [x] **Bug 1 — btmsg.rs column index mismatch**: `get_agents()` used `SELECT a.*` with positional index 7 for `status`, but column 7 is `system_prompt` (column 8 is `status`). Converted ALL query functions in btmsg.rs and bttask.rs from positional to named column access (`row.get("column_name")`). Added SQL aliases for JOIN columns.
+- [x] **Bug 2 — btmsg-bridge.ts serde camelCase mismatch**: `BtmsgAgent` and `BtmsgMessage` TypeScript interfaces used snake_case (`group_id`, `unread_count`, `from_agent`) but Rust `#[serde(rename_all = "camelCase")]` sends camelCase. Fixed interfaces to match wire format.
+- [x] **Bug 3 — GroupAgentsPanel event propagation**: toggleAgent button click propagated to parent card click handler (setActiveProject). Added `e.stopPropagation()`.
+- [x] **Bug 4 — ArchitectureTab PlantUML encoding**: `rawDeflate()` was a no-op, `encode64()` did hex encoding. Collapsed into single `plantumlEncode()` using PlantUML's `~h` hex encoding.
+- [x] **Bug 5 — TestingTab Tauri 2.x asset URL**: Used `asset://localhost/` (Tauri 1.x pattern). Fixed to `convertFileSrc()` from `@tauri-apps/api/core`.
+
+#### Hardening
+- [x] Added WAL mode + 5s busy_timeout to both btmsg.rs and bttask.rs `open_db()` for safe concurrent access from Python CLIs + Rust backend
+- [x] Fixed misleading "Read-only access" comment in btmsg.rs (it opens READ_WRITE)
+
+#### Verification
+- [x] cargo check: clean
+- [x] svelte-check: 0 project errors (2 pre-existing in node_modules/esrap)
+
+### Regression Tests + Sidecar Security Session (2026-03-11 night, continued)
+
+#### Regression Tests (49 new tests total)
+- [x] **btmsg.rs cargo tests (8)**: In-memory SQLite with full schema, verifies named column access returns status (not system_prompt), unread counts, JOIN alias disambiguation (all_feed, unread_messages, channel_messages), serde camelCase serialization
+- [x] **bttask.rs cargo tests (7)**: Named column access (list_tasks, task_comments), serde camelCase serialization, status validation
+- [x] **sidecar strip_provider_env_var tests (8)**: All prefix combinations (CLAUDE, CODEX, OLLAMA, ANTHROPIC stripped; CLAUDE_CODE_EXPERIMENTAL whitelisted; OPENAI kept), integration test with full env simulation
+- [x] **btmsg-bridge.test.ts (17)**: camelCase field verification for all 5 interfaces, IPC command names, error propagation
+- [x] **bttask-bridge.test.ts (10)**: camelCase field verification (Task, TaskComment), IPC command names
+- [x] **plantuml-encode.test.ts (7)**: ~h hex prefix, ASCII/Unicode encoding, URL safety, plantuml.com URL generation
+- [x] Fixed pre-existing groups.rs test (missing `agents` field from Dexter's schema change)
+
+#### Security: Sidecar Env Allowlist
+- [x] Added ANTHROPIC_* to Rust-level strip_provider_env_var() — defense-in-depth (Claude CLI uses credentials file, not env var for auth)
+- [x] OPENAI_* intentionally NOT stripped at Rust level (Codex runner needs OPENAI_API_KEY from env)
+- [x] Documented dual-layer stripping design in code comments
+
+#### Test Counts
+- Vitest: 327 passed (was 286, +41)
+- Cargo src-tauri: 64 passed (was 49, +15)
+- Cargo bterminal-core: 8 passed (was 0, +8)
+
+### E2E Testing Engine — Phase A (2026-03-12)
+
+#### Test Mode Infrastructure
+- [x] Rust: watcher.rs — test mode bypass (skip file watching, return content directly)
+- [x] Rust: fs_watcher.rs — test mode bypass (skip inotify watchers)
+- [x] Rust: commands/misc.rs — added `is_test_mode` Tauri command
+- [x] Rust: lib.rs — registered is_test_mode in invoke handler
+- [x] Frontend: wake-scheduler.svelte.ts — `disableWakeScheduler()` export + early return
+- [x] Frontend: App.svelte — test mode detection via IPC, disables wake scheduler
+
+#### E2E Test Anchors (data-testid attributes)
+- [x] AgentPane: data-testid="agent-pane", data-agent-status, agent-messages, agent-stop, agent-prompt, agent-submit
+- [x] ProjectBox: data-testid="project-box", data-project-id, project-tabs, terminal-toggle
+- [x] StatusBar: data-testid="status-bar"
+- [x] AgentSession: data-testid="agent-session"
+- [x] GlobalTabBar: data-testid="sidebar-rail", settings-btn
+- [x] CommandPalette: data-testid="command-palette", palette-input
+- [x] TerminalTabs: data-testid="terminal-tabs", tab-add
+
+#### WebDriverIO Config Improvements
+- [x] TCP readiness probe replaces blind 2s sleep for tauri-driver startup
+- [x] BTERMINAL_TEST=1 env var passed to Tauri app via capabilities
+- [x] Optional BTERMINAL_TEST_DATA_DIR / BTERMINAL_TEST_CONFIG_DIR passthrough
+
+#### Test Infrastructure Files
+- [x] `v2/tests/e2e/fixtures.ts` — isolated test fixture generator (temp dirs, git repos, groups.json)
+- [x] `v2/tests/e2e/results-db.ts` — JSON-based test results store (no native deps)
+- [x] `v2/tests/e2e/specs/agent-scenarios.test.ts` — 7 Phase A scenarios (22 test cases)
+
+#### Phase A Scenarios (7 scenarios, 22 tests)
+1. **App Structural Integrity** — verifies all data-testid anchors render correctly
+2. **Settings Panel (data-testid)** — open/close settings via stable selector
+3. **Agent Pane Initial State** — idle status, prompt textarea, empty messages
+4. **Terminal Tab Management** — add/close tabs via data-testid, empty state
+5. **Command Palette (data-testid)** — open, focus, filter, close
+6. **Project Focus & Tab Switching** — focus, tab persistence, agent status preservation
+7. **Agent Prompt Submission** — textarea input, submit button state, graceful Claude CLI skip
+
+#### Verification
+- [x] cargo test: 68 passed, 0 failed
+- [x] vitest: 345 passed across 18 files, 0 failed
+- [x] svelte-check: 0 project errors (2 pre-existing esrap node_modules)
+
+#### Test Counts
+- Vitest: 345 passed (was 327, +18 — new wake-scorer + metrics tests from prior session)
+- Cargo src-tauri: 68 passed (was 64, +4)
+- E2E scenarios: 22 new test cases across 7 scenarios
+
+### Session: 2026-03-12 — E2E Testing Engine Phase B+
+
+#### LLM Judge Helper
+- [x] Created `v2/tests/e2e/llm-judge.ts` — Claude API-based test assertion judge
+  - Raw fetch to Anthropic API (zero new deps), uses claude-haiku-4-5 for speed/cost
+  - `judge()` evaluates actual output against criteria, returns structured verdict (pass/fail, reasoning, confidence)
+  - `assertWithJudge()` convenience with minimum confidence threshold (default 0.7)
+  - `isJudgeAvailable()` check — tests skip gracefully when ANTHROPIC_API_KEY absent
+
+#### Phase B Scenarios (6 scenarios, ~15 tests)
+- [x] Created `v2/tests/e2e/specs/phase-b.test.ts`
+  - **B1: Multi-Project Grid** — renders multiple project boxes, unique IDs, independent agent panes, CWD paths, focus/active styling
+  - **B2: Independent Tab Switching** — different tabs active in different project boxes simultaneously
+  - **B3: Status Bar Fleet State** — agent count display, burn rate $0.00 when all idle
+  - **B4: LLM-Judged Agent Response** — sends file listing prompt, evaluates response quality + tool usage via LLM judge (requires ANTHROPIC_API_KEY)
+  - **B5: LLM-Judged Code Generation** — sends code explanation prompt, evaluates correctness via LLM judge
+  - **B6: Context Tab After Activity** — verifies context tab shows token usage data after agent activity
+- [x] Per-project helper functions: focusProject(), getAgentStatus(), sendPromptInProject(), waitForProjectAgentStatus(), getAgentMessages(), switchProjectTab()
+- [x] All LLM-judged tests skip gracefully when ANTHROPIC_API_KEY not set
+- [x] Added phase-b.test.ts to wdio.conf.js specs array
+
+#### CI Workflow
+- [x] Created `.github/workflows/e2e.yml`
+  - Triggers: push to v2-mission-control, PRs to master/v2-mission-control, manual dispatch
+  - Path filters: v2/src/**, v2/src-tauri/**, v2/tests/e2e/**
+  - 3 jobs: unit-tests (vitest), cargo-tests, e2e-tests (needs both)
+  - E2E job: installs xvfb + tauri-driver, builds debug binary, runs Phase A + Phase B specs
+  - LLM-judged tests gated on ANTHROPIC_API_KEY secret availability
+  - Uploads test-results/ artifact on all outcomes
+
+#### Verification
+- [x] Vitest: 388 passed, 0 failed (was 345, +43 from prior sessions)
+- [x] Cargo: 68 passed, 0 failed
+- [x] No regressions
+
+---
+
+### Session: v3 Production Readiness — Tribunal Implementation (2026-03-12)
+
+Implemented ALL 13 features from tribunal assessment in 3 parallel waves (11 sub-agents total). 60+ files changed, 3861 insertions.
+
+#### Wave 1: Core Infrastructure (3 agents)
+- [x] **Sidecar supervisor** — `bterminal-core/src/supervisor.rs`: SidecarSupervisor with exponential backoff (1s-30s, 5 retries), SidecarHealth enum, 5min stability window, 17 tests
+- [x] **FTS5 search** — rusqlite `bundled-full`, SearchDb with 3 FTS5 virtual tables, SearchOverlay.svelte (Ctrl+Shift+F), search-bridge.ts
+- [x] **Secrets management** — `keyring` crate (linux-native/libsecret), SecretsManager, secrets-bridge.ts, SettingsTab section
+
+#### Wave 2: Features (5 agents)
+- [x] **Notification system** — notify-rust + NotificationCenter.svelte (bell icon, history, 6 types), notifications-bridge.ts
+- [x] **Keyboard-first UX** — Alt+1-5 jump, Ctrl+H/L vi-nav, Ctrl+Shift+1-9 tabs, Ctrl+J terminal, CommandPalette rewrite (18+ cmds, 6 categories)
+- [x] **Agent health monitoring** — heartbeats + dead_letter_queue tables, 15s poll, ProjectHeader heart indicator, StatusBar badge
+- [x] **Plugin system** — plugins.rs discovery, plugin-host.ts sandboxed runtime, plugins.svelte.ts store, example plugin
+- [x] **Landlock sandbox** — bterminal-core/src/sandbox.rs, SandboxConfig, pre_exec() integration, per-project toggle
+
+#### Wave 3: Integration (3 agents)
+- [x] **Error classification** — error-classifier.ts (6 types, retry logic), 20 tests
+- [x] **Audit log** — audit_log table, AuditLogTab.svelte, audit-bridge.ts
+- [x] **Team agent orchestration** — install_cli_tools(), register_agents_from_groups(), bidirectional contacts, review channels
+- [x] **Optimistic locking** — version column in bttask, conflict detection in Rust + Python CLI
+- [x] **Usage meter** — UsageMeter.svelte, AgentPane integration
+
+#### Key Fixes
+- PRAGMA journal_mode=WAL: changed to query_row for bundled-full compatibility (session/mod.rs, btmsg.rs, bttask.rs)
+- SidecarConfig: changed to `Mutex<SidecarConfig>` for interior mutability (sandbox updates)
+- New Cargo deps: notify-rust 4, keyring 3 (linux-native), landlock 0.4
+
+#### Verification
+- [x] Vitest: 409 passed, 0 failed (+21 from prior)
+- [x] Cargo: 109 passed, 0 failed (+41 from prior)
+- [x] No regressions
+
+---
+
+### Session: v3 Hardening Sprint (2026-03-12)
+
+Executed tribunal-recommended hybrid S-2/S-1 hardening sprint. Fixed 3 security/resilience issues, added TLS, fixed gitignore bug.
+
+#### Subagent Delegation Fix
+- [x] Root cause: Manager system prompt had no mention of Agent tool / delegation capability
+- [x] Added "Multi-Agent Delegation" section to Manager workflow in `agent-prompts.ts`
+- [x] Inject `CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1` env var for Manager agents in `AgentSession.svelte`
+
+#### TLS for bterminal-relay
+- [x] Added `--tls-cert` and `--tls-key` optional CLI args to relay binary
+- [x] `build_tls_acceptor()` using `native_tls::Identity::from_pkcs8`
+- [x] Refactored to generic `accept_ws_with_auth<S>` and `run_ws_session<S>` (avoids code duplication)
+- [x] Client side already supports `wss://` via `connect_async` with native-tls feature — no changes needed
+- [x] Certificate pinning deferred to v3.1 per tribunal risk matrix
+
+#### Security Hardening
+- [x] **WAL checkpoint** — `checkpoint_wal()` + `spawn_wal_checkpoint_task()` in lib.rs. Runs `PRAGMA wal_checkpoint(TRUNCATE)` every 5 minutes on sessions.db + btmsg.db. 2 tests
+- [x] **Landlock logging** — Improved fallback message: "Kernel 6.2+ required for enforcement" + 3-state enforcement comments
+- [x] **Plugin sandbox** — Already hardened (13 shadowed globals, `this` binding to undefined). Documented known `new Function()` escape vectors in JSDoc
+
+#### Gitignore Fix
+- [x] Root `.gitignore` had `plugins/` which matched `v2/src/lib/plugins/` (source code). Narrowed to `/plugins/` and `/v2/plugins/` (runtime dirs only)
+- [x] Tracked previously-ignored `plugin-host.ts` source file
+- [x] Added `plugin-host.test.ts` with 35 tests (sandbox globals, permissions, lifecycle)
+
+#### Verification
+- [x] Vitest: 444 passed, 0 failed (+35 plugin sandbox tests)
+- [x] Cargo: 111 passed, 0 failed (+2 WAL checkpoint tests)
+- [x] Full workspace compiles clean
diff --git a/docs/v3-release-notes.md b/docs/v3-release-notes.md
new file mode 100644
index 0000000..db626f6
--- /dev/null
+++ b/docs/v3-release-notes.md
@@ -0,0 +1,110 @@
+# BTerminal v3.0 Release Notes
+
+## Mission Control — Multi-Project AI Agent Orchestration
+
+BTerminal v3.0 is a ground-up redesign of the terminal interface, built for managing multiple AI agent sessions across multiple projects simultaneously. The Mission Control dashboard replaces the single-pane terminal with a full orchestration workspace.
+
+### What's New
+
+**Mission Control Dashboard**
+- VSCode-style layout: icon sidebar + expandable settings drawer + project grid + status bar
+- Per-project boxes with 11 tab types (Model, Docs, Context, Files, SSH, Memory, Metrics, Tasks, Architecture, Selenium, Tests)
+- Command palette (Ctrl+K) with 18+ commands across 6 categories
+- Keyboard-first navigation: Alt+1-5 project jump, Ctrl+H/L vi-nav, Ctrl+Shift+1-9 tab switch
+- 17 themes in 3 groups (Catppuccin, Editor, Deep Dark)
+
+**Multi-Agent Orchestration**
+- 4 Tier 1 management roles: Manager, Architect, Tester, Reviewer
+- btmsg: inter-agent messaging (DMs, channels, contacts ACL, heartbeats, dead letter queue)
+- bttask: kanban task board (5 columns, optimistic locking, review queue auto-notifications)
+- Agent prompt generator with role-specific workflows and tool documentation
+- Manager subagent delegation via Claude Agent SDK teams
+- Auto-wake scheduler: 3 strategies (persistent, on-demand, smart) with 6 wake signals
+
+**Multi-Provider Support**
+- Claude Code (primary), OpenAI Codex, Ollama
+- Provider-specific sidecar runners with unified message adapter layer
+- Per-project provider selection with capability-gated UI
+
+**Session Continuity**
+- SQLite persistence for agent sessions, messages, and cost tracking
+- Session anchors: preserve important turns through context compaction
+- Auto-anchoring on first compaction (observation-masked, reasoning preserved)
+- Configurable anchor budget (2K–20K tokens)
+
+**Dashboard Metrics**
+- Real-time fleet overview: running/idle/stalled counts, burn rate ($/hr)
+- Per-project health: activity state, context pressure, file conflicts, attention scoring
+- Historical sparklines for cost, tokens, turns, tools, and duration
+- Attention queue with priority-scored cards (click to focus)
+
+**File Management**
+- VSCode-style directory tree with CodeMirror 6 editor (15 language modes)
+- PDF viewer (pdfjs-dist, multi-page, zoom 0.5x–3x)
+- CSV table viewer (RFC 4180, delimiter auto-detect, sortable columns)
+- Filesystem watcher for external write conflict detection
+
+**Terminal**
+- xterm.js with Canvas addon (WebKit2GTK compatible)
+- Agent preview pane (read-only view of agent activity)
+- SSH session management (native PTY, no library required)
+- Worktree isolation per project (optional)
+
+### Production Readiness
+
+**Reliability**
+- Sidecar crash recovery: auto-restart with exponential backoff (1s–30s, 5 retries)
+- WAL checkpoint: periodic TRUNCATE every 5 minutes (sessions.db + btmsg.db)
+- Error classification: 6 types with actionable messages and retry logic
+- Optimistic locking for concurrent task board updates
+
+**Security**
+- Landlock sandbox: kernel 6.2+ filesystem restriction for sidecar processes
+- Plugin sandbox: 13 shadowed globals, strict mode, frozen API, permission-gated
+- Secrets management: system keyring (libsecret), no plaintext fallback
+- TLS support for bterminal-relay (optional `--tls-cert`/`--tls-key`)
+- Sidecar environment stripping: dual-layer (Rust + JS) credential isolation
+- Audit logging: agent events, task changes, wake events, prompt injections
+
+**Observability**
+- OpenTelemetry: tracing + OTLP export to Tempo (optional)
+- FTS5 full-text search across messages, tasks, and agent comms
+- Agent health monitoring: heartbeats, stale detection, dead letter queue
+- Desktop + in-app notifications with history
+
+### Multi-Machine (Early Access)
+
+bterminal-relay enables running agent sessions across multiple Linux machines via WebSocket. TLS encryption is supported. This feature is architecturally complete but not yet surfaced in the v3 UI — available for advanced users via the relay binary and bridges.
+
+**v3.1 roadmap:** Certificate pinning, UI integration, real-world multi-machine testing.
+
+### Test Coverage
+
+| Suite | Tests | Status |
+|-------|-------|--------|
+| Vitest (frontend) | 444 | Pass |
+| Cargo (backend) | 151 | Pass |
+| E2E (WebDriverIO) | 109 | Pass |
+| **Total** | **704** | **All passing** |
+
+### Breaking Changes from v2
+
+- Layout system replaced by workspace store (project groups)
+- Configuration moved from sessions.json to groups.json
+- App.svelte rewritten (VSCode-style sidebar replaces TilingGrid)
+- Settings moved from modal dialog to sidebar drawer tab
+
+### Requirements
+
+- Linux x86_64
+- Kernel 6.2+ recommended (for Landlock sandbox enforcement)
+- libsecret / DBUS session (for secrets management)
+- Node.js 20+ and Rust 1.77+ (build from source)
+- Claude CLI installed (`~/.local/bin/claude` or system path)
+
+### Known Limitations
+
+- Maximum 4 active xterm.js instances (WebKit2GTK memory constraint)
+- Plugin sandbox uses `new Function()` — best-effort, not a security boundary
+- Multi-machine UI not yet integrated into Mission Control
+- Agent Teams delegation requires complex prompts to trigger reliably
diff --git a/docs/v3-task_plan.md b/docs/v3-task_plan.md
new file mode 100644
index 0000000..b140aa1
--- /dev/null
+++ b/docs/v3-task_plan.md
@@ -0,0 +1,348 @@
+# BTerminal v3 — Mission Control Redesign
+
+## Goal
+
+Transform BTerminal from a multi-pane terminal/agent tool into a **multi-project mission control** — a helm for managing multiple development projects simultaneously, each with its own Claude agent session, team agents, terminals, and settings.
+
+## Status: All Phases Complete (1-10) — Rev 3 (Sidebar Redesign)
+
+---
+
+## Core Concept
+
+**Project Groups** are workspaces. Each group has up to 5 projects arranged horizontally. One group visible at a time. Projects have their own Claude subscription, working directory, icon, and settings. The app is a dashboard for orchestrating Claude agents across a portfolio of projects.
+
+### Key Mental Model
+
+```
+BTerminal v2: Terminal emulator with agent sessions (panes in a grid)
+BTerminal v3: Project orchestration dashboard (projects in a workspace)
+```
+
+### User Requirements
+
+1. Projects arranged in **project groups** (many groups, switch between them)
+2. Each group has **up to 5 projects** shown horizontally
+3. Group/project config via **main menu** (command palette / hidden drawer, Ctrl+K)
+4. Per-project settings: Claude subscription, working dir, icon (nerd font), name, identifier, description, enabled
+5. Project group = workspace on screen
+6. Each project box: Claude session (default, resume previous) + team agents (right) + terminal tabs (below)
+7. **VSCode-style left sidebar**: Vertical icon rail (Sessions/Docs/Context/Settings) + expandable drawer panel + always-visible workspace
+8. App launchable with `--group <name>` CLI arg
+9. JSON config file defines all groups (`~/.config/bterminal/groups.json`)
+10. Session continuity: resume previous + restore history visually
+11. SSH sessions: spawnable within a project's terminal tabs
+12. ctx viewer: workspace tab #3
+
+---
+
+## Architecture (Post-Adversarial Review)
+
+### Adversarial Review Summary
+
+3 agents reviewed the architecture: Architect (advocate), Devil's Advocate (attacker), UX+Performance Specialist.
+
+**12 issues identified by Devil's Advocate. Resolutions:**
+
+| # | Issue | Severity | Resolution |
+|---|---|---|---|
+| 1 | xterm.js 4-instance ceiling (WebKit2GTK OOM) | Critical | Lazy-init + scrollback serialization. Budget: 4 active xterm, unlimited suspended (text buffer). Enforced in code. |
+| 2 | Single sidecar = SPOF for all projects | Critical | Accept for v3.0 (existing crash recovery). Per-project pool deferred to v3.1 if needed. |
+| 3 | Session identity collision (sdkSessionId not persisted) | Major | Persist sdkSessionId in SQLite `project_agent_state` table. Per-project CLAUDE_CONFIG_DIR isolation. |
+| 4 | Layout store has no workspace concept | Critical | Full rewrite: `workspace.svelte.ts` replaces `layout.svelte.ts`. |
+| 5 | 384px per project unusable on 1920px | Major | Adaptive: compute visible count from viewport width (`Math.floor(width / 520)`). 5@5120px, 3@1920px, scroll-snap for rest. min-width 480px. |
+| 6 | JSON config + SQLite = split-brain | Major | JSON for groups/projects config (human-editable). SQLite for session state. JSON loaded at startup only, no hot-reload. |
+| 7 | Agent dispatcher is global singleton, no project scoping | Major | Add projectId to AgentSession. Dispatcher routes by project. Per-project cleanup on workspace switch. |
+| 8 | Markdown discovery undefined | Minor | Priority list: CLAUDE.md, README.md, docs/*.md (max 20). Rust command scans with depth limit. |
+| 9 | Keyboard shortcut conflicts (3 layers) | Major | Shortcut manager: Terminal layer (focused only), Workspace layer (Ctrl+1-5), App layer (Ctrl+K, Ctrl+G). |
+| 10 | Remote machine support orphaned | Major | Elevate to project level (project.remote_machine_id). Defer integration to v3.1. |
+| 11 | No graceful degradation for broken projects | Major | Project health state: healthy/degraded/unavailable/error. Colored dot indicator. |
+| 12 | Flat event stream wastes CPU for hidden projects | Minor | Buffer messages for inactive workspace projects. Flush on activation. |
+
+---
+
+## Data Model
+
+### Project Group Config (`~/.config/bterminal/groups.json`)
+
+```jsonc
+{
+  "version": 1,
+  "groups": [
+    {
+      "id": "work-ai",
+      "name": "AI Projects",
+      "projects": [
+        {
+          "id": "bterminal",
+          "name": "BTerminal",
+          "identifier": "bterminal",
+          "description": "Terminal emulator with Claude integration",
+          "icon": "\uf120",
+          "cwd": "/home/hibryda/code/ai/BTerminal",
+          "profile": "default",
+          "enabled": true
+        }
+      ]
+    }
+  ],
+  "activeGroupId": "work-ai"
+}
+```
+
+### TypeScript Types (`v2/src/lib/types/groups.ts`)
+
+```typescript
+export interface ProjectConfig {
+  id: string;
+  name: string;
+  identifier: string;
+  description: string;
+  icon: string;
+  cwd: string;
+  profile: string;
+  enabled: boolean;
+}
+
+export interface GroupConfig {
+  id: string;
+  name: string;
+  projects: ProjectConfig[];  // max 5
+}
+
+export interface GroupsFile {
+  version: number;
+  groups: GroupConfig[];
+  activeGroupId: string;
+}
+```
+
+### SQLite Schema Additions
+
+```sql
+ALTER TABLE sessions ADD COLUMN project_id TEXT DEFAULT '';
+
+CREATE TABLE IF NOT EXISTS agent_messages (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    session_id TEXT NOT NULL,
+    project_id TEXT NOT NULL,
+    sdk_session_id TEXT,
+    message_type TEXT NOT NULL,
+    content TEXT NOT NULL,
+    parent_id TEXT,
+    created_at INTEGER NOT NULL,
+    FOREIGN KEY (session_id) REFERENCES sessions(id) ON DELETE CASCADE
+);
+CREATE INDEX idx_agent_messages_session ON agent_messages(session_id);
+CREATE INDEX idx_agent_messages_project ON agent_messages(project_id);
+
+CREATE TABLE IF NOT EXISTS project_agent_state (
+    project_id TEXT PRIMARY KEY,
+    last_session_id TEXT NOT NULL,
+    sdk_session_id TEXT,
+    status TEXT NOT NULL,
+    cost_usd REAL DEFAULT 0,
+    input_tokens INTEGER DEFAULT 0,
+    output_tokens INTEGER DEFAULT 0,
+    last_prompt TEXT,
+    updated_at INTEGER NOT NULL
+);
+```
+
+---
+
+## Component Architecture
+
+### Component Tree
+
+```
+App.svelte                              [REWRITTEN — VSCode-style sidebar]
+├── CommandPalette.svelte               [NEW]
+├── GlobalTabBar.svelte                 [NEW] Vertical icon rail (36px, 4 SVG icons)
+├── [Sidebar Panel]                      Expandable drawer (28em, max 50%)
+│   ├── [Tab: Sessions] ProjectGrid    [renders in sidebar when open]
+│   ├── [Tab: Docs] DocsTab
+│   ├── [Tab: Context] ContextPane
+│   └── [Tab: Settings] SettingsTab
+├── [Main Workspace]                     Always visible
+│   └── ProjectGrid.svelte             [NEW] Horizontal flex + scroll-snap
+│       └── ProjectBox.svelte           [NEW] Per-project container
+│           ├── ProjectHeader.svelte    [NEW] Icon + name + status dot
+│           ├── ClaudeSession.svelte    [NEW, from AgentPane] Main session
+│           ├── TeamAgentsPanel.svelte  [NEW] Right panel for subagents
+│           │   └── AgentCard.svelte    [NEW] Compact subagent view
+│           └── TerminalTabs.svelte     [NEW] Tabbed terminals
+│               └── TerminalPane.svelte [SURVIVES]
+├── StatusBar.svelte                    [MODIFIED]
+└── ToastContainer.svelte               [SURVIVES]
+```
+
+### What Dies
+
+| v2 Component/Store | Reason |
+|---|---|
+| TilingGrid.svelte | Replaced by ProjectGrid |
+| PaneContainer.svelte | Fixed project box structure |
+| SessionList.svelte (sidebar) | No sidebar; project headers replace |
+| SshSessionList.svelte | Absorbed into TerminalTabs |
+| SettingsDialog.svelte | Replaced by SettingsTab |
+| AgentPane.svelte | Split into ClaudeSession + TeamAgentsPanel |
+| layout.svelte.ts | Replaced by workspace.svelte.ts |
+| layout.test.ts | Replaced by workspace tests |
+
+### What Survives
+
+TerminalPane, MarkdownPane, AgentTree, ContextPane, StatusBar, ToastContainer, theme store, notifications store, agents store (modified), all adapters (agent-bridge, pty-bridge, claude-bridge, sdk-messages, session-bridge, ctx-bridge, ssh-bridge), all Rust backend (sidecar, pty, session, ctx, watcher), highlight utils.
+
+---
+
+## Layout System
+
+### Project Grid (Flexbox + scroll-snap)
+
+```css
+.project-grid {
+  display: flex;
+  gap: 4px;
+  height: 100%;
+  overflow-x: auto;
+  scroll-snap-type: x mandatory;
+}
+
+.project-box {
+  flex: 0 0 calc((100% - (N-1) * 4px) / N);
+  scroll-snap-align: start;
+  min-width: 480px;
+}
+```
+
+N computed from viewport: `Math.min(projects.length, Math.max(1, Math.floor(containerWidth / 520)))`
+
+### Project Box Internal Layout
+
+```
+┌─ ProjectHeader (28px) ──────────────────┐
+├─────────────────────┬───────────────────┤
+│ ClaudeSession       │ TeamAgentsPanel   │
+│ (flex: 1)           │ (240px or overlay)│
+├─────────────────────┴───────────────────┤
+│ [Tab1] [Tab2] [+]           TabBar 26px │
+├─────────────────────────────────────────┤
+│ Terminal content (xterm or scrollback)  │
+└─────────────────────────────────────────┘
+```
+
+Team panel: inline at >2560px, overlay at <2560px. Collapsed when no subagents.
+
+### Responsive Breakpoints
+
+| Width | Visible Projects | Team Panel |
+|-------|-----------------|------------|
+| 5120px+ | 5 | inline 240px |
+| 3840px | 4 | inline 200px |
+| 2560px | 3 | overlay |
+| 1920px | 3 | overlay |
+| <1600px | 1 + project tabs | overlay |
+
+### xterm.js Budget: 4 Active Instances
+
+| State | xterm? | Memory |
+|-------|--------|--------|
+| Active-Focused | Yes | ~20MB |
+| Active-Background | Yes (if budget allows) | ~20MB |
+| Suspended | No (HTML pre scrollback) | ~200KB |
+| Uninitialized | No (placeholder) | 0 |
+
+On focus: serialize least-recent xterm scrollback, destroy it, create new for focused tab, reconnect PTY.
+
+### Project Accent Colors (Catppuccin)
+
+| Slot | Color | Variable |
+|------|-------|----------|
+| 1 | Blue | --ctp-blue |
+| 2 | Green | --ctp-green |
+| 3 | Mauve | --ctp-mauve |
+| 4 | Peach | --ctp-peach |
+| 5 | Pink | --ctp-pink |
+
+---
+
+## Sidecar Strategy
+
+**Single shared sidecar** (unchanged from v2). Per-project isolation via:
+- `cwd` per query (already implemented)
+- `claude_config_dir` per query (already implemented)
+- `session_id` routing (already implemented)
+
+No sidecar changes needed for v3.0.
+
+---
+
+## Keyboard Shortcuts
+
+| Shortcut | Action | Layer |
+|----------|--------|-------|
+| Ctrl+K | Command palette | App |
+| Ctrl+G | Switch group (palette filtered) | App |
+| Ctrl+1..5 | Focus project by index | App |
+| Alt+1..4 | Switch sidebar tab + open drawer | App |
+| Ctrl+B | Toggle sidebar open/closed | App |
+| Ctrl+, | Toggle settings panel | App |
+| Escape | Close sidebar drawer | App |
+| Ctrl+N | New terminal in focused project | Workspace |
+| Ctrl+Shift+N | New agent query | Workspace |
+| Ctrl+Tab | Next terminal tab | Project |
+| Ctrl+W | Close terminal tab | Project |
+| Ctrl+Shift+C/V | Copy/paste in terminal | Terminal |
+
+---
+
+## Implementation Phases
+
+All 10 phases complete. Detailed checklists in [v3-progress.md](v3-progress.md).
+
+| Phase | Scope | Status |
+|-------|-------|--------|
+| 1 | Data Model + Config (groups.rs, workspace store, SQLite migrations) | Complete |
+| 2 | Project Box Shell (GlobalTabBar, ProjectGrid/Box/Header, App.svelte, sidebar redesign 2026-03-08) | Complete |
+| 3 | Claude Session Integration (ClaudeSession.svelte wraps AgentPane) | Complete |
+| 4 | Terminal Tabs (TerminalTabs.svelte, per-project tabbed terminals) | Complete |
+| 5 | Team Agents Panel (TeamAgentsPanel, AgentCard) — **MVP boundary** | Complete |
+| 6 | Session Continuity (persist/restore agent messages, sdkSessionId) | Complete |
+| 7 | Command Palette + Group Switching (workspace teardown) | Complete |
+| 8 | Docs Tab (DocsTab.svelte, markdown discovery) | Complete |
+| 9 | Settings Tab (group/project CRUD, 5-project limit) | Complete |
+| 10 | Polish + Cleanup (dead v2 components removed, StatusBar rewrite) | Complete |
+
+---
+
+## Decisions Log
+
+| Decision | Rationale | Date |
+|---|---|---|
+| JSON for groups config, SQLite for session state | JSON is human-editable, shareable, version-controllable. SQLite for ephemeral runtime state. Load at startup only. | 2026-03-07 |
+| Adaptive project count from viewport width | 5@5120px, 3@1920px, scroll-snap for overflow. min-width 480px. Better than forcing 5 at all sizes. | 2026-03-07 |
+| Single shared sidecar (v3.0) | Existing multiplexed protocol handles concurrent sessions. Per-project pool deferred to v3.1 if crash isolation needed. Saves ~200MB RAM. | 2026-03-07 |
+| xterm budget: 4 active, unlimited suspended | WebKit2GTK OOM at ~5 instances. Serialize scrollback to text buffer, destroy xterm, recreate on focus. PTY stays alive. | 2026-03-07 |
+| Flexbox + scroll-snap over CSS Grid | Allows horizontal scroll on narrow screens. Scroll-snap gives clean project-to-project scrolling. | 2026-03-07 |
+| Team panel: inline >2560px, overlay <2560px | Adapts to available space. Collapsed when no subagents running. | 2026-03-07 |
+| VSCode-style left sidebar (replaces top tab bar + settings drawer) | Vertical icon rail (2.75rem, 4 SVG icons) + expandable drawer panel (28em, max 50%) + always-visible workspace. Settings is a regular tab, not special drawer. ProjectGrid always visible. Ctrl+B toggles sidebar. | 2026-03-08 |
+| CSS relative units (rule 18) | Use rem/em for all layout CSS. Pixels only for icon sizes, borders, box shadows. Exception: --ui-font-size/--term-font-size store px for xterm.js API. | 2026-03-08 |
+| Project accent colors from Catppuccin palette | Visual distinction: blue/green/mauve/peach/pink per slot 1-5. Applied to border + header tint. | 2026-03-07 |
+| Remote machines deferred to v3.1 | Elevate to project level (project.remote_machine_id) but don't implement in MVP. | 2026-03-07 |
+| Keyboard shortcut layers: App > Workspace > Terminal | Prevents conflicts. Terminal captures raw keys only when focused. App layer uses Ctrl+K/G. | 2026-03-07 |
+| AgentPane splits into ClaudeSession + TeamAgentsPanel | Team agents shown inline in right panel, not as separate panes. Saves xterm/pane slots. | 2026-03-07 |
+| Unmount/remount on group switch | Serialize xterm scrollbacks, destroy, remount new group. <100ms perceived. Frees ~80MB. | 2026-03-07 |
+| All themes map to --ctp-* CSS vars | 17 themes in 3 groups: 4 Catppuccin + 7 Editor (VSCode Dark+, Atom One Dark, Monokai, Dracula, Nord, Solarized Dark, GitHub Dark) + 6 Deep Dark (Tokyo Night, Gruvbox Dark, Ayu Dark, Poimandres, Vesper, Midnight). All map to same 26 --ctp-* CSS custom properties — zero component changes needed. | 2026-03-07 |
+| Typography via CSS custom properties | --ui-font-family/--ui-font-size + --term-font-family/--term-font-size in catppuccin.css :root. Restored by initTheme() on startup. Persisted as ui_font_family/ui_font_size/term_font_family/term_font_size SQLite settings. | 2026-03-07 |
+| Tier 1 agents as ProjectBoxes via agentToProject() | Agents render as full ProjectBoxes (not separate UI). getAllWorkItems() merges agents+projects. Unified rendering = less code, same capabilities. | 2026-03-11 |
+| extra_env 5-layer passthrough for BTMSG_AGENT_ID | TS → Rust AgentQueryOptions → NDJSON → JS runner → SDK env. Minimal surface — only agent projects get env injection. | 2026-03-11 |
+| Periodic system prompt re-injection (1 hour) | LLM context degrades over long sessions. 1-hour timer re-sends role/tools reminder when agent is idle. autoPrompt/onautopromptconsumed callback pattern between AgentSession and AgentPane. | 2026-03-11 |
+| btmsg/bttask shared SQLite DB | Both CLI tools share ~/.local/share/bterminal/btmsg.db. Single DB simplifies deployment, agents already have path. Read-only for non-Manager roles via CLI permissions. | 2026-03-11 |
+| Role-specific tabs via conditional rendering | Manager=Tasks, Architect=Arch, Tester=Selenium+Tests. PERSISTED-LAZY pattern (mount on first activation). Conditional on isAgent && agentRole. | 2026-03-11 |
+| PlantUML via plantuml.com server (~h hex encoding) | Avoids Java dependency. Hex encoding simpler than deflate+base64. Works with free tier. Trade-off: requires internet. | 2026-03-11 |
+
+## Errors Encountered
+
+| Error | Cause | Fix | Date |
+|---|---|---|---|
diff --git a/install-v2.sh b/install-v2.sh
new file mode 100755
index 0000000..b57d708
--- /dev/null
+++ b/install-v2.sh
@@ -0,0 +1,216 @@
+#!/bin/bash
+set -euo pipefail
+
+# BTerminal v2 installer — builds from source
+# Requires: Node.js 20+, Rust toolchain, system libs (WebKit2GTK, etc.)
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+BIN_DIR="$HOME/.local/bin"
+ICON_DIR="$HOME/.local/share/icons/hicolor/scalable/apps"
+DESKTOP_DIR="$HOME/.local/share/applications"
+
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+NC='\033[0m'
+
+info()  { echo -e "  ${GREEN}✓${NC} $1"; }
+warn()  { echo -e "  ${YELLOW}!${NC} $1"; }
+fail()  { echo -e "  ${RED}✗${NC} $1"; exit 1; }
+
+echo "=== BTerminal v2 Installer ==="
+echo ""
+
+# ─── 1. Check Node.js ────────────────────────────────────────────────────────
+
+echo "[1/6] Checking Node.js..."
+
+if ! command -v node &>/dev/null; then
+    fail "Node.js not found. Install Node.js 20+ (https://nodejs.org)"
+fi
+
+NODE_VER=$(node -v | sed 's/^v//' | cut -d. -f1)
+if [ "$NODE_VER" -lt 20 ]; then
+    fail "Node.js $NODE_VER found, need 20+. Upgrade at https://nodejs.org"
+fi
+info "Node.js $(node -v)"
+
+if ! command -v npm &>/dev/null; then
+    fail "npm not found. Install Node.js with npm."
+fi
+info "npm $(npm -v)"
+
+# ─── 2. Check Rust toolchain ─────────────────────────────────────────────────
+
+echo "[2/6] Checking Rust toolchain..."
+
+if ! command -v rustc &>/dev/null; then
+    fail "Rust not found. Install via: curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh"
+fi
+
+RUST_VER=$(rustc --version | awk '{print $2}')
+RUST_MAJOR=$(echo "$RUST_VER" | cut -d. -f1)
+RUST_MINOR=$(echo "$RUST_VER" | cut -d. -f2)
+if [ "$RUST_MAJOR" -lt 1 ] || { [ "$RUST_MAJOR" -eq 1 ] && [ "$RUST_MINOR" -lt 77 ]; }; then
+    fail "Rust $RUST_VER found, need 1.77+. Run: rustup update"
+fi
+info "Rust $RUST_VER"
+
+if ! command -v cargo &>/dev/null; then
+    fail "Cargo not found. Reinstall Rust toolchain."
+fi
+info "Cargo $(cargo --version | awk '{print $2}')"
+
+# ─── 3. Check system libraries ───────────────────────────────────────────────
+
+echo "[3/6] Checking system libraries..."
+
+MISSING_PKGS=()
+
+# WebKit2GTK 4.1 (required by Tauri 2.x on Linux)
+if ! pkg-config --exists webkit2gtk-4.1 2>/dev/null; then
+    MISSING_PKGS+=("libwebkit2gtk-4.1-dev")
+fi
+
+# GTK3
+if ! pkg-config --exists gtk+-3.0 2>/dev/null; then
+    MISSING_PKGS+=("libgtk-3-dev")
+fi
+
+# GLib/GIO
+if ! pkg-config --exists gio-2.0 2>/dev/null; then
+    MISSING_PKGS+=("libglib2.0-dev")
+fi
+
+# libayatana-appindicator (system tray)
+if ! pkg-config --exists ayatana-appindicator3-0.1 2>/dev/null; then
+    MISSING_PKGS+=("libayatana-appindicator3-dev")
+fi
+
+# librsvg (SVG icon rendering)
+if ! pkg-config --exists librsvg-2.0 2>/dev/null; then
+    MISSING_PKGS+=("librsvg2-dev")
+fi
+
+# libssl (TLS)
+if ! pkg-config --exists openssl 2>/dev/null; then
+    MISSING_PKGS+=("libssl-dev")
+fi
+
+# Build essentials
+if ! command -v cc &>/dev/null; then
+    MISSING_PKGS+=("build-essential")
+fi
+
+# pkg-config itself
+if ! command -v pkg-config &>/dev/null; then
+    MISSING_PKGS+=("pkg-config")
+fi
+
+# curl (needed for some build steps)
+if ! command -v curl &>/dev/null; then
+    MISSING_PKGS+=("curl")
+fi
+
+# wget (needed for AppImage tools)
+if ! command -v wget &>/dev/null; then
+    MISSING_PKGS+=("wget")
+fi
+
+# FUSE (needed for AppImage)
+if ! dpkg -s libfuse2t64 &>/dev/null 2>&1 && ! dpkg -s libfuse2 &>/dev/null 2>&1; then
+    # Try the newer package name first (Debian trixie+), fall back to older
+    if apt-cache show libfuse2t64 &>/dev/null 2>&1; then
+        MISSING_PKGS+=("libfuse2t64")
+    else
+        MISSING_PKGS+=("libfuse2")
+    fi
+fi
+
+if [ ${#MISSING_PKGS[@]} -gt 0 ]; then
+    echo ""
+    warn "Missing system packages: ${MISSING_PKGS[*]}"
+    echo ""
+    read -rp "  Install with apt? [Y/n] " REPLY
+    REPLY=${REPLY:-Y}
+    if [[ "$REPLY" =~ ^[Yy]$ ]]; then
+        sudo apt update
+        sudo apt install -y "${MISSING_PKGS[@]}"
+        info "System packages installed"
+    else
+        fail "Cannot continue without: ${MISSING_PKGS[*]}"
+    fi
+else
+    info "All system libraries present"
+fi
+
+# ─── 4. Install npm dependencies ─────────────────────────────────────────────
+
+echo "[4/6] Installing npm dependencies..."
+
+cd "$SCRIPT_DIR/v2"
+npm ci --legacy-peer-deps
+info "npm dependencies installed"
+
+# ─── 5. Build Tauri app ──────────────────────────────────────────────────────
+
+echo "[5/6] Building BTerminal (this may take a few minutes on first build)..."
+
+npx tauri build 2>&1 | tail -5
+info "Build complete"
+
+# Locate built artifacts
+BUNDLE_DIR="$SCRIPT_DIR/v2/src-tauri/target/release/bundle"
+DEB_FILE=$(find "$BUNDLE_DIR/deb" -name "*.deb" 2>/dev/null | head -1)
+APPIMAGE_FILE=$(find "$BUNDLE_DIR/appimage" -name "*.AppImage" 2>/dev/null | head -1)
+BINARY="$SCRIPT_DIR/v2/src-tauri/target/release/bterminal"
+
+# ─── 6. Install ──────────────────────────────────────────────────────────────
+
+echo "[6/6] Installing..."
+
+mkdir -p "$BIN_DIR" "$ICON_DIR" "$DESKTOP_DIR"
+
+# Copy binary
+cp "$BINARY" "$BIN_DIR/bterminal-v2"
+chmod +x "$BIN_DIR/bterminal-v2"
+info "Binary: $BIN_DIR/bterminal-v2"
+
+# Copy icon
+if [ -f "$SCRIPT_DIR/bterminal.svg" ]; then
+    cp "$SCRIPT_DIR/bterminal.svg" "$ICON_DIR/bterminal.svg"
+    info "Icon: $ICON_DIR/bterminal.svg"
+fi
+
+# Desktop entry
+cat > "$DESKTOP_DIR/bterminal-v2.desktop" << EOF
+[Desktop Entry]
+Name=BTerminal v2
+Comment=Multi-session Claude agent dashboard
+Exec=$BIN_DIR/bterminal-v2
+Icon=bterminal
+Type=Application
+Categories=System;TerminalEmulator;Development;
+Terminal=false
+StartupNotify=true
+StartupWMClass=bterminal
+EOF
+info "Desktop entry created"
+
+echo ""
+echo "=== Installation complete ==="
+echo ""
+
+if [ -n "${DEB_FILE:-}" ]; then
+    echo "  .deb package:  $DEB_FILE"
+fi
+if [ -n "${APPIMAGE_FILE:-}" ]; then
+    echo "  AppImage:      $APPIMAGE_FILE"
+fi
+echo "  Binary:        $BIN_DIR/bterminal-v2"
+echo ""
+echo "Run: bterminal-v2"
+echo ""
+echo "Make sure $BIN_DIR is in your PATH."
+echo "If not, add to ~/.bashrc:"
+echo "  export PATH=\"\$HOME/.local/bin:\$PATH\""
diff --git a/v2/.gitignore b/v2/.gitignore
new file mode 100644
index 0000000..0d6b98e
--- /dev/null
+++ b/v2/.gitignore
@@ -0,0 +1,27 @@
+# Logs
+logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+pnpm-debug.log*
+lerna-debug.log*
+
+node_modules
+dist
+public/pdf.worker.min.mjs
+dist-ssr
+*.local
+sidecar/dist
+sidecar/node_modules
+
+# Editor directories and files
+.vscode/*
+!.vscode/extensions.json
+.idea
+.DS_Store
+*.suo
+*.ntvs*
+*.njsproj
+*.sln
+*.sw?
diff --git a/v2/.vscode/extensions.json b/v2/.vscode/extensions.json
new file mode 100644
index 0000000..bdef820
--- /dev/null
+++ b/v2/.vscode/extensions.json
@@ -0,0 +1,3 @@
+{
+  "recommendations": ["svelte.svelte-vscode"]
+}
diff --git a/v2/Cargo.lock b/v2/Cargo.lock
new file mode 100644
index 0000000..8a9aa2e
--- /dev/null
+++ b/v2/Cargo.lock
@@ -0,0 +1,6780 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "adler2"
+version = "2.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "320119579fcad9c21884f5c4861d16174d0e06250625266f50fe6898340abefa"
+
+[[package]]
+name = "ahash"
+version = "0.8.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5a15f179cd60c4584b8a8c596927aadc462e27f2ca70c04e0071964a73ba7a75"
+dependencies = [
+ "cfg-if",
+ "once_cell",
+ "version_check",
+ "zerocopy",
+]
+
+[[package]]
+name = "aho-corasick"
+version = "1.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ddd31a130427c27518df266943a5308ed92d4b226cc639f5a8f1002816174301"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "alloc-no-stdlib"
+version = "2.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cc7bb162ec39d46ab1ca8c77bf72e890535becd1751bb45f64c597edb4c8c6b3"
+
+[[package]]
+name = "alloc-stdlib"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "94fb8275041c72129eb51b7d0322c29b8387a0386127718b096429201a5d6ece"
+dependencies = [
+ "alloc-no-stdlib",
+]
+
+[[package]]
+name = "android_system_properties"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "819e7219dbd41043ac279b19830f2efc897156490d7fd6ea916720117ee66311"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "anstream"
+version = "0.6.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "43d5b281e737544384e969a5ccad3f1cdd24b48086a0fc1b2a5262a26b8f4f4a"
+dependencies = [
+ "anstyle",
+ "anstyle-parse",
+ "anstyle-query",
+ "anstyle-wincon",
+ "colorchoice",
+ "is_terminal_polyfill",
+ "utf8parse",
+]
+
+[[package]]
+name = "anstyle"
+version = "1.0.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5192cca8006f1fd4f7237516f40fa183bb07f8fbdfedaa0036de5ea9b0b45e78"
+
+[[package]]
+name = "anstyle-parse"
+version = "0.2.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4e7644824f0aa2c7b9384579234ef10eb7efb6a0deb83f9630a49594dd9c15c2"
+dependencies = [
+ "utf8parse",
+]
+
+[[package]]
+name = "anstyle-query"
+version = "1.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "40c48f72fd53cd289104fc64099abca73db4166ad86ea0b4341abe65af83dadc"
+dependencies = [
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "anstyle-wincon"
+version = "3.0.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "291e6a250ff86cd4a820112fb8898808a366d8f9f58ce16d1f538353ad55747d"
+dependencies = [
+ "anstyle",
+ "once_cell_polyfill",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "anyhow"
+version = "1.0.102"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7f202df86484c868dbad7eaa557ef785d5c66295e41b460ef922eca0723b842c"
+
+[[package]]
+name = "arbitrary"
+version = "1.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c3d036a3c4ab069c7b410a2ce876bd74808d2d0888a82667669f8e783a898bf1"
+dependencies = [
+ "derive_arbitrary",
+]
+
+[[package]]
+name = "async-broadcast"
+version = "0.7.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "435a87a52755b8f27fcf321ac4f04b2802e337c8c4872923137471ec39c37532"
+dependencies = [
+ "event-listener",
+ "event-listener-strategy",
+ "futures-core",
+ "pin-project-lite",
+]
+
+[[package]]
+name = "async-channel"
+version = "2.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "924ed96dd52d1b75e9c1a3e6275715fd320f5f9439fb5a4a11fa51f4221158d2"
+dependencies = [
+ "concurrent-queue",
+ "event-listener-strategy",
+ "futures-core",
+ "pin-project-lite",
+]
+
+[[package]]
+name = "async-executor"
+version = "1.14.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c96bf972d85afc50bf5ab8fe2d54d1586b4e0b46c97c50a0c9e71e2f7bcd812a"
+dependencies = [
+ "async-task",
+ "concurrent-queue",
+ "fastrand",
+ "futures-lite",
+ "pin-project-lite",
+ "slab",
+]
+
+[[package]]
+name = "async-io"
+version = "2.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "456b8a8feb6f42d237746d4b3e9a178494627745c3c56c6ea55d92ba50d026fc"
+dependencies = [
+ "autocfg",
+ "cfg-if",
+ "concurrent-queue",
+ "futures-io",
+ "futures-lite",
+ "parking",
+ "polling",
+ "rustix",
+ "slab",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "async-lock"
+version = "3.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "290f7f2596bd5b78a9fec8088ccd89180d7f9f55b94b0576823bbbdc72ee8311"
+dependencies = [
+ "event-listener",
+ "event-listener-strategy",
+ "pin-project-lite",
+]
+
+[[package]]
+name = "async-process"
+version = "2.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fc50921ec0055cdd8a16de48773bfeec5c972598674347252c0399676be7da75"
+dependencies = [
+ "async-channel",
+ "async-io",
+ "async-lock",
+ "async-signal",
+ "async-task",
+ "blocking",
+ "cfg-if",
+ "event-listener",
+ "futures-lite",
+ "rustix",
+]
+
+[[package]]
+name = "async-recursion"
+version = "1.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3b43422f69d8ff38f95f1b2bb76517c91589a924d1559a0e935d7c8ce0274c11"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "async-signal"
+version = "0.2.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "43c070bbf59cd3570b6b2dd54cd772527c7c3620fce8be898406dd3ed6adc64c"
+dependencies = [
+ "async-io",
+ "async-lock",
+ "atomic-waker",
+ "cfg-if",
+ "futures-core",
+ "futures-io",
+ "rustix",
+ "signal-hook-registry",
+ "slab",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "async-task"
+version = "4.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8b75356056920673b02621b35afd0f7dda9306d03c79a30f5c56c44cf256e3de"
+
+[[package]]
+name = "async-trait"
+version = "0.1.89"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9035ad2d096bed7955a320ee7e2230574d28fd3c3a0f186cbea1ff3c7eed5dbb"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "atk"
+version = "0.18.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "241b621213072e993be4f6f3a9e4b45f65b7e6faad43001be957184b7bb1824b"
+dependencies = [
+ "atk-sys",
+ "glib",
+ "libc",
+]
+
+[[package]]
+name = "atk-sys"
+version = "0.18.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c5e48b684b0ca77d2bbadeef17424c2ea3c897d44d566a1617e7e8f30614d086"
+dependencies = [
+ "glib-sys",
+ "gobject-sys",
+ "libc",
+ "system-deps",
+]
+
+[[package]]
+name = "atomic-waker"
+version = "1.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1505bd5d3d116872e7271a6d4e16d81d0c8570876c8de68093a09ac269d8aac0"
+
+[[package]]
+name = "autocfg"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c08606f8c3cbf4ce6ec8e28fb0014a2c086708fe954eaa885384a6165172e7e8"
+
+[[package]]
+name = "base64"
+version = "0.21.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9d297deb1925b89f2ccc13d7635fa0714f12c87adce1c75356b39ca9b7178567"
+
+[[package]]
+name = "base64"
+version = "0.22.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6"
+
+[[package]]
+name = "bitflags"
+version = "1.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
+
+[[package]]
+name = "bitflags"
+version = "2.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "843867be96c8daad0d758b57df9392b6d8d271134fce549de6ce169ff98a92af"
+dependencies = [
+ "serde_core",
+]
+
+[[package]]
+name = "block-buffer"
+version = "0.10.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3078c7629b62d3f0439517fa394996acacc5cbc91c5a20d8c658e77abd503a71"
+dependencies = [
+ "generic-array",
+]
+
+[[package]]
+name = "block2"
+version = "0.6.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cdeb9d870516001442e364c5220d3574d2da8dc765554b4a617230d33fa58ef5"
+dependencies = [
+ "objc2",
+]
+
+[[package]]
+name = "blocking"
+version = "1.6.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e83f8d02be6967315521be875afa792a316e28d57b5a2d401897e2a7921b7f21"
+dependencies = [
+ "async-channel",
+ "async-task",
+ "futures-io",
+ "futures-lite",
+ "piper",
+]
+
+[[package]]
+name = "brotli"
+version = "8.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4bd8b9603c7aa97359dbd97ecf258968c95f3adddd6db2f7e7a5bef101c84560"
+dependencies = [
+ "alloc-no-stdlib",
+ "alloc-stdlib",
+ "brotli-decompressor",
+]
+
+[[package]]
+name = "brotli-decompressor"
+version = "5.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "874bb8112abecc98cbd6d81ea4fa7e94fb9449648c93cc89aa40c81c24d7de03"
+dependencies = [
+ "alloc-no-stdlib",
+ "alloc-stdlib",
+]
+
+[[package]]
+name = "bterminal"
+version = "0.1.0"
+dependencies = [
+ "bterminal-core",
+ "dirs 5.0.1",
+ "futures-util",
+ "keyring",
+ "log",
+ "notify",
+ "notify-rust",
+ "opentelemetry",
+ "opentelemetry-otlp",
+ "opentelemetry_sdk",
+ "rfd",
+ "rusqlite",
+ "serde",
+ "serde_json",
+ "tauri",
+ "tauri-build",
+ "tauri-plugin-dialog",
+ "tauri-plugin-updater",
+ "tempfile",
+ "tokio",
+ "tokio-tungstenite",
+ "tracing",
+ "tracing-opentelemetry",
+ "tracing-subscriber",
+ "uuid",
+]
+
+[[package]]
+name = "bterminal-core"
+version = "0.1.0"
+dependencies = [
+ "dirs 5.0.1",
+ "landlock",
+ "log",
+ "portable-pty",
+ "serde",
+ "serde_json",
+ "uuid",
+]
+
+[[package]]
+name = "bterminal-relay"
+version = "0.1.0"
+dependencies = [
+ "bterminal-core",
+ "clap",
+ "env_logger",
+ "futures-util",
+ "log",
+ "native-tls",
+ "serde",
+ "serde_json",
+ "tokio",
+ "tokio-native-tls",
+ "tokio-tungstenite",
+ "uuid",
+]
+
+[[package]]
+name = "bumpalo"
+version = "3.20.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5d20789868f4b01b2f2caec9f5c4e0213b41e3e5702a50157d699ae31ced2fcb"
+
+[[package]]
+name = "bytemuck"
+version = "1.25.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c8efb64bd706a16a1bdde310ae86b351e4d21550d98d056f22f8a7f7a2183fec"
+
+[[package]]
+name = "byteorder"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"
+
+[[package]]
+name = "bytes"
+version = "1.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e748733b7cbc798e1434b6ac524f0c1ff2ab456fe201501e6497c8417a4fc33"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "cairo-rs"
+version = "0.18.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8ca26ef0159422fb77631dc9d17b102f253b876fe1586b03b803e63a309b4ee2"
+dependencies = [
+ "bitflags 2.11.0",
+ "cairo-sys-rs",
+ "glib",
+ "libc",
+ "once_cell",
+ "thiserror 1.0.69",
+]
+
+[[package]]
+name = "cairo-sys-rs"
+version = "0.18.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "685c9fa8e590b8b3d678873528d83411db17242a73fccaed827770ea0fedda51"
+dependencies = [
+ "glib-sys",
+ "libc",
+ "system-deps",
+]
+
+[[package]]
+name = "camino"
+version = "1.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e629a66d692cb9ff1a1c664e41771b3dcaf961985a9774c0eb0bd1b51cf60a48"
+dependencies = [
+ "serde_core",
+]
+
+[[package]]
+name = "cargo-platform"
+version = "0.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e35af189006b9c0f00a064685c727031e3ed2d8020f7ba284d78cc2671bd36ea"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "cargo_metadata"
+version = "0.19.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dd5eb614ed4c27c5d706420e4320fbe3216ab31fa1c33cd8246ac36dae4479ba"
+dependencies = [
+ "camino",
+ "cargo-platform",
+ "semver",
+ "serde",
+ "serde_json",
+ "thiserror 2.0.18",
+]
+
+[[package]]
+name = "cargo_toml"
+version = "0.22.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "374b7c592d9c00c1f4972ea58390ac6b18cbb6ab79011f3bdc90a0b82ca06b77"
+dependencies = [
+ "serde",
+ "toml 0.9.12+spec-1.1.0",
+]
+
+[[package]]
+name = "cc"
+version = "1.2.56"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "aebf35691d1bfb0ac386a69bac2fde4dd276fb618cf8bf4f5318fe285e821bb2"
+dependencies = [
+ "find-msvc-tools",
+ "shlex",
+]
+
+[[package]]
+name = "cesu8"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6d43a04d8753f35258c91f8ec639f792891f748a1edbd759cf1dcea3382ad83c"
+
+[[package]]
+name = "cfb"
+version = "0.7.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d38f2da7a0a2c4ccf0065be06397cc26a81f4e528be095826eee9d4adbb8c60f"
+dependencies = [
+ "byteorder",
+ "fnv",
+ "uuid",
+]
+
+[[package]]
+name = "cfg-expr"
+version = "0.15.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d067ad48b8650848b989a59a86c6c36a995d02d2bf778d45c3c5d57bc2718f02"
+dependencies = [
+ "smallvec",
+ "target-lexicon",
+]
+
+[[package]]
+name = "cfg-if"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801"
+
+[[package]]
+name = "chrono"
+version = "0.4.44"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c673075a2e0e5f4a1dde27ce9dee1ea4558c7ffe648f576438a20ca1d2acc4b0"
+dependencies = [
+ "iana-time-zone",
+ "num-traits",
+ "serde",
+ "windows-link 0.2.1",
+]
+
+[[package]]
+name = "clap"
+version = "4.5.60"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2797f34da339ce31042b27d23607e051786132987f595b02ba4f6a6dffb7030a"
+dependencies = [
+ "clap_builder",
+ "clap_derive",
+]
+
+[[package]]
+name = "clap_builder"
+version = "4.5.60"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "24a241312cea5059b13574bb9b3861cabf758b879c15190b37b6d6fd63ab6876"
+dependencies = [
+ "anstream",
+ "anstyle",
+ "clap_lex",
+ "strsim",
+]
+
+[[package]]
+name = "clap_derive"
+version = "4.5.55"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a92793da1a46a5f2a02a6f4c46c6496b28c43638adea8306fcb0caa1634f24e5"
+dependencies = [
+ "heck 0.5.0",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "clap_lex"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3a822ea5bc7590f9d40f1ba12c0dc3c2760f3482c6984db1573ad11031420831"
+
+[[package]]
+name = "colorchoice"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b05b61dc5112cbb17e4b6cd61790d9845d13888356391624cbe7e41efeac1e75"
+
+[[package]]
+name = "combine"
+version = "4.6.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ba5a308b75df32fe02788e748662718f03fde005016435c444eea572398219fd"
+dependencies = [
+ "bytes",
+ "memchr",
+]
+
+[[package]]
+name = "concurrent-queue"
+version = "2.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4ca0197aee26d1ae37445ee532fefce43251d24cc7c166799f4d46817f1d3973"
+dependencies = [
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "convert_case"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6245d59a3e82a7fc217c5828a6692dbc6dfb63a0c8c90495621f7b9d79704a0e"
+
+[[package]]
+name = "cookie"
+version = "0.18.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4ddef33a339a91ea89fb53151bd0a4689cfce27055c291dfa69945475d22c747"
+dependencies = [
+ "time",
+ "version_check",
+]
+
+[[package]]
+name = "core-foundation"
+version = "0.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b2a6cd9ae233e7f62ba4e9353e81a88df7fc8a5987b8d445b4d90c879bd156f6"
+dependencies = [
+ "core-foundation-sys",
+ "libc",
+]
+
+[[package]]
+name = "core-foundation-sys"
+version = "0.8.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "773648b94d0e5d620f64f280777445740e61fe701025087ec8b57f45c791888b"
+
+[[package]]
+name = "core-graphics"
+version = "0.25.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "064badf302c3194842cf2c5d61f56cc88e54a759313879cdf03abdd27d0c3b97"
+dependencies = [
+ "bitflags 2.11.0",
+ "core-foundation",
+ "core-graphics-types",
+ "foreign-types 0.5.0",
+ "libc",
+]
+
+[[package]]
+name = "core-graphics-types"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3d44a101f213f6c4cdc1853d4b78aef6db6bdfa3468798cc1d9912f4735013eb"
+dependencies = [
+ "bitflags 2.11.0",
+ "core-foundation",
+ "libc",
+]
+
+[[package]]
+name = "cpufeatures"
+version = "0.2.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "59ed5838eebb26a2bb2e58f6d5b5316989ae9d08bab10e0e6d103e656d1b0280"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "crc32fast"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9481c1c90cbf2ac953f07c8d4a58aa3945c425b7185c9154d67a65e4230da511"
+dependencies = [
+ "cfg-if",
+]
+
+[[package]]
+name = "crossbeam-channel"
+version = "0.5.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "82b8f8f868b36967f9606790d1903570de9ceaf870a7bf9fbbd3016d636a2cb2"
+dependencies = [
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "crossbeam-utils"
+version = "0.8.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d0a5c400df2834b80a4c3327b3aad3a4c4cd4de0629063962b03235697506a28"
+
+[[package]]
+name = "crypto-common"
+version = "0.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "78c8292055d1c1df0cce5d180393dc8cce0abec0a7102adb6c7b1eef6016d60a"
+dependencies = [
+ "generic-array",
+ "typenum",
+]
+
+[[package]]
+name = "cssparser"
+version = "0.29.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f93d03419cb5950ccfd3daf3ff1c7a36ace64609a1a8746d493df1ca0afde0fa"
+dependencies = [
+ "cssparser-macros",
+ "dtoa-short",
+ "itoa",
+ "matches",
+ "phf 0.10.1",
+ "proc-macro2",
+ "quote",
+ "smallvec",
+ "syn 1.0.109",
+]
+
+[[package]]
+name = "cssparser-macros"
+version = "0.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "13b588ba4ac1a99f7f2964d24b3d896ddc6bf847ee3855dbd4366f058cfcd331"
+dependencies = [
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "csv"
+version = "1.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "52cd9d68cf7efc6ddfaaee42e7288d3a99d613d4b50f76ce9827ae0c6e14f938"
+dependencies = [
+ "csv-core",
+ "itoa",
+ "ryu",
+ "serde_core",
+]
+
+[[package]]
+name = "csv-core"
+version = "0.1.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "704a3c26996a80471189265814dbc2c257598b96b8a7feae2d31ace646bb9782"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "ctor"
+version = "0.2.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32a2785755761f3ddc1492979ce1e48d2c00d09311c39e4466429188f3dd6501"
+dependencies = [
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "darling"
+version = "0.21.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9cdf337090841a411e2a7f3deb9187445851f91b309c0c0a29e05f74a00a48c0"
+dependencies = [
+ "darling_core",
+ "darling_macro",
+]
+
+[[package]]
+name = "darling_core"
+version = "0.21.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1247195ecd7e3c85f83c8d2a366e4210d588e802133e1e355180a9870b517ea4"
+dependencies = [
+ "fnv",
+ "ident_case",
+ "proc-macro2",
+ "quote",
+ "strsim",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "darling_macro"
+version = "0.21.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d38308df82d1080de0afee5d069fa14b0326a88c14f15c5ccda35b4a6c414c81"
+dependencies = [
+ "darling_core",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "data-encoding"
+version = "2.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d7a1e2f27636f116493b8b860f5546edb47c8d8f8ea73e1d2a20be88e28d1fea"
+
+[[package]]
+name = "deranged"
+version = "0.5.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7cd812cc2bc1d69d4764bd80df88b4317eaef9e773c75226407d9bc0876b211c"
+dependencies = [
+ "powerfmt",
+ "serde_core",
+]
+
+[[package]]
+name = "derive_arbitrary"
+version = "1.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e567bd82dcff979e4b03460c307b3cdc9e96fde3d73bed1496d2bc75d9dd62a"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "derive_more"
+version = "0.99.20"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6edb4b64a43d977b8e99788fe3a04d483834fba1215a7e02caa415b626497f7f"
+dependencies = [
+ "convert_case",
+ "proc-macro2",
+ "quote",
+ "rustc_version",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "digest"
+version = "0.10.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292"
+dependencies = [
+ "block-buffer",
+ "crypto-common",
+]
+
+[[package]]
+name = "dirs"
+version = "5.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "44c45a9d03d6676652bcb5e724c7e988de1acad23a711b5217ab9cbecbec2225"
+dependencies = [
+ "dirs-sys 0.4.1",
+]
+
+[[package]]
+name = "dirs"
+version = "6.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c3e8aa94d75141228480295a7d0e7feb620b1a5ad9f12bc40be62411e38cce4e"
+dependencies = [
+ "dirs-sys 0.5.0",
+]
+
+[[package]]
+name = "dirs-sys"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "520f05a5cbd335fae5a99ff7a6ab8627577660ee5cfd6a94a6a929b52ff0321c"
+dependencies = [
+ "libc",
+ "option-ext",
+ "redox_users 0.4.6",
+ "windows-sys 0.48.0",
+]
+
+[[package]]
+name = "dirs-sys"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e01a3366d27ee9890022452ee61b2b63a67e6f13f58900b651ff5665f0bb1fab"
+dependencies = [
+ "libc",
+ "option-ext",
+ "redox_users 0.5.2",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "dispatch2"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e0e367e4e7da84520dedcac1901e4da967309406d1e51017ae1abfb97adbd38"
+dependencies = [
+ "bitflags 2.11.0",
+ "block2",
+ "libc",
+ "objc2",
+]
+
+[[package]]
+name = "displaydoc"
+version = "0.2.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "97369cbbc041bc366949bc74d34658d6cda5621039731c6310521892a3a20ae0"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "dlopen2"
+version = "0.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5e2c5bd4158e66d1e215c49b837e11d62f3267b30c92f1d171c4d3105e3dc4d4"
+dependencies = [
+ "dlopen2_derive",
+ "libc",
+ "once_cell",
+ "winapi",
+]
+
+[[package]]
+name = "dlopen2_derive"
+version = "0.4.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0fbbb781877580993a8707ec48672673ec7b81eeba04cfd2310bd28c08e47c8f"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "downcast-rs"
+version = "1.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "75b325c5dbd37f80359721ad39aca5a29fb04c89279657cffdda8736d0c0b9d2"
+
+[[package]]
+name = "dpi"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d8b14ccef22fc6f5a8f4d7d768562a182c04ce9a3b3157b91390b52ddfdf1a76"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "dtoa"
+version = "1.0.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4c3cf4824e2d5f025c7b531afcb2325364084a16806f6d47fbc1f5fbd9960590"
+
+[[package]]
+name = "dtoa-short"
+version = "0.3.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cd1511a7b6a56299bd043a9c167a6d2bfb37bf84a6dfceaba651168adfb43c87"
+dependencies = [
+ "dtoa",
+]
+
+[[package]]
+name = "dunce"
+version = "1.0.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "92773504d58c093f6de2459af4af33faa518c13451eb8f2b5698ed3d36e7c813"
+
+[[package]]
+name = "dyn-clone"
+version = "1.0.20"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d0881ea181b1df73ff77ffaaf9c7544ecc11e82fba9b5f27b262a3c73a332555"
+
+[[package]]
+name = "either"
+version = "1.15.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "48c757948c5ede0e46177b7add2e67155f70e33c07fea8284df6576da70b3719"
+
+[[package]]
+name = "embed-resource"
+version = "3.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "55a075fc573c64510038d7ee9abc7990635863992f83ebc52c8b433b8411a02e"
+dependencies = [
+ "cc",
+ "memchr",
+ "rustc_version",
+ "toml 0.9.12+spec-1.1.0",
+ "vswhom",
+ "winreg 0.55.0",
+]
+
+[[package]]
+name = "embed_plist"
+version = "1.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4ef6b89e5b37196644d8796de5268852ff179b44e96276cf4290264843743bb7"
+
+[[package]]
+name = "endi"
+version = "1.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "66b7e2430c6dff6a955451e2cfc438f09cea1965a9d6f87f7e3b90decc014099"
+
+[[package]]
+name = "enumflags2"
+version = "0.7.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1027f7680c853e056ebcec683615fb6fbbc07dbaa13b4d5d9442b146ded4ecef"
+dependencies = [
+ "enumflags2_derive",
+ "serde",
+]
+
+[[package]]
+name = "enumflags2_derive"
+version = "0.7.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "67c78a4d8fdf9953a5c9d458f9efe940fd97a0cab0941c075a813ac594733827"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "env_filter"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7a1c3cc8e57274ec99de65301228b537f1e4eedc1b8e0f9411c6caac8ae7308f"
+dependencies = [
+ "log",
+ "regex",
+]
+
+[[package]]
+name = "env_logger"
+version = "0.11.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b2daee4ea451f429a58296525ddf28b45a3b64f1acf6587e2067437bb11e218d"
+dependencies = [
+ "anstream",
+ "anstyle",
+ "env_filter",
+ "jiff",
+ "log",
+]
+
+[[package]]
+name = "equivalent"
+version = "1.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f"
+
+[[package]]
+name = "erased-serde"
+version = "0.4.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d2add8a07dd6a8d93ff627029c51de145e12686fbc36ecb298ac22e74cf02dec"
+dependencies = [
+ "serde",
+ "serde_core",
+ "typeid",
+]
+
+[[package]]
+name = "errno"
+version = "0.3.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb"
+dependencies = [
+ "libc",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "event-listener"
+version = "5.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e13b66accf52311f30a0db42147dadea9850cb48cd070028831ae5f5d4b856ab"
+dependencies = [
+ "concurrent-queue",
+ "parking",
+ "pin-project-lite",
+]
+
+[[package]]
+name = "event-listener-strategy"
+version = "0.5.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8be9f3dfaaffdae2972880079a491a1a8bb7cbed0b8dd7a347f668b4150a3b93"
+dependencies = [
+ "event-listener",
+ "pin-project-lite",
+]
+
+[[package]]
+name = "fallible-iterator"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2acce4a10f12dc2fb14a218589d4f1f62ef011b2d0cc4b3cb1bba8e94da14649"
+
+[[package]]
+name = "fallible-streaming-iterator"
+version = "0.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7360491ce676a36bf9bb3c56c1aa791658183a54d2744120f27285738d90465a"
+
+[[package]]
+name = "fastrand"
+version = "2.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "37909eebbb50d72f9059c3b6d82c0463f2ff062c9e95845c43a6c9c0355411be"
+
+[[package]]
+name = "fdeflate"
+version = "0.3.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e6853b52649d4ac5c0bd02320cddc5ba956bdb407c4b75a2c6b75bf51500f8c"
+dependencies = [
+ "simd-adler32",
+]
+
+[[package]]
+name = "field-offset"
+version = "0.3.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "38e2275cc4e4fc009b0669731a1e5ab7ebf11f469eaede2bab9309a5b4d6057f"
+dependencies = [
+ "memoffset 0.9.1",
+ "rustc_version",
+]
+
+[[package]]
+name = "filedescriptor"
+version = "0.8.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e40758ed24c9b2eeb76c35fb0aebc66c626084edd827e07e1552279814c6682d"
+dependencies = [
+ "libc",
+ "thiserror 1.0.69",
+ "winapi",
+]
+
+[[package]]
+name = "filetime"
+version = "0.2.27"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f98844151eee8917efc50bd9e8318cb963ae8b297431495d3f758616ea5c57db"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "libredox",
+]
+
+[[package]]
+name = "find-msvc-tools"
+version = "0.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5baebc0774151f905a1a2cc41989300b1e6fbb29aff0ceffa1064fdd3088d582"
+
+[[package]]
+name = "flate2"
+version = "1.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "843fba2746e448b37e26a819579957415c8cef339bf08564fe8b7ddbd959573c"
+dependencies = [
+ "crc32fast",
+ "miniz_oxide",
+]
+
+[[package]]
+name = "fnv"
+version = "1.0.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"
+
+[[package]]
+name = "foldhash"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d9c4f5dac5e15c24eb999c26181a6ca40b39fe946cbe4c263c7209467bc83af2"
+
+[[package]]
+name = "foreign-types"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f6f339eb8adc052cd2ca78910fda869aefa38d22d5cb648e6485e4d3fc06f3b1"
+dependencies = [
+ "foreign-types-shared 0.1.1",
+]
+
+[[package]]
+name = "foreign-types"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d737d9aa519fb7b749cbc3b962edcf310a8dd1f4b67c91c4f83975dbdd17d965"
+dependencies = [
+ "foreign-types-macros",
+ "foreign-types-shared 0.3.1",
+]
+
+[[package]]
+name = "foreign-types-macros"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1a5c6c585bc94aaf2c7b51dd4c2ba22680844aba4c687be581871a6f518c5742"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "foreign-types-shared"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "00b0228411908ca8685dba7fc2cdd70ec9990a6e753e89b6ac91a84c40fbaf4b"
+
+[[package]]
+name = "foreign-types-shared"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "aa9a19cbb55df58761df49b23516a86d432839add4af60fc256da840f66ed35b"
+
+[[package]]
+name = "form_urlencoded"
+version = "1.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cb4cb245038516f5f85277875cdaa4f7d2c9a0fa0468de06ed190163b1581fcf"
+dependencies = [
+ "percent-encoding",
+]
+
+[[package]]
+name = "fsevent-sys"
+version = "4.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "76ee7a02da4d231650c7cea31349b889be2f45ddb3ef3032d2ec8185f6313fd2"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "futf"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "df420e2e84819663797d1ec6544b13c5be84629e7bb00dc960d6917db2987843"
+dependencies = [
+ "mac",
+ "new_debug_unreachable",
+]
+
+[[package]]
+name = "futures-channel"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "07bbe89c50d7a535e539b8c17bc0b49bdb77747034daa8087407d655f3f7cc1d"
+dependencies = [
+ "futures-core",
+ "futures-sink",
+]
+
+[[package]]
+name = "futures-core"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7e3450815272ef58cec6d564423f6e755e25379b217b0bc688e295ba24df6b1d"
+
+[[package]]
+name = "futures-executor"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "baf29c38818342a3b26b5b923639e7b1f4a61fc5e76102d4b1981c6dc7a7579d"
+dependencies = [
+ "futures-core",
+ "futures-task",
+ "futures-util",
+]
+
+[[package]]
+name = "futures-io"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cecba35d7ad927e23624b22ad55235f2239cfa44fd10428eecbeba6d6a717718"
+
+[[package]]
+name = "futures-lite"
+version = "2.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f78e10609fe0e0b3f4157ffab1876319b5b0db102a2c60dc4626306dc46b44ad"
+dependencies = [
+ "fastrand",
+ "futures-core",
+ "futures-io",
+ "parking",
+ "pin-project-lite",
+]
+
+[[package]]
+name = "futures-macro"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e835b70203e41293343137df5c0664546da5745f82ec9b84d40be8336958447b"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "futures-sink"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c39754e157331b013978ec91992bde1ac089843443c49cbc7f46150b0fad0893"
+
+[[package]]
+name = "futures-task"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "037711b3d59c33004d3856fbdc83b99d4ff37a24768fa1be9ce3538a1cde4393"
+
+[[package]]
+name = "futures-util"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "389ca41296e6190b48053de0321d02a77f32f8a5d2461dd38762c0593805c6d6"
+dependencies = [
+ "futures-core",
+ "futures-io",
+ "futures-macro",
+ "futures-sink",
+ "futures-task",
+ "memchr",
+ "pin-project-lite",
+ "slab",
+]
+
+[[package]]
+name = "fxhash"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c31b6d751ae2c7f11320402d34e41349dd1016f8d5d45e48c4312bc8625af50c"
+dependencies = [
+ "byteorder",
+]
+
+[[package]]
+name = "gdk"
+version = "0.18.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d9f245958c627ac99d8e529166f9823fb3b838d1d41fd2b297af3075093c2691"
+dependencies = [
+ "cairo-rs",
+ "gdk-pixbuf",
+ "gdk-sys",
+ "gio",
+ "glib",
+ "libc",
+ "pango",
+]
+
+[[package]]
+name = "gdk-pixbuf"
+version = "0.18.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "50e1f5f1b0bfb830d6ccc8066d18db35c487b1b2b1e8589b5dfe9f07e8defaec"
+dependencies = [
+ "gdk-pixbuf-sys",
+ "gio",
+ "glib",
+ "libc",
+ "once_cell",
+]
+
+[[package]]
+name = "gdk-pixbuf-sys"
+version = "0.18.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3f9839ea644ed9c97a34d129ad56d38a25e6756f99f3a88e15cd39c20629caf7"
+dependencies = [
+ "gio-sys",
+ "glib-sys",
+ "gobject-sys",
+ "libc",
+ "system-deps",
+]
+
+[[package]]
+name = "gdk-sys"
+version = "0.18.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c2d13f38594ac1e66619e188c6d5a1adb98d11b2fcf7894fc416ad76aa2f3f7"
+dependencies = [
+ "cairo-sys-rs",
+ "gdk-pixbuf-sys",
+ "gio-sys",
+ "glib-sys",
+ "gobject-sys",
+ "libc",
+ "pango-sys",
+ "pkg-config",
+ "system-deps",
+]
+
+[[package]]
+name = "gdkwayland-sys"
+version = "0.18.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "140071d506d223f7572b9f09b5e155afbd77428cd5cc7af8f2694c41d98dfe69"
+dependencies = [
+ "gdk-sys",
+ "glib-sys",
+ "gobject-sys",
+ "libc",
+ "pkg-config",
+ "system-deps",
+]
+
+[[package]]
+name = "gdkx11"
+version = "0.18.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3caa00e14351bebbc8183b3c36690327eb77c49abc2268dd4bd36b856db3fbfe"
+dependencies = [
+ "gdk",
+ "gdkx11-sys",
+ "gio",
+ "glib",
+ "libc",
+ "x11",
+]
+
+[[package]]
+name = "gdkx11-sys"
+version = "0.18.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6e2e7445fe01ac26f11601db260dd8608fe172514eb63b3b5e261ea6b0f4428d"
+dependencies = [
+ "gdk-sys",
+ "glib-sys",
+ "libc",
+ "system-deps",
+ "x11",
+]
+
+[[package]]
+name = "generic-array"
+version = "0.14.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a"
+dependencies = [
+ "typenum",
+ "version_check",
+]
+
+[[package]]
+name = "getrandom"
+version = "0.1.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8fc3cb4d91f53b50155bdcfd23f6a4c39ae1969c2ae85982b135750cccaf5fce"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "wasi 0.9.0+wasi-snapshot-preview1",
+]
+
+[[package]]
+name = "getrandom"
+version = "0.2.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ff2abc00be7fca6ebc474524697ae276ad847ad0a6b3faa4bcb027e9a4614ad0"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "wasi 0.11.1+wasi-snapshot-preview1",
+]
+
+[[package]]
+name = "getrandom"
+version = "0.3.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "899def5c37c4fd7b2664648c28120ecec138e4d395b459e5ca34f9cce2dd77fd"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "r-efi 5.3.0",
+ "wasip2",
+]
+
+[[package]]
+name = "getrandom"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0de51e6874e94e7bf76d726fc5d13ba782deca734ff60d5bb2fb2607c7406555"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "r-efi 6.0.0",
+ "wasip2",
+ "wasip3",
+]
+
+[[package]]
+name = "gio"
+version = "0.18.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d4fc8f532f87b79cbc51a79748f16a6828fb784be93145a322fa14d06d354c73"
+dependencies = [
+ "futures-channel",
+ "futures-core",
+ "futures-io",
+ "futures-util",
+ "gio-sys",
+ "glib",
+ "libc",
+ "once_cell",
+ "pin-project-lite",
+ "smallvec",
+ "thiserror 1.0.69",
+]
+
+[[package]]
+name = "gio-sys"
+version = "0.18.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "37566df850baf5e4cb0dfb78af2e4b9898d817ed9263d1090a2df958c64737d2"
+dependencies = [
+ "glib-sys",
+ "gobject-sys",
+ "libc",
+ "system-deps",
+ "winapi",
+]
+
+[[package]]
+name = "glib"
+version = "0.18.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "233daaf6e83ae6a12a52055f568f9d7cf4671dabb78ff9560ab6da230ce00ee5"
+dependencies = [
+ "bitflags 2.11.0",
+ "futures-channel",
+ "futures-core",
+ "futures-executor",
+ "futures-task",
+ "futures-util",
+ "gio-sys",
+ "glib-macros",
+ "glib-sys",
+ "gobject-sys",
+ "libc",
+ "memchr",
+ "once_cell",
+ "smallvec",
+ "thiserror 1.0.69",
+]
+
+[[package]]
+name = "glib-macros"
+version = "0.18.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0bb0228f477c0900c880fd78c8759b95c7636dbd7842707f49e132378aa2acdc"
+dependencies = [
+ "heck 0.4.1",
+ "proc-macro-crate 2.0.2",
+ "proc-macro-error",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "glib-sys"
+version = "0.18.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "063ce2eb6a8d0ea93d2bf8ba1957e78dbab6be1c2220dd3daca57d5a9d869898"
+dependencies = [
+ "libc",
+ "system-deps",
+]
+
+[[package]]
+name = "glob"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0cc23270f6e1808e30a928bdc84dea0b9b4136a8bc82338574f23baf47bbd280"
+
+[[package]]
+name = "gobject-sys"
+version = "0.18.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0850127b514d1c4a4654ead6dedadb18198999985908e6ffe4436f53c785ce44"
+dependencies = [
+ "glib-sys",
+ "libc",
+ "system-deps",
+]
+
+[[package]]
+name = "gtk"
+version = "0.18.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fd56fb197bfc42bd5d2751f4f017d44ff59fbb58140c6b49f9b3b2bdab08506a"
+dependencies = [
+ "atk",
+ "cairo-rs",
+ "field-offset",
+ "futures-channel",
+ "gdk",
+ "gdk-pixbuf",
+ "gio",
+ "glib",
+ "gtk-sys",
+ "gtk3-macros",
+ "libc",
+ "pango",
+ "pkg-config",
+]
+
+[[package]]
+name = "gtk-sys"
+version = "0.18.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8f29a1c21c59553eb7dd40e918be54dccd60c52b049b75119d5d96ce6b624414"
+dependencies = [
+ "atk-sys",
+ "cairo-sys-rs",
+ "gdk-pixbuf-sys",
+ "gdk-sys",
+ "gio-sys",
+ "glib-sys",
+ "gobject-sys",
+ "libc",
+ "pango-sys",
+ "system-deps",
+]
+
+[[package]]
+name = "gtk3-macros"
+version = "0.18.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "52ff3c5b21f14f0736fed6dcfc0bfb4225ebf5725f3c0209edeec181e4d73e9d"
+dependencies = [
+ "proc-macro-crate 1.3.1",
+ "proc-macro-error",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "hashbrown"
+version = "0.12.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8a9ee70c43aaf417c914396645a0fa852624801b24ebb7ae78fe8272889ac888"
+
+[[package]]
+name = "hashbrown"
+version = "0.14.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e5274423e17b7c9fc20b6e7e208532f9b19825d82dfd615708b70edd83df41f1"
+dependencies = [
+ "ahash",
+]
+
+[[package]]
+name = "hashbrown"
+version = "0.15.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9229cfe53dfd69f0609a49f65461bd93001ea1ef889cd5529dd176593f5338a1"
+dependencies = [
+ "foldhash",
+]
+
+[[package]]
+name = "hashbrown"
+version = "0.16.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "841d1cc9bed7f9236f321df977030373f4a4163ae1a7dbfe1a51a2c1a51d9100"
+
+[[package]]
+name = "hashlink"
+version = "0.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6ba4ff7128dee98c7dc9794b6a411377e1404dba1c97deb8d1a55297bd25d8af"
+dependencies = [
+ "hashbrown 0.14.5",
+]
+
+[[package]]
+name = "heck"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "95505c38b4572b2d910cecb0281560f54b440a19336cbbcb27bf6ce6adc6f5a8"
+
+[[package]]
+name = "heck"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
+
+[[package]]
+name = "hermit-abi"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fc0fef456e4baa96da950455cd02c081ca953b141298e41db3fc7e36b1da849c"
+
+[[package]]
+name = "hex"
+version = "0.4.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70"
+
+[[package]]
+name = "html5ever"
+version = "0.29.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3b7410cae13cbc75623c98ac4cbfd1f0bedddf3227afc24f370cf0f50a44a11c"
+dependencies = [
+ "log",
+ "mac",
+ "markup5ever",
+ "match_token",
+]
+
+[[package]]
+name = "http"
+version = "1.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e3ba2a386d7f85a81f119ad7498ebe444d2e22c2af0b86b069416ace48b3311a"
+dependencies = [
+ "bytes",
+ "itoa",
+]
+
+[[package]]
+name = "http-body"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1efedce1fb8e6913f23e0c92de8e62cd5b772a67e7b3946df930a62566c93184"
+dependencies = [
+ "bytes",
+ "http",
+]
+
+[[package]]
+name = "http-body-util"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b021d93e26becf5dc7e1b75b1bed1fd93124b374ceb73f43d4d4eafec896a64a"
+dependencies = [
+ "bytes",
+ "futures-core",
+ "http",
+ "http-body",
+ "pin-project-lite",
+]
+
+[[package]]
+name = "httparse"
+version = "1.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6dbf3de79e51f3d586ab4cb9d5c3e2c14aa28ed23d180cf89b4df0454a69cc87"
+
+[[package]]
+name = "hyper"
+version = "1.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2ab2d4f250c3d7b1c9fcdff1cece94ea4e2dfbec68614f7b87cb205f24ca9d11"
+dependencies = [
+ "atomic-waker",
+ "bytes",
+ "futures-channel",
+ "futures-core",
+ "http",
+ "http-body",
+ "httparse",
+ "itoa",
+ "pin-project-lite",
+ "pin-utils",
+ "smallvec",
+ "tokio",
+ "want",
+]
+
+[[package]]
+name = "hyper-rustls"
+version = "0.27.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e3c93eb611681b207e1fe55d5a71ecf91572ec8a6705cdb6857f7d8d5242cf58"
+dependencies = [
+ "http",
+ "hyper",
+ "hyper-util",
+ "rustls",
+ "rustls-pki-types",
+ "tokio",
+ "tokio-rustls",
+ "tower-service",
+]
+
+[[package]]
+name = "hyper-util"
+version = "0.1.20"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "96547c2556ec9d12fb1578c4eaf448b04993e7fb79cbaad930a656880a6bdfa0"
+dependencies = [
+ "base64 0.22.1",
+ "bytes",
+ "futures-channel",
+ "futures-util",
+ "http",
+ "http-body",
+ "hyper",
+ "ipnet",
+ "libc",
+ "percent-encoding",
+ "pin-project-lite",
+ "socket2",
+ "tokio",
+ "tower-service",
+ "tracing",
+]
+
+[[package]]
+name = "iana-time-zone"
+version = "0.1.65"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e31bc9ad994ba00e440a8aa5c9ef0ec67d5cb5e5cb0cc7f8b744a35b389cc470"
+dependencies = [
+ "android_system_properties",
+ "core-foundation-sys",
+ "iana-time-zone-haiku",
+ "js-sys",
+ "log",
+ "wasm-bindgen",
+ "windows-core 0.62.2",
+]
+
+[[package]]
+name = "iana-time-zone-haiku"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f31827a206f56af32e590ba56d5d2d085f558508192593743f16b2306495269f"
+dependencies = [
+ "cc",
+]
+
+[[package]]
+name = "ico"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3e795dff5605e0f04bff85ca41b51a96b83e80b281e96231bcaaf1ac35103371"
+dependencies = [
+ "byteorder",
+ "png",
+]
+
+[[package]]
+name = "icu_collections"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4c6b649701667bbe825c3b7e6388cb521c23d88644678e83c0c4d0a621a34b43"
+dependencies = [
+ "displaydoc",
+ "potential_utf",
+ "yoke",
+ "zerofrom",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_locale_core"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "edba7861004dd3714265b4db54a3c390e880ab658fec5f7db895fae2046b5bb6"
+dependencies = [
+ "displaydoc",
+ "litemap",
+ "tinystr",
+ "writeable",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_normalizer"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5f6c8828b67bf8908d82127b2054ea1b4427ff0230ee9141c54251934ab1b599"
+dependencies = [
+ "icu_collections",
+ "icu_normalizer_data",
+ "icu_properties",
+ "icu_provider",
+ "smallvec",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_normalizer_data"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7aedcccd01fc5fe81e6b489c15b247b8b0690feb23304303a9e560f37efc560a"
+
+[[package]]
+name = "icu_properties"
+version = "2.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "020bfc02fe870ec3a66d93e677ccca0562506e5872c650f893269e08615d74ec"
+dependencies = [
+ "icu_collections",
+ "icu_locale_core",
+ "icu_properties_data",
+ "icu_provider",
+ "zerotrie",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_properties_data"
+version = "2.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "616c294cf8d725c6afcd8f55abc17c56464ef6211f9ed59cccffe534129c77af"
+
+[[package]]
+name = "icu_provider"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85962cf0ce02e1e0a629cc34e7ca3e373ce20dda4c4d7294bbd0bf1fdb59e614"
+dependencies = [
+ "displaydoc",
+ "icu_locale_core",
+ "writeable",
+ "yoke",
+ "zerofrom",
+ "zerotrie",
+ "zerovec",
+]
+
+[[package]]
+name = "id-arena"
+version = "2.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3d3067d79b975e8844ca9eb072e16b31c3c1c36928edf9c6789548c524d0d954"
+
+[[package]]
+name = "ident_case"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b9e0384b61958566e926dc50660321d12159025e767c18e043daf26b70104c39"
+
+[[package]]
+name = "idna"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3b0875f23caa03898994f6ddc501886a45c7d3d62d04d2d90788d47be1b1e4de"
+dependencies = [
+ "idna_adapter",
+ "smallvec",
+ "utf8_iter",
+]
+
+[[package]]
+name = "idna_adapter"
+version = "1.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3acae9609540aa318d1bc588455225fb2085b9ed0c4f6bd0d9d5bcd86f1a0344"
+dependencies = [
+ "icu_normalizer",
+ "icu_properties",
+]
+
+[[package]]
+name = "indexmap"
+version = "1.9.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bd070e393353796e801d209ad339e89596eb4c8d430d18ede6a1cced8fafbd99"
+dependencies = [
+ "autocfg",
+ "hashbrown 0.12.3",
+ "serde",
+]
+
+[[package]]
+name = "indexmap"
+version = "2.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7714e70437a7dc3ac8eb7e6f8df75fd8eb422675fc7678aff7364301092b1017"
+dependencies = [
+ "equivalent",
+ "hashbrown 0.16.1",
+ "serde",
+ "serde_core",
+]
+
+[[package]]
+name = "infer"
+version = "0.19.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a588916bfdfd92e71cacef98a63d9b1f0d74d6599980d11894290e7ddefffcf7"
+dependencies = [
+ "cfb",
+]
+
+[[package]]
+name = "inotify"
+version = "0.9.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f8069d3ec154eb856955c1c0fbffefbf5f3c40a104ec912d4797314c1801abff"
+dependencies = [
+ "bitflags 1.3.2",
+ "inotify-sys",
+ "libc",
+]
+
+[[package]]
+name = "inotify-sys"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e05c02b5e89bff3b946cedeca278abc628fe811e604f027c45a8aa3cf793d0eb"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "ioctl-rs"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f7970510895cee30b3e9128319f2cefd4bde883a39f38baa279567ba3a7eb97d"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "ipnet"
+version = "2.12.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d98f6fed1fde3f8c21bc40a1abb88dd75e67924f9cffc3ef95607bad8017f8e2"
+
+[[package]]
+name = "iri-string"
+version = "0.7.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c91338f0783edbd6195decb37bae672fd3b165faffb89bf7b9e6942f8b1a731a"
+dependencies = [
+ "memchr",
+ "serde",
+]
+
+[[package]]
+name = "is_terminal_polyfill"
+version = "1.70.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a6cb138bb79a146c1bd460005623e142ef0181e3d0219cb493e02f7d08a35695"
+
+[[package]]
+name = "itertools"
+version = "0.14.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2b192c782037fadd9cfa75548310488aabdbf3d2da73885b31bd0abd03351285"
+dependencies = [
+ "either",
+]
+
+[[package]]
+name = "itoa"
+version = "1.0.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "92ecc6618181def0457392ccd0ee51198e065e016d1d527a7ac1b6dc7c1f09d2"
+
+[[package]]
+name = "javascriptcore-rs"
+version = "1.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ca5671e9ffce8ffba57afc24070e906da7fc4b1ba66f2cabebf61bf2ea257fcc"
+dependencies = [
+ "bitflags 1.3.2",
+ "glib",
+ "javascriptcore-rs-sys",
+]
+
+[[package]]
+name = "javascriptcore-rs-sys"
+version = "1.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "af1be78d14ffa4b75b66df31840478fef72b51f8c2465d4ca7c194da9f7a5124"
+dependencies = [
+ "glib-sys",
+ "gobject-sys",
+ "libc",
+ "system-deps",
+]
+
+[[package]]
+name = "jiff"
+version = "0.2.23"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1a3546dc96b6d42c5f24902af9e2538e82e39ad350b0c766eb3fbf2d8f3d8359"
+dependencies = [
+ "jiff-static",
+ "log",
+ "portable-atomic",
+ "portable-atomic-util",
+ "serde_core",
+]
+
+[[package]]
+name = "jiff-static"
+version = "0.2.23"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2a8c8b344124222efd714b73bb41f8b5120b27a7cc1c75593a6ff768d9d05aa4"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "jni"
+version = "0.21.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1a87aa2bb7d2af34197c04845522473242e1aa17c12f4935d5856491a7fb8c97"
+dependencies = [
+ "cesu8",
+ "cfg-if",
+ "combine",
+ "jni-sys",
+ "log",
+ "thiserror 1.0.69",
+ "walkdir",
+ "windows-sys 0.45.0",
+]
+
+[[package]]
+name = "jni-sys"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8eaf4bc02d17cbdd7ff4c7438cafcdf7fb9a4613313ad11b4f8fefe7d3fa0130"
+
+[[package]]
+name = "js-sys"
+version = "0.3.91"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b49715b7073f385ba4bc528e5747d02e66cb39c6146efb66b781f131f0fb399c"
+dependencies = [
+ "once_cell",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "json-patch"
+version = "3.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "863726d7afb6bc2590eeff7135d923545e5e964f004c2ccf8716c25e70a86f08"
+dependencies = [
+ "jsonptr",
+ "serde",
+ "serde_json",
+ "thiserror 1.0.69",
+]
+
+[[package]]
+name = "jsonptr"
+version = "0.6.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5dea2b27dd239b2556ed7a25ba842fe47fd602e7fc7433c2a8d6106d4d9edd70"
+dependencies = [
+ "serde",
+ "serde_json",
+]
+
+[[package]]
+name = "keyboard-types"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b750dcadc39a09dbadd74e118f6dd6598df77fa01df0cfcdc52c28dece74528a"
+dependencies = [
+ "bitflags 2.11.0",
+ "serde",
+ "unicode-segmentation",
+]
+
+[[package]]
+name = "keyring"
+version = "3.6.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "eebcc3aff044e5944a8fbaf69eb277d11986064cba30c468730e8b9909fb551c"
+dependencies = [
+ "linux-keyutils",
+ "log",
+ "zeroize",
+]
+
+[[package]]
+name = "kqueue"
+version = "1.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "eac30106d7dce88daf4a3fcb4879ea939476d5074a9b7ddd0fb97fa4bed5596a"
+dependencies = [
+ "kqueue-sys",
+ "libc",
+]
+
+[[package]]
+name = "kqueue-sys"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ed9625ffda8729b85e45cf04090035ac368927b8cebc34898e7c120f52e4838b"
+dependencies = [
+ "bitflags 1.3.2",
+ "libc",
+]
+
+[[package]]
+name = "kuchikiki"
+version = "0.8.8-speedreader"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "02cb977175687f33fa4afa0c95c112b987ea1443e5a51c8f8ff27dc618270cc2"
+dependencies = [
+ "cssparser",
+ "html5ever",
+ "indexmap 2.13.0",
+ "selectors",
+]
+
+[[package]]
+name = "landlock"
+version = "0.4.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "49fefd6652c57d68aaa32544a4c0e642929725bdc1fd929367cdeb673ab81088"
+dependencies = [
+ "enumflags2",
+ "libc",
+ "thiserror 2.0.18",
+]
+
+[[package]]
+name = "lazy_static"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe"
+
+[[package]]
+name = "leb128fmt"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "09edd9e8b54e49e587e4f6295a7d29c3ea94d469cb40ab8ca70b288248a81db2"
+
+[[package]]
+name = "libappindicator"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "03589b9607c868cc7ae54c0b2a22c8dc03dd41692d48f2d7df73615c6a95dc0a"
+dependencies = [
+ "glib",
+ "gtk",
+ "gtk-sys",
+ "libappindicator-sys",
+ "log",
+]
+
+[[package]]
+name = "libappindicator-sys"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6e9ec52138abedcc58dc17a7c6c0c00a2bdb4f3427c7f63fa97fd0d859155caf"
+dependencies = [
+ "gtk-sys",
+ "libloading",
+ "once_cell",
+]
+
+[[package]]
+name = "libc"
+version = "0.2.182"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6800badb6cb2082ffd7b6a67e6125bb39f18782f793520caee8cb8846be06112"
+
+[[package]]
+name = "libloading"
+version = "0.7.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b67380fd3b2fbe7527a606e18729d21c6f3951633d0500574c4dc22d2d638b9f"
+dependencies = [
+ "cfg-if",
+ "winapi",
+]
+
+[[package]]
+name = "libredox"
+version = "0.1.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1744e39d1d6a9948f4f388969627434e31128196de472883b39f148769bfe30a"
+dependencies = [
+ "bitflags 2.11.0",
+ "libc",
+ "plain",
+ "redox_syscall 0.7.3",
+]
+
+[[package]]
+name = "libsqlite3-sys"
+version = "0.28.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0c10584274047cb335c23d3e61bcef8e323adae7c5c8c760540f73610177fc3f"
+dependencies = [
+ "cc",
+ "pkg-config",
+ "vcpkg",
+]
+
+[[package]]
+name = "linux-keyutils"
+version = "0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "761e49ec5fd8a5a463f9b84e877c373d888935b71c6be78f3767fe2ae6bed18e"
+dependencies = [
+ "bitflags 2.11.0",
+ "libc",
+]
+
+[[package]]
+name = "linux-raw-sys"
+version = "0.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32a66949e030da00e8c7d4434b251670a91556f4144941d37452769c25d58a53"
+
+[[package]]
+name = "litemap"
+version = "0.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6373607a59f0be73a39b6fe456b8192fcc3585f602af20751600e974dd455e77"
+
+[[package]]
+name = "lock_api"
+version = "0.4.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "224399e74b87b5f3557511d98dff8b14089b3dadafcab6bb93eab67d3aace965"
+dependencies = [
+ "scopeguard",
+]
+
+[[package]]
+name = "log"
+version = "0.4.29"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5e5032e24019045c762d3c0f28f5b6b8bbf38563a65908389bf7978758920897"
+
+[[package]]
+name = "mac"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c41e0c4fef86961ac6d6f8a82609f55f31b05e4fce149ac5710e439df7619ba4"
+
+[[package]]
+name = "mac-notification-sys"
+version = "0.6.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "29a16783dd1a47849b8c8133c9cd3eb2112cfbc6901670af3dba47c8bbfb07d3"
+dependencies = [
+ "cc",
+ "objc2",
+ "objc2-foundation",
+ "time",
+]
+
+[[package]]
+name = "markup5ever"
+version = "0.14.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c7a7213d12e1864c0f002f52c2923d4556935a43dec5e71355c2760e0f6e7a18"
+dependencies = [
+ "log",
+ "phf 0.11.3",
+ "phf_codegen 0.11.3",
+ "string_cache",
+ "string_cache_codegen",
+ "tendril",
+]
+
+[[package]]
+name = "match_token"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "88a9689d8d44bf9964484516275f5cd4c9b59457a6940c1d5d0ecbb94510a36b"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "matchers"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d1525a2a28c7f4fa0fc98bb91ae755d1e2d1505079e05539e35bc876b5d65ae9"
+dependencies = [
+ "regex-automata",
+]
+
+[[package]]
+name = "matches"
+version = "0.1.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2532096657941c2fea9c289d370a250971c689d4f143798ff67113ec042024a5"
+
+[[package]]
+name = "memchr"
+version = "2.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f8ca58f447f06ed17d5fc4043ce1b10dd205e060fb3ce5b979b8ed8e59ff3f79"
+
+[[package]]
+name = "memoffset"
+version = "0.6.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5aa361d4faea93603064a027415f07bd8e1d5c88c9fbf68bf56a285428fd79ce"
+dependencies = [
+ "autocfg",
+]
+
+[[package]]
+name = "memoffset"
+version = "0.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "488016bfae457b036d996092f6cb448677611ce4449e970ceaf42695203f218a"
+dependencies = [
+ "autocfg",
+]
+
+[[package]]
+name = "mime"
+version = "0.3.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6877bb514081ee2a7ff5ef9de3281f14a4dd4bceac4c09388074a6b5df8a139a"
+
+[[package]]
+name = "minisign-verify"
+version = "0.2.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "22f9645cb765ea72b8111f36c522475d2daa0d22c957a9826437e97534bc4e9e"
+
+[[package]]
+name = "miniz_oxide"
+version = "0.8.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fa76a2c86f704bdb222d66965fb3d63269ce38518b83cb0575fca855ebb6316"
+dependencies = [
+ "adler2",
+ "simd-adler32",
+]
+
+[[package]]
+name = "mio"
+version = "0.8.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a4a650543ca06a924e8b371db273b2756685faae30f8487da1b56505a8f78b0c"
+dependencies = [
+ "libc",
+ "log",
+ "wasi 0.11.1+wasi-snapshot-preview1",
+ "windows-sys 0.48.0",
+]
+
+[[package]]
+name = "mio"
+version = "1.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a69bcab0ad47271a0234d9422b131806bf3968021e5dc9328caf2d4cd58557fc"
+dependencies = [
+ "libc",
+ "wasi 0.11.1+wasi-snapshot-preview1",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "muda"
+version = "0.17.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "01c1738382f66ed56b3b9c8119e794a2e23148ac8ea214eda86622d4cb9d415a"
+dependencies = [
+ "crossbeam-channel",
+ "dpi",
+ "gtk",
+ "keyboard-types",
+ "objc2",
+ "objc2-app-kit",
+ "objc2-core-foundation",
+ "objc2-foundation",
+ "once_cell",
+ "png",
+ "serde",
+ "thiserror 2.0.18",
+ "windows-sys 0.60.2",
+]
+
+[[package]]
+name = "native-tls"
+version = "0.2.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "465500e14ea162429d264d44189adc38b199b62b1c21eea9f69e4b73cb03bbf2"
+dependencies = [
+ "libc",
+ "log",
+ "openssl",
+ "openssl-probe",
+ "openssl-sys",
+ "schannel",
+ "security-framework",
+ "security-framework-sys",
+ "tempfile",
+]
+
+[[package]]
+name = "ndk"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c3f42e7bbe13d351b6bead8286a43aac9534b82bd3cc43e47037f012ebfd62d4"
+dependencies = [
+ "bitflags 2.11.0",
+ "jni-sys",
+ "log",
+ "ndk-sys",
+ "num_enum",
+ "raw-window-handle",
+ "thiserror 1.0.69",
+]
+
+[[package]]
+name = "ndk-context"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "27b02d87554356db9e9a873add8782d4ea6e3e58ea071a9adb9a2e8ddb884a8b"
+
+[[package]]
+name = "ndk-sys"
+version = "0.6.0+11769913"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ee6cda3051665f1fb8d9e08fc35c96d5a244fb1be711a03b71118828afc9a873"
+dependencies = [
+ "jni-sys",
+]
+
+[[package]]
+name = "new_debug_unreachable"
+version = "1.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "650eef8c711430f1a879fdd01d4745a7deea475becfb90269c06775983bbf086"
+
+[[package]]
+name = "nix"
+version = "0.25.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f346ff70e7dbfd675fe90590b92d59ef2de15a8779ae305ebcbfd3f0caf59be4"
+dependencies = [
+ "autocfg",
+ "bitflags 1.3.2",
+ "cfg-if",
+ "libc",
+ "memoffset 0.6.5",
+ "pin-utils",
+]
+
+[[package]]
+name = "nodrop"
+version = "0.1.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "72ef4a56884ca558e5ddb05a1d1e7e1bfd9a68d9ed024c21704cc98872dae1bb"
+
+[[package]]
+name = "notify"
+version = "6.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6205bd8bb1e454ad2e27422015fb5e4f2bcc7e08fa8f27058670d208324a4d2d"
+dependencies = [
+ "bitflags 2.11.0",
+ "crossbeam-channel",
+ "filetime",
+ "fsevent-sys",
+ "inotify",
+ "kqueue",
+ "libc",
+ "log",
+ "mio 0.8.11",
+ "walkdir",
+ "windows-sys 0.48.0",
+]
+
+[[package]]
+name = "notify-rust"
+version = "4.12.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "21af20a1b50be5ac5861f74af1a863da53a11c38684d9818d82f1c42f7fdc6c2"
+dependencies = [
+ "futures-lite",
+ "log",
+ "mac-notification-sys",
+ "serde",
+ "tauri-winrt-notification",
+ "zbus",
+]
+
+[[package]]
+name = "nu-ansi-term"
+version = "0.50.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7957b9740744892f114936ab4a57b3f487491bbeafaf8083688b16841a4240e5"
+dependencies = [
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "num-conv"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cf97ec579c3c42f953ef76dbf8d55ac91fb219dde70e49aa4a6b7d74e9919050"
+
+[[package]]
+name = "num-traits"
+version = "0.2.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841"
+dependencies = [
+ "autocfg",
+]
+
+[[package]]
+name = "num_enum"
+version = "0.7.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b1207a7e20ad57b847bbddc6776b968420d38292bbfe2089accff5e19e82454c"
+dependencies = [
+ "num_enum_derive",
+ "rustversion",
+]
+
+[[package]]
+name = "num_enum_derive"
+version = "0.7.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ff32365de1b6743cb203b710788263c44a03de03802daf96092f2da4fe6ba4d7"
+dependencies = [
+ "proc-macro-crate 3.5.0",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "objc2"
+version = "0.6.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3a12a8ed07aefc768292f076dc3ac8c48f3781c8f2d5851dd3d98950e8c5a89f"
+dependencies = [
+ "objc2-encode",
+ "objc2-exception-helper",
+]
+
+[[package]]
+name = "objc2-app-kit"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d49e936b501e5c5bf01fda3a9452ff86dc3ea98ad5f283e1455153142d97518c"
+dependencies = [
+ "bitflags 2.11.0",
+ "block2",
+ "objc2",
+ "objc2-core-foundation",
+ "objc2-foundation",
+]
+
+[[package]]
+name = "objc2-core-foundation"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2a180dd8642fa45cdb7dd721cd4c11b1cadd4929ce112ebd8b9f5803cc79d536"
+dependencies = [
+ "bitflags 2.11.0",
+ "dispatch2",
+ "objc2",
+]
+
+[[package]]
+name = "objc2-core-graphics"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e022c9d066895efa1345f8e33e584b9f958da2fd4cd116792e15e07e4720a807"
+dependencies = [
+ "bitflags 2.11.0",
+ "dispatch2",
+ "objc2",
+ "objc2-core-foundation",
+ "objc2-io-surface",
+]
+
+[[package]]
+name = "objc2-encode"
+version = "4.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ef25abbcd74fb2609453eb695bd2f860d389e457f67dc17cafc8b8cbc89d0c33"
+
+[[package]]
+name = "objc2-exception-helper"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c7a1c5fbb72d7735b076bb47b578523aedc40f3c439bea6dfd595c089d79d98a"
+dependencies = [
+ "cc",
+]
+
+[[package]]
+name = "objc2-foundation"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e3e0adef53c21f888deb4fa59fc59f7eb17404926ee8a6f59f5df0fd7f9f3272"
+dependencies = [
+ "bitflags 2.11.0",
+ "block2",
+ "libc",
+ "objc2",
+ "objc2-core-foundation",
+]
+
+[[package]]
+name = "objc2-io-surface"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "180788110936d59bab6bd83b6060ffdfffb3b922ba1396b312ae795e1de9d81d"
+dependencies = [
+ "bitflags 2.11.0",
+ "objc2",
+ "objc2-core-foundation",
+]
+
+[[package]]
+name = "objc2-osa-kit"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f112d1746737b0da274ef79a23aac283376f335f4095a083a267a082f21db0c0"
+dependencies = [
+ "bitflags 2.11.0",
+ "objc2",
+ "objc2-app-kit",
+ "objc2-foundation",
+]
+
+[[package]]
+name = "objc2-quartz-core"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "96c1358452b371bf9f104e21ec536d37a650eb10f7ee379fff67d2e08d537f1f"
+dependencies = [
+ "bitflags 2.11.0",
+ "objc2",
+ "objc2-core-foundation",
+ "objc2-foundation",
+]
+
+[[package]]
+name = "objc2-ui-kit"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d87d638e33c06f577498cbcc50491496a3ed4246998a7fbba7ccb98b1e7eab22"
+dependencies = [
+ "bitflags 2.11.0",
+ "objc2",
+ "objc2-core-foundation",
+ "objc2-foundation",
+]
+
+[[package]]
+name = "objc2-web-kit"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b2e5aaab980c433cf470df9d7af96a7b46a9d892d521a2cbbb2f8a4c16751e7f"
+dependencies = [
+ "bitflags 2.11.0",
+ "block2",
+ "objc2",
+ "objc2-app-kit",
+ "objc2-core-foundation",
+ "objc2-foundation",
+]
+
+[[package]]
+name = "once_cell"
+version = "1.21.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "42f5e15c9953c5e4ccceeb2e7382a716482c34515315f7b03532b8b4e8393d2d"
+
+[[package]]
+name = "once_cell_polyfill"
+version = "1.70.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "384b8ab6d37215f3c5301a95a4accb5d64aa607f1fcb26a11b5303878451b4fe"
+
+[[package]]
+name = "openssl"
+version = "0.10.75"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "08838db121398ad17ab8531ce9de97b244589089e290a384c900cb9ff7434328"
+dependencies = [
+ "bitflags 2.11.0",
+ "cfg-if",
+ "foreign-types 0.3.2",
+ "libc",
+ "once_cell",
+ "openssl-macros",
+ "openssl-sys",
+]
+
+[[package]]
+name = "openssl-macros"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a948666b637a0f465e8564c73e89d4dde00d72d4d473cc972f390fc3dcee7d9c"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "openssl-probe"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7c87def4c32ab89d880effc9e097653c8da5d6ef28e6b539d313baaacfbafcbe"
+
+[[package]]
+name = "openssl-sys"
+version = "0.9.111"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "82cab2d520aa75e3c58898289429321eb788c3106963d0dc886ec7a5f4adc321"
+dependencies = [
+ "cc",
+ "libc",
+ "pkg-config",
+ "vcpkg",
+]
+
+[[package]]
+name = "opentelemetry"
+version = "0.28.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "236e667b670a5cdf90c258f5a55794ec5ac5027e960c224bff8367a59e1e6426"
+dependencies = [
+ "futures-core",
+ "futures-sink",
+ "js-sys",
+ "pin-project-lite",
+ "thiserror 2.0.18",
+ "tracing",
+]
+
+[[package]]
+name = "opentelemetry-http"
+version = "0.28.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a8863faf2910030d139fb48715ad5ff2f35029fc5f244f6d5f689ddcf4d26253"
+dependencies = [
+ "async-trait",
+ "bytes",
+ "http",
+ "opentelemetry",
+ "reqwest 0.12.28",
+ "tracing",
+]
+
+[[package]]
+name = "opentelemetry-otlp"
+version = "0.28.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5bef114c6d41bea83d6dc60eb41720eedd0261a67af57b66dd2b84ac46c01d91"
+dependencies = [
+ "async-trait",
+ "futures-core",
+ "http",
+ "opentelemetry",
+ "opentelemetry-http",
+ "opentelemetry-proto",
+ "opentelemetry_sdk",
+ "prost",
+ "reqwest 0.12.28",
+ "thiserror 2.0.18",
+ "tracing",
+]
+
+[[package]]
+name = "opentelemetry-proto"
+version = "0.28.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "56f8870d3024727e99212eb3bb1762ec16e255e3e6f58eeb3dc8db1aa226746d"
+dependencies = [
+ "opentelemetry",
+ "opentelemetry_sdk",
+ "prost",
+ "tonic",
+]
+
+[[package]]
+name = "opentelemetry_sdk"
+version = "0.28.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "84dfad6042089c7fc1f6118b7040dc2eb4ab520abbf410b79dc481032af39570"
+dependencies = [
+ "async-trait",
+ "futures-channel",
+ "futures-executor",
+ "futures-util",
+ "glob",
+ "opentelemetry",
+ "percent-encoding",
+ "rand 0.8.5",
+ "serde_json",
+ "thiserror 2.0.18",
+ "tokio",
+ "tokio-stream",
+ "tracing",
+]
+
+[[package]]
+name = "option-ext"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "04744f49eae99ab78e0d5c0b603ab218f515ea8cfe5a456d7629ad883a3b6e7d"
+
+[[package]]
+name = "ordered-stream"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9aa2b01e1d916879f73a53d01d1d6cee68adbb31d6d9177a8cfce093cced1d50"
+dependencies = [
+ "futures-core",
+ "pin-project-lite",
+]
+
+[[package]]
+name = "osakit"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "732c71caeaa72c065bb69d7ea08717bd3f4863a4f451402fc9513e29dbd5261b"
+dependencies = [
+ "objc2",
+ "objc2-foundation",
+ "objc2-osa-kit",
+ "serde",
+ "serde_json",
+ "thiserror 2.0.18",
+]
+
+[[package]]
+name = "pango"
+version = "0.18.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7ca27ec1eb0457ab26f3036ea52229edbdb74dee1edd29063f5b9b010e7ebee4"
+dependencies = [
+ "gio",
+ "glib",
+ "libc",
+ "once_cell",
+ "pango-sys",
+]
+
+[[package]]
+name = "pango-sys"
+version = "0.18.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "436737e391a843e5933d6d9aa102cb126d501e815b83601365a948a518555dc5"
+dependencies = [
+ "glib-sys",
+ "gobject-sys",
+ "libc",
+ "system-deps",
+]
+
+[[package]]
+name = "parking"
+version = "2.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f38d5652c16fde515bb1ecef450ab0f6a219d619a7274976324d5e377f7dceba"
+
+[[package]]
+name = "parking_lot"
+version = "0.12.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "93857453250e3077bd71ff98b6a65ea6621a19bb0f559a85248955ac12c45a1a"
+dependencies = [
+ "lock_api",
+ "parking_lot_core",
+]
+
+[[package]]
+name = "parking_lot_core"
+version = "0.9.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2621685985a2ebf1c516881c026032ac7deafcda1a2c9b7850dc81e3dfcb64c1"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "redox_syscall 0.5.18",
+ "smallvec",
+ "windows-link 0.2.1",
+]
+
+[[package]]
+name = "percent-encoding"
+version = "2.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9b4f627cb1b25917193a259e49bdad08f671f8d9708acfd5fe0a8c1455d87220"
+
+[[package]]
+name = "phf"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3dfb61232e34fcb633f43d12c58f83c1df82962dcdfa565a4e866ffc17dafe12"
+dependencies = [
+ "phf_shared 0.8.0",
+]
+
+[[package]]
+name = "phf"
+version = "0.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fabbf1ead8a5bcbc20f5f8b939ee3f5b0f6f281b6ad3468b84656b658b455259"
+dependencies = [
+ "phf_macros 0.10.0",
+ "phf_shared 0.10.0",
+ "proc-macro-hack",
+]
+
+[[package]]
+name = "phf"
+version = "0.11.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fd6780a80ae0c52cc120a26a1a42c1ae51b247a253e4e06113d23d2c2edd078"
+dependencies = [
+ "phf_macros 0.11.3",
+ "phf_shared 0.11.3",
+]
+
+[[package]]
+name = "phf_codegen"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cbffee61585b0411840d3ece935cce9cb6321f01c45477d30066498cd5e1a815"
+dependencies = [
+ "phf_generator 0.8.0",
+ "phf_shared 0.8.0",
+]
+
+[[package]]
+name = "phf_codegen"
+version = "0.11.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "aef8048c789fa5e851558d709946d6d79a8ff88c0440c587967f8e94bfb1216a"
+dependencies = [
+ "phf_generator 0.11.3",
+ "phf_shared 0.11.3",
+]
+
+[[package]]
+name = "phf_generator"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "17367f0cc86f2d25802b2c26ee58a7b23faeccf78a396094c13dced0d0182526"
+dependencies = [
+ "phf_shared 0.8.0",
+ "rand 0.7.3",
+]
+
+[[package]]
+name = "phf_generator"
+version = "0.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5d5285893bb5eb82e6aaf5d59ee909a06a16737a8970984dd7746ba9283498d6"
+dependencies = [
+ "phf_shared 0.10.0",
+ "rand 0.8.5",
+]
+
+[[package]]
+name = "phf_generator"
+version = "0.11.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3c80231409c20246a13fddb31776fb942c38553c51e871f8cbd687a4cfb5843d"
+dependencies = [
+ "phf_shared 0.11.3",
+ "rand 0.8.5",
+]
+
+[[package]]
+name = "phf_macros"
+version = "0.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "58fdf3184dd560f160dd73922bea2d5cd6e8f064bf4b13110abd81b03697b4e0"
+dependencies = [
+ "phf_generator 0.10.0",
+ "phf_shared 0.10.0",
+ "proc-macro-hack",
+ "proc-macro2",
+ "quote",
+ "syn 1.0.109",
+]
+
+[[package]]
+name = "phf_macros"
+version = "0.11.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f84ac04429c13a7ff43785d75ad27569f2951ce0ffd30a3321230db2fc727216"
+dependencies = [
+ "phf_generator 0.11.3",
+ "phf_shared 0.11.3",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "phf_shared"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c00cf8b9eafe68dde5e9eaa2cef8ee84a9336a47d566ec55ca16589633b65af7"
+dependencies = [
+ "siphasher 0.3.11",
+]
+
+[[package]]
+name = "phf_shared"
+version = "0.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6796ad771acdc0123d2a88dc428b5e38ef24456743ddb1744ed628f9815c096"
+dependencies = [
+ "siphasher 0.3.11",
+]
+
+[[package]]
+name = "phf_shared"
+version = "0.11.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "67eabc2ef2a60eb7faa00097bd1ffdb5bd28e62bf39990626a582201b7a754e5"
+dependencies = [
+ "siphasher 1.0.2",
+]
+
+[[package]]
+name = "pin-project"
+version = "1.1.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f1749c7ed4bcaf4c3d0a3efc28538844fb29bcdd7d2b67b2be7e20ba861ff517"
+dependencies = [
+ "pin-project-internal",
+]
+
+[[package]]
+name = "pin-project-internal"
+version = "1.1.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d9b20ed30f105399776b9c883e68e536ef602a16ae6f596d2c473591d6ad64c6"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "pin-project-lite"
+version = "0.2.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a89322df9ebe1c1578d689c92318e070967d1042b512afbe49518723f4e6d5cd"
+
+[[package]]
+name = "pin-utils"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184"
+
+[[package]]
+name = "piper"
+version = "0.2.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c835479a4443ded371d6c535cbfd8d31ad92c5d23ae9770a61bc155e4992a3c1"
+dependencies = [
+ "atomic-waker",
+ "fastrand",
+ "futures-io",
+]
+
+[[package]]
+name = "pkg-config"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7edddbd0b52d732b21ad9a5fab5c704c14cd949e5e9a1ec5929a24fded1b904c"
+
+[[package]]
+name = "plain"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b4596b6d070b27117e987119b4dac604f3c58cfb0b191112e24771b2faeac1a6"
+
+[[package]]
+name = "plist"
+version = "1.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "740ebea15c5d1428f910cd1a5f52cebf8d25006245ed8ade92702f4943d91e07"
+dependencies = [
+ "base64 0.22.1",
+ "indexmap 2.13.0",
+ "quick-xml 0.38.4",
+ "serde",
+ "time",
+]
+
+[[package]]
+name = "png"
+version = "0.17.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "82151a2fc869e011c153adc57cf2789ccb8d9906ce52c0b39a6b5697749d7526"
+dependencies = [
+ "bitflags 1.3.2",
+ "crc32fast",
+ "fdeflate",
+ "flate2",
+ "miniz_oxide",
+]
+
+[[package]]
+name = "polling"
+version = "3.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5d0e4f59085d47d8241c88ead0f274e8a0cb551f3625263c05eb8dd897c34218"
+dependencies = [
+ "cfg-if",
+ "concurrent-queue",
+ "hermit-abi",
+ "pin-project-lite",
+ "rustix",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "portable-atomic"
+version = "1.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c33a9471896f1c69cecef8d20cbe2f7accd12527ce60845ff44c153bb2a21b49"
+
+[[package]]
+name = "portable-atomic-util"
+version = "0.2.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7a9db96d7fa8782dd8c15ce32ffe8680bbd1e978a43bf51a34d39483540495f5"
+dependencies = [
+ "portable-atomic",
+]
+
+[[package]]
+name = "portable-pty"
+version = "0.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "806ee80c2a03dbe1a9fb9534f8d19e4c0546b790cde8fd1fea9d6390644cb0be"
+dependencies = [
+ "anyhow",
+ "bitflags 1.3.2",
+ "downcast-rs",
+ "filedescriptor",
+ "lazy_static",
+ "libc",
+ "log",
+ "nix",
+ "serial",
+ "shared_library",
+ "shell-words",
+ "winapi",
+ "winreg 0.10.1",
+]
+
+[[package]]
+name = "potential_utf"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b73949432f5e2a09657003c25bca5e19a0e9c84f8058ca374f49e0ebe605af77"
+dependencies = [
+ "zerovec",
+]
+
+[[package]]
+name = "powerfmt"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "439ee305def115ba05938db6eb1644ff94165c5ab5e9420d1c1bcedbba909391"
+
+[[package]]
+name = "ppv-lite86"
+version = "0.2.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85eae3c4ed2f50dcfe72643da4befc30deadb458a9b590d720cde2f2b1e97da9"
+dependencies = [
+ "zerocopy",
+]
+
+[[package]]
+name = "precomputed-hash"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "925383efa346730478fb4838dbe9137d2a47675ad789c546d150a6e1dd4ab31c"
+
+[[package]]
+name = "prettyplease"
+version = "0.2.37"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "479ca8adacdd7ce8f1fb39ce9ecccbfe93a3f1344b3d0d97f20bc0196208f62b"
+dependencies = [
+ "proc-macro2",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "proc-macro-crate"
+version = "1.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7f4c021e1093a56626774e81216a4ce732a735e5bad4868a03f3ed65ca0c3919"
+dependencies = [
+ "once_cell",
+ "toml_edit 0.19.15",
+]
+
+[[package]]
+name = "proc-macro-crate"
+version = "2.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b00f26d3400549137f92511a46ac1cd8ce37cb5598a96d382381458b992a5d24"
+dependencies = [
+ "toml_datetime 0.6.3",
+ "toml_edit 0.20.2",
+]
+
+[[package]]
+name = "proc-macro-crate"
+version = "3.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e67ba7e9b2b56446f1d419b1d807906278ffa1a658a8a5d8a39dcb1f5a78614f"
+dependencies = [
+ "toml_edit 0.25.4+spec-1.1.0",
+]
+
+[[package]]
+name = "proc-macro-error"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "da25490ff9892aab3fcf7c36f08cfb902dd3e71ca0f9f9517bea02a73a5ce38c"
+dependencies = [
+ "proc-macro-error-attr",
+ "proc-macro2",
+ "quote",
+ "syn 1.0.109",
+ "version_check",
+]
+
+[[package]]
+name = "proc-macro-error-attr"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a1be40180e52ecc98ad80b184934baf3d0d29f979574e439af5a55274b35f869"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "version_check",
+]
+
+[[package]]
+name = "proc-macro-hack"
+version = "0.5.20+deprecated"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dc375e1527247fe1a97d8b7156678dfe7c1af2fc075c9a4db3690ecd2a148068"
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.106"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8fd00f0bb2e90d81d1044c2b32617f68fcb9fa3bb7640c23e9c748e53fb30934"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "prost"
+version = "0.13.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2796faa41db3ec313a31f7624d9286acf277b52de526150b7e69f3debf891ee5"
+dependencies = [
+ "bytes",
+ "prost-derive",
+]
+
+[[package]]
+name = "prost-derive"
+version = "0.13.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8a56d757972c98b346a9b766e3f02746cde6dd1cd1d1d563472929fdd74bec4d"
+dependencies = [
+ "anyhow",
+ "itertools",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "quick-xml"
+version = "0.37.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "331e97a1af0bf59823e6eadffe373d7b27f485be8748f71471c662c1f269b7fb"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "quick-xml"
+version = "0.38.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b66c2058c55a409d601666cffe35f04333cf1013010882cec174a7467cd4e21c"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.45"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "41f2619966050689382d2b44f664f4bc593e129785a36d6ee376ddf37259b924"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "r-efi"
+version = "5.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "69cdb34c158ceb288df11e18b4bd39de994f6657d83847bdffdbd7f346754b0f"
+
+[[package]]
+name = "r-efi"
+version = "6.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f8dcc9c7d52a811697d2151c701e0d08956f92b0e24136cf4cf27b57a6a0d9bf"
+
+[[package]]
+name = "rand"
+version = "0.7.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6a6b1679d49b24bbfe0c803429aa1874472f50d9b363131f0e89fc356b544d03"
+dependencies = [
+ "getrandom 0.1.16",
+ "libc",
+ "rand_chacha 0.2.2",
+ "rand_core 0.5.1",
+ "rand_hc",
+ "rand_pcg",
+]
+
+[[package]]
+name = "rand"
+version = "0.8.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404"
+dependencies = [
+ "libc",
+ "rand_chacha 0.3.1",
+ "rand_core 0.6.4",
+]
+
+[[package]]
+name = "rand_chacha"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f4c8ed856279c9737206bf725bf36935d8666ead7aa69b52be55af369d193402"
+dependencies = [
+ "ppv-lite86",
+ "rand_core 0.5.1",
+]
+
+[[package]]
+name = "rand_chacha"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88"
+dependencies = [
+ "ppv-lite86",
+ "rand_core 0.6.4",
+]
+
+[[package]]
+name = "rand_core"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "90bde5296fc891b0cef12a6d03ddccc162ce7b2aff54160af9338f8d40df6d19"
+dependencies = [
+ "getrandom 0.1.16",
+]
+
+[[package]]
+name = "rand_core"
+version = "0.6.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
+dependencies = [
+ "getrandom 0.2.17",
+]
+
+[[package]]
+name = "rand_hc"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ca3129af7b92a17112d59ad498c6f81eaf463253766b90396d39ea7a39d6613c"
+dependencies = [
+ "rand_core 0.5.1",
+]
+
+[[package]]
+name = "rand_pcg"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "16abd0c1b639e9eb4d7c50c0b8100b0d0f849be2349829c740fe8e6eb4816429"
+dependencies = [
+ "rand_core 0.5.1",
+]
+
+[[package]]
+name = "raw-window-handle"
+version = "0.6.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "20675572f6f24e9e76ef639bc5552774ed45f1c30e2951e1e99c59888861c539"
+
+[[package]]
+name = "redox_syscall"
+version = "0.5.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ed2bf2547551a7053d6fdfafda3f938979645c44812fbfcda098faae3f1a362d"
+dependencies = [
+ "bitflags 2.11.0",
+]
+
+[[package]]
+name = "redox_syscall"
+version = "0.7.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6ce70a74e890531977d37e532c34d45e9055d2409ed08ddba14529471ed0be16"
+dependencies = [
+ "bitflags 2.11.0",
+]
+
+[[package]]
+name = "redox_users"
+version = "0.4.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ba009ff324d1fc1b900bd1fdb31564febe58a8ccc8a6fdbb93b543d33b13ca43"
+dependencies = [
+ "getrandom 0.2.17",
+ "libredox",
+ "thiserror 1.0.69",
+]
+
+[[package]]
+name = "redox_users"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a4e608c6638b9c18977b00b475ac1f28d14e84b27d8d42f70e0bf1e3dec127ac"
+dependencies = [
+ "getrandom 0.2.17",
+ "libredox",
+ "thiserror 2.0.18",
+]
+
+[[package]]
+name = "ref-cast"
+version = "1.0.25"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f354300ae66f76f1c85c5f84693f0ce81d747e2c3f21a45fef496d89c960bf7d"
+dependencies = [
+ "ref-cast-impl",
+]
+
+[[package]]
+name = "ref-cast-impl"
+version = "1.0.25"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b7186006dcb21920990093f30e3dea63b7d6e977bf1256be20c3563a5db070da"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "regex"
+version = "1.12.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e10754a14b9137dd7b1e3e5b0493cc9171fdd105e0ab477f51b72e7f3ac0e276"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-automata",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-automata"
+version = "0.4.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6e1dd4122fc1595e8162618945476892eefca7b88c52820e74af6262213cae8f"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-syntax"
+version = "0.8.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dc897dd8d9e8bd1ed8cdad82b5966c3e0ecae09fb1907d58efaa013543185d0a"
+
+[[package]]
+name = "reqwest"
+version = "0.12.28"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "eddd3ca559203180a307f12d114c268abf583f59b03cb906fd0b3ff8646c1147"
+dependencies = [
+ "base64 0.22.1",
+ "bytes",
+ "futures-channel",
+ "futures-core",
+ "futures-util",
+ "http",
+ "http-body",
+ "http-body-util",
+ "hyper",
+ "hyper-util",
+ "js-sys",
+ "log",
+ "percent-encoding",
+ "pin-project-lite",
+ "serde",
+ "serde_json",
+ "serde_urlencoded",
+ "sync_wrapper",
+ "tokio",
+ "tower",
+ "tower-http",
+ "tower-service",
+ "url",
+ "wasm-bindgen",
+ "wasm-bindgen-futures",
+ "web-sys",
+]
+
+[[package]]
+name = "reqwest"
+version = "0.13.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ab3f43e3283ab1488b624b44b0e988d0acea0b3214e694730a055cb6b2efa801"
+dependencies = [
+ "base64 0.22.1",
+ "bytes",
+ "futures-core",
+ "futures-util",
+ "http",
+ "http-body",
+ "http-body-util",
+ "hyper",
+ "hyper-rustls",
+ "hyper-util",
+ "js-sys",
+ "log",
+ "percent-encoding",
+ "pin-project-lite",
+ "rustls",
+ "rustls-pki-types",
+ "rustls-platform-verifier",
+ "serde",
+ "serde_json",
+ "sync_wrapper",
+ "tokio",
+ "tokio-rustls",
+ "tokio-util",
+ "tower",
+ "tower-http",
+ "tower-service",
+ "url",
+ "wasm-bindgen",
+ "wasm-bindgen-futures",
+ "wasm-streams",
+ "web-sys",
+]
+
+[[package]]
+name = "rfd"
+version = "0.16.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a15ad77d9e70a92437d8f74c35d99b4e4691128df018833e99f90bcd36152672"
+dependencies = [
+ "block2",
+ "dispatch2",
+ "glib-sys",
+ "gobject-sys",
+ "gtk-sys",
+ "js-sys",
+ "log",
+ "objc2",
+ "objc2-app-kit",
+ "objc2-core-foundation",
+ "objc2-foundation",
+ "raw-window-handle",
+ "wasm-bindgen",
+ "wasm-bindgen-futures",
+ "web-sys",
+ "windows-sys 0.60.2",
+]
+
+[[package]]
+name = "ring"
+version = "0.17.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a4689e6c2294d81e88dc6261c768b63bc4fcdb852be6d1352498b114f61383b7"
+dependencies = [
+ "cc",
+ "cfg-if",
+ "getrandom 0.2.17",
+ "libc",
+ "untrusted",
+ "windows-sys 0.52.0",
+]
+
+[[package]]
+name = "rusqlite"
+version = "0.31.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b838eba278d213a8beaf485bd313fd580ca4505a00d5871caeb1457c55322cae"
+dependencies = [
+ "bitflags 2.11.0",
+ "chrono",
+ "csv",
+ "fallible-iterator",
+ "fallible-streaming-iterator",
+ "hashlink",
+ "libsqlite3-sys",
+ "serde_json",
+ "smallvec",
+ "time",
+ "url",
+ "uuid",
+]
+
+[[package]]
+name = "rustc_version"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cfcb3a22ef46e85b45de6ee7e79d063319ebb6594faafcf1c225ea92ab6e9b92"
+dependencies = [
+ "semver",
+]
+
+[[package]]
+name = "rustix"
+version = "1.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6fe4565b9518b83ef4f91bb47ce29620ca828bd32cb7e408f0062e9930ba190"
+dependencies = [
+ "bitflags 2.11.0",
+ "errno",
+ "libc",
+ "linux-raw-sys",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "rustls"
+version = "0.23.37"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "758025cb5fccfd3bc2fd74708fd4682be41d99e5dff73c377c0646c6012c73a4"
+dependencies = [
+ "once_cell",
+ "ring",
+ "rustls-pki-types",
+ "rustls-webpki",
+ "subtle",
+ "zeroize",
+]
+
+[[package]]
+name = "rustls-native-certs"
+version = "0.8.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "612460d5f7bea540c490b2b6395d8e34a953e52b491accd6c86c8164c5932a63"
+dependencies = [
+ "openssl-probe",
+ "rustls-pki-types",
+ "schannel",
+ "security-framework",
+]
+
+[[package]]
+name = "rustls-pki-types"
+version = "1.14.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "be040f8b0a225e40375822a563fa9524378b9d63112f53e19ffff34df5d33fdd"
+dependencies = [
+ "zeroize",
+]
+
+[[package]]
+name = "rustls-platform-verifier"
+version = "0.6.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1d99feebc72bae7ab76ba994bb5e121b8d83d910ca40b36e0921f53becc41784"
+dependencies = [
+ "core-foundation",
+ "core-foundation-sys",
+ "jni",
+ "log",
+ "once_cell",
+ "rustls",
+ "rustls-native-certs",
+ "rustls-platform-verifier-android",
+ "rustls-webpki",
+ "security-framework",
+ "security-framework-sys",
+ "webpki-root-certs",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "rustls-platform-verifier-android"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f87165f0995f63a9fbeea62b64d10b4d9d8e78ec6d7d51fb2125fda7bb36788f"
+
+[[package]]
+name = "rustls-webpki"
+version = "0.103.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d7df23109aa6c1567d1c575b9952556388da57401e4ace1d15f79eedad0d8f53"
+dependencies = [
+ "ring",
+ "rustls-pki-types",
+ "untrusted",
+]
+
+[[package]]
+name = "rustversion"
+version = "1.0.22"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b39cdef0fa800fc44525c84ccb54a029961a8215f9619753635a9c0d2538d46d"
+
+[[package]]
+name = "ryu"
+version = "1.0.23"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9774ba4a74de5f7b1c1451ed6cd5285a32eddb5cccb8cc655a4e50009e06477f"
+
+[[package]]
+name = "same-file"
+version = "1.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "93fc1dc3aaa9bfed95e02e6eadabb4baf7e3078b0bd1b4d7b6b0b68378900502"
+dependencies = [
+ "winapi-util",
+]
+
+[[package]]
+name = "schannel"
+version = "0.1.28"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "891d81b926048e76efe18581bf793546b4c0eaf8448d72be8de2bbee5fd166e1"
+dependencies = [
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "schemars"
+version = "0.8.22"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3fbf2ae1b8bc8e02df939598064d22402220cd5bbcca1c76f7d6a310974d5615"
+dependencies = [
+ "dyn-clone",
+ "indexmap 1.9.3",
+ "schemars_derive",
+ "serde",
+ "serde_json",
+ "url",
+ "uuid",
+]
+
+[[package]]
+name = "schemars"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4cd191f9397d57d581cddd31014772520aa448f65ef991055d7f61582c65165f"
+dependencies = [
+ "dyn-clone",
+ "ref-cast",
+ "serde",
+ "serde_json",
+]
+
+[[package]]
+name = "schemars"
+version = "1.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a2b42f36aa1cd011945615b92222f6bf73c599a102a300334cd7f8dbeec726cc"
+dependencies = [
+ "dyn-clone",
+ "ref-cast",
+ "serde",
+ "serde_json",
+]
+
+[[package]]
+name = "schemars_derive"
+version = "0.8.22"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32e265784ad618884abaea0600a9adf15393368d840e0222d101a072f3f7534d"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "serde_derive_internals",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "scopeguard"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49"
+
+[[package]]
+name = "security-framework"
+version = "3.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b7f4bc775c73d9a02cde8bf7b2ec4c9d12743edf609006c7facc23998404cd1d"
+dependencies = [
+ "bitflags 2.11.0",
+ "core-foundation",
+ "core-foundation-sys",
+ "libc",
+ "security-framework-sys",
+]
+
+[[package]]
+name = "security-framework-sys"
+version = "2.17.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6ce2691df843ecc5d231c0b14ece2acc3efb62c0a398c7e1d875f3983ce020e3"
+dependencies = [
+ "core-foundation-sys",
+ "libc",
+]
+
+[[package]]
+name = "selectors"
+version = "0.24.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0c37578180969d00692904465fb7f6b3d50b9a2b952b87c23d0e2e5cb5013416"
+dependencies = [
+ "bitflags 1.3.2",
+ "cssparser",
+ "derive_more",
+ "fxhash",
+ "log",
+ "phf 0.8.0",
+ "phf_codegen 0.8.0",
+ "precomputed-hash",
+ "servo_arc",
+ "smallvec",
+]
+
+[[package]]
+name = "semver"
+version = "1.0.27"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d767eb0aabc880b29956c35734170f26ed551a859dbd361d140cdbeca61ab1e2"
+dependencies = [
+ "serde",
+ "serde_core",
+]
+
+[[package]]
+name = "serde"
+version = "1.0.228"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9a8e94ea7f378bd32cbbd37198a4a91436180c5bb472411e48b5ec2e2124ae9e"
+dependencies = [
+ "serde_core",
+ "serde_derive",
+]
+
+[[package]]
+name = "serde-untagged"
+version = "0.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f9faf48a4a2d2693be24c6289dbe26552776eb7737074e6722891fadbe6c5058"
+dependencies = [
+ "erased-serde",
+ "serde",
+ "serde_core",
+ "typeid",
+]
+
+[[package]]
+name = "serde_core"
+version = "1.0.228"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "41d385c7d4ca58e59fc732af25c3983b67ac852c1a25000afe1175de458b67ad"
+dependencies = [
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_derive"
+version = "1.0.228"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d540f220d3187173da220f885ab66608367b6574e925011a9353e4badda91d79"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "serde_derive_internals"
+version = "0.29.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "18d26a20a969b9e3fdf2fc2d9f21eda6c40e2de84c9408bb5d3b05d499aae711"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "serde_json"
+version = "1.0.149"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "83fc039473c5595ace860d8c4fafa220ff474b3fc6bfdb4293327f1a37e94d86"
+dependencies = [
+ "itoa",
+ "memchr",
+ "serde",
+ "serde_core",
+ "zmij",
+]
+
+[[package]]
+name = "serde_repr"
+version = "0.1.20"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "175ee3e80ae9982737ca543e96133087cbd9a485eecc3bc4de9c1a37b47ea59c"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "serde_spanned"
+version = "0.6.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bf41e0cfaf7226dca15e8197172c295a782857fcb97fad1808a166870dee75a3"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "serde_spanned"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f8bbf91e5a4d6315eee45e704372590b30e260ee83af6639d64557f51b067776"
+dependencies = [
+ "serde_core",
+]
+
+[[package]]
+name = "serde_urlencoded"
+version = "0.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d3491c14715ca2294c4d6a88f15e84739788c1d030eed8c110436aafdaa2f3fd"
+dependencies = [
+ "form_urlencoded",
+ "itoa",
+ "ryu",
+ "serde",
+]
+
+[[package]]
+name = "serde_with"
+version = "3.17.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "381b283ce7bc6b476d903296fb59d0d36633652b633b27f64db4fb46dcbfc3b9"
+dependencies = [
+ "base64 0.22.1",
+ "chrono",
+ "hex",
+ "indexmap 1.9.3",
+ "indexmap 2.13.0",
+ "schemars 0.9.0",
+ "schemars 1.2.1",
+ "serde_core",
+ "serde_json",
+ "serde_with_macros",
+ "time",
+]
+
+[[package]]
+name = "serde_with_macros"
+version = "3.17.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a6d4e30573c8cb306ed6ab1dca8423eec9a463ea0e155f45399455e0368b27e0"
+dependencies = [
+ "darling",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "serial"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a1237a96570fc377c13baa1b88c7589ab66edced652e43ffb17088f003db3e86"
+dependencies = [
+ "serial-core",
+ "serial-unix",
+ "serial-windows",
+]
+
+[[package]]
+name = "serial-core"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3f46209b345401737ae2125fe5b19a77acce90cd53e1658cda928e4fe9a64581"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "serial-unix"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f03fbca4c9d866e24a459cbca71283f545a37f8e3e002ad8c70593871453cab7"
+dependencies = [
+ "ioctl-rs",
+ "libc",
+ "serial-core",
+ "termios",
+]
+
+[[package]]
+name = "serial-windows"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "15c6d3b776267a75d31bbdfd5d36c0ca051251caafc285827052bc53bcdc8162"
+dependencies = [
+ "libc",
+ "serial-core",
+]
+
+[[package]]
+name = "serialize-to-javascript"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "04f3666a07a197cdb77cdf306c32be9b7f598d7060d50cfd4d5aa04bfd92f6c5"
+dependencies = [
+ "serde",
+ "serde_json",
+ "serialize-to-javascript-impl",
+]
+
+[[package]]
+name = "serialize-to-javascript-impl"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "772ee033c0916d670af7860b6e1ef7d658a4629a6d0b4c8c3e67f09b3765b75d"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "servo_arc"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d52aa42f8fdf0fed91e5ce7f23d8138441002fa31dca008acf47e6fd4721f741"
+dependencies = [
+ "nodrop",
+ "stable_deref_trait",
+]
+
+[[package]]
+name = "sha1"
+version = "0.10.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e3bf829a2d51ab4a5ddf1352d8470c140cadc8301b2ae1789db023f01cedd6ba"
+dependencies = [
+ "cfg-if",
+ "cpufeatures",
+ "digest",
+]
+
+[[package]]
+name = "sha2"
+version = "0.10.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a7507d819769d01a365ab707794a4084392c824f54a7a6a7862f8c3d0892b283"
+dependencies = [
+ "cfg-if",
+ "cpufeatures",
+ "digest",
+]
+
+[[package]]
+name = "sharded-slab"
+version = "0.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f40ca3c46823713e0d4209592e8d6e826aa57e928f09752619fc696c499637f6"
+dependencies = [
+ "lazy_static",
+]
+
+[[package]]
+name = "shared_library"
+version = "0.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5a9e7e0f2bfae24d8a5b5a66c5b257a83c7412304311512a0c054cd5e619da11"
+dependencies = [
+ "lazy_static",
+ "libc",
+]
+
+[[package]]
+name = "shell-words"
+version = "1.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dc6fe69c597f9c37bfeeeeeb33da3530379845f10be461a66d16d03eca2ded77"
+
+[[package]]
+name = "shlex"
+version = "1.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"
+
+[[package]]
+name = "signal-hook-registry"
+version = "1.4.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c4db69cba1110affc0e9f7bcd48bbf87b3f4fc7c61fc9155afd4c469eb3d6c1b"
+dependencies = [
+ "errno",
+ "libc",
+]
+
+[[package]]
+name = "simd-adler32"
+version = "0.3.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e320a6c5ad31d271ad523dcf3ad13e2767ad8b1cb8f047f75a8aeaf8da139da2"
+
+[[package]]
+name = "siphasher"
+version = "0.3.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "38b58827f4464d87d377d175e90bf58eb00fd8716ff0a62f80356b5e61555d0d"
+
+[[package]]
+name = "siphasher"
+version = "1.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b2aa850e253778c88a04c3d7323b043aeda9d3e30d5971937c1855769763678e"
+
+[[package]]
+name = "slab"
+version = "0.4.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0c790de23124f9ab44544d7ac05d60440adc586479ce501c1d6d7da3cd8c9cf5"
+
+[[package]]
+name = "smallvec"
+version = "1.15.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "67b1b7a3b5fe4f1376887184045fcf45c69e92af734b7aaddc05fb777b6fbd03"
+
+[[package]]
+name = "socket2"
+version = "0.6.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "86f4aa3ad99f2088c990dfa82d367e19cb29268ed67c574d10d0a4bfe71f07e0"
+dependencies = [
+ "libc",
+ "windows-sys 0.60.2",
+]
+
+[[package]]
+name = "softbuffer"
+version = "0.4.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "aac18da81ebbf05109ab275b157c22a653bb3c12cf884450179942f81bcbf6c3"
+dependencies = [
+ "bytemuck",
+ "js-sys",
+ "ndk",
+ "objc2",
+ "objc2-core-foundation",
+ "objc2-core-graphics",
+ "objc2-foundation",
+ "objc2-quartz-core",
+ "raw-window-handle",
+ "redox_syscall 0.5.18",
+ "tracing",
+ "wasm-bindgen",
+ "web-sys",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "soup3"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "471f924a40f31251afc77450e781cb26d55c0b650842efafc9c6cbd2f7cc4f9f"
+dependencies = [
+ "futures-channel",
+ "gio",
+ "glib",
+ "libc",
+ "soup3-sys",
+]
+
+[[package]]
+name = "soup3-sys"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7ebe8950a680a12f24f15ebe1bf70db7af98ad242d9db43596ad3108aab86c27"
+dependencies = [
+ "gio-sys",
+ "glib-sys",
+ "gobject-sys",
+ "libc",
+ "system-deps",
+]
+
+[[package]]
+name = "stable_deref_trait"
+version = "1.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6ce2be8dc25455e1f91df71bfa12ad37d7af1092ae736f3a6cd0e37bc7810596"
+
+[[package]]
+name = "string_cache"
+version = "0.8.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bf776ba3fa74f83bf4b63c3dcbbf82173db2632ed8452cb2d891d33f459de70f"
+dependencies = [
+ "new_debug_unreachable",
+ "parking_lot",
+ "phf_shared 0.11.3",
+ "precomputed-hash",
+ "serde",
+]
+
+[[package]]
+name = "string_cache_codegen"
+version = "0.5.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c711928715f1fe0fe509c53b43e993a9a557babc2d0a3567d0a3006f1ac931a0"
+dependencies = [
+ "phf_generator 0.11.3",
+ "phf_shared 0.11.3",
+ "proc-macro2",
+ "quote",
+]
+
+[[package]]
+name = "strsim"
+version = "0.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7da8b5736845d9f2fcb837ea5d9e2628564b3b043a70948a3f0b778838c5fb4f"
+
+[[package]]
+name = "subtle"
+version = "2.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "13c2bddecc57b384dee18652358fb23172facb8a2c51ccc10d74c157bdea3292"
+
+[[package]]
+name = "swift-rs"
+version = "1.0.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4057c98e2e852d51fdcfca832aac7b571f6b351ad159f9eda5db1655f8d0c4d7"
+dependencies = [
+ "base64 0.21.7",
+ "serde",
+ "serde_json",
+]
+
+[[package]]
+name = "syn"
+version = "1.0.109"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "72b64191b275b66ffe2469e8af2c1cfe3bafa67b529ead792a6d0160888b4237"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "syn"
+version = "2.0.117"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e665b8803e7b1d2a727f4023456bbbbe74da67099c585258af0ad9c5013b9b99"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "sync_wrapper"
+version = "1.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0bf256ce5efdfa370213c1dabab5935a12e49f2c58d15e9eac2870d3b4f27263"
+dependencies = [
+ "futures-core",
+]
+
+[[package]]
+name = "synstructure"
+version = "0.13.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "728a70f3dbaf5bab7f0c4b1ac8d7ae5ea60a4b5549c8a5914361c99147a709d2"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "system-deps"
+version = "6.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a3e535eb8dded36d55ec13eddacd30dec501792ff23a0b1682c38601b8cf2349"
+dependencies = [
+ "cfg-expr",
+ "heck 0.5.0",
+ "pkg-config",
+ "toml 0.8.2",
+ "version-compare",
+]
+
+[[package]]
+name = "tao"
+version = "0.34.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6e06d52c379e63da659a483a958110bbde891695a0ecb53e48cc7786d5eda7bb"
+dependencies = [
+ "bitflags 2.11.0",
+ "block2",
+ "core-foundation",
+ "core-graphics",
+ "crossbeam-channel",
+ "dispatch2",
+ "dlopen2",
+ "dpi",
+ "gdkwayland-sys",
+ "gdkx11-sys",
+ "gtk",
+ "jni",
+ "libc",
+ "log",
+ "ndk",
+ "ndk-context",
+ "ndk-sys",
+ "objc2",
+ "objc2-app-kit",
+ "objc2-foundation",
+ "once_cell",
+ "parking_lot",
+ "raw-window-handle",
+ "tao-macros",
+ "unicode-segmentation",
+ "url",
+ "windows",
+ "windows-core 0.61.2",
+ "windows-version",
+ "x11-dl",
+]
+
+[[package]]
+name = "tao-macros"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f4e16beb8b2ac17db28eab8bca40e62dbfbb34c0fcdc6d9826b11b7b5d047dfd"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "tar"
+version = "0.4.44"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1d863878d212c87a19c1a610eb53bb01fe12951c0501cf5a0d65f724914a667a"
+dependencies = [
+ "filetime",
+ "libc",
+ "xattr",
+]
+
+[[package]]
+name = "target-lexicon"
+version = "0.12.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "61c41af27dd6d1e27b1b16b489db798443478cef1f06a660c96db617ba5de3b1"
+
+[[package]]
+name = "tauri"
+version = "2.10.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "da77cc00fb9028caf5b5d4650f75e31f1ef3693459dfca7f7e506d1ecef0ba2d"
+dependencies = [
+ "anyhow",
+ "bytes",
+ "cookie",
+ "dirs 6.0.0",
+ "dunce",
+ "embed_plist",
+ "getrandom 0.3.4",
+ "glob",
+ "gtk",
+ "heck 0.5.0",
+ "http",
+ "jni",
+ "libc",
+ "log",
+ "mime",
+ "muda",
+ "objc2",
+ "objc2-app-kit",
+ "objc2-foundation",
+ "objc2-ui-kit",
+ "objc2-web-kit",
+ "percent-encoding",
+ "plist",
+ "raw-window-handle",
+ "reqwest 0.13.2",
+ "serde",
+ "serde_json",
+ "serde_repr",
+ "serialize-to-javascript",
+ "swift-rs",
+ "tauri-build",
+ "tauri-macros",
+ "tauri-runtime",
+ "tauri-runtime-wry",
+ "tauri-utils",
+ "thiserror 2.0.18",
+ "tokio",
+ "tray-icon",
+ "url",
+ "webkit2gtk",
+ "webview2-com",
+ "window-vibrancy",
+ "windows",
+]
+
+[[package]]
+name = "tauri-build"
+version = "2.5.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4bbc990d1dbf57a8e1c7fa2327f2a614d8b757805603c1b9ba5c81bade09fd4d"
+dependencies = [
+ "anyhow",
+ "cargo_toml",
+ "dirs 6.0.0",
+ "glob",
+ "heck 0.5.0",
+ "json-patch",
+ "schemars 0.8.22",
+ "semver",
+ "serde",
+ "serde_json",
+ "tauri-utils",
+ "tauri-winres",
+ "toml 0.9.12+spec-1.1.0",
+ "walkdir",
+]
+
+[[package]]
+name = "tauri-codegen"
+version = "2.5.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d4a24476afd977c5d5d169f72425868613d82747916dd29e0a357c84c4bd6d29"
+dependencies = [
+ "base64 0.22.1",
+ "brotli",
+ "ico",
+ "json-patch",
+ "plist",
+ "png",
+ "proc-macro2",
+ "quote",
+ "semver",
+ "serde",
+ "serde_json",
+ "sha2",
+ "syn 2.0.117",
+ "tauri-utils",
+ "thiserror 2.0.18",
+ "time",
+ "url",
+ "uuid",
+ "walkdir",
+]
+
+[[package]]
+name = "tauri-macros"
+version = "2.5.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d39b349a98dadaffebb73f0a40dcd1f23c999211e5a2e744403db384d0c33de7"
+dependencies = [
+ "heck 0.5.0",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+ "tauri-codegen",
+ "tauri-utils",
+]
+
+[[package]]
+name = "tauri-plugin"
+version = "2.5.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ddde7d51c907b940fb573006cdda9a642d6a7c8153657e88f8a5c3c9290cd4aa"
+dependencies = [
+ "anyhow",
+ "glob",
+ "plist",
+ "schemars 0.8.22",
+ "serde",
+ "serde_json",
+ "tauri-utils",
+ "toml 0.9.12+spec-1.1.0",
+ "walkdir",
+]
+
+[[package]]
+name = "tauri-plugin-dialog"
+version = "2.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9204b425d9be8d12aa60c2a83a289cf7d1caae40f57f336ed1155b3a5c0e359b"
+dependencies = [
+ "log",
+ "raw-window-handle",
+ "rfd",
+ "serde",
+ "serde_json",
+ "tauri",
+ "tauri-plugin",
+ "tauri-plugin-fs",
+ "thiserror 2.0.18",
+ "url",
+]
+
+[[package]]
+name = "tauri-plugin-fs"
+version = "2.4.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ed390cc669f937afeb8b28032ce837bac8ea023d975a2e207375ec05afaf1804"
+dependencies = [
+ "anyhow",
+ "dunce",
+ "glob",
+ "percent-encoding",
+ "schemars 0.8.22",
+ "serde",
+ "serde_json",
+ "serde_repr",
+ "tauri",
+ "tauri-plugin",
+ "tauri-utils",
+ "thiserror 2.0.18",
+ "toml 0.9.12+spec-1.1.0",
+ "url",
+]
+
+[[package]]
+name = "tauri-plugin-updater"
+version = "2.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3fe8e9bebd88fc222938ffdfbdcfa0307081423bd01e3252fc337d8bde81fc61"
+dependencies = [
+ "base64 0.22.1",
+ "dirs 6.0.0",
+ "flate2",
+ "futures-util",
+ "http",
+ "infer",
+ "log",
+ "minisign-verify",
+ "osakit",
+ "percent-encoding",
+ "reqwest 0.13.2",
+ "rustls",
+ "semver",
+ "serde",
+ "serde_json",
+ "tar",
+ "tauri",
+ "tauri-plugin",
+ "tempfile",
+ "thiserror 2.0.18",
+ "time",
+ "tokio",
+ "url",
+ "windows-sys 0.60.2",
+ "zip",
+]
+
+[[package]]
+name = "tauri-runtime"
+version = "2.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2826d79a3297ed08cd6ea7f412644ef58e32969504bc4fbd8d7dbeabc4445ea2"
+dependencies = [
+ "cookie",
+ "dpi",
+ "gtk",
+ "http",
+ "jni",
+ "objc2",
+ "objc2-ui-kit",
+ "objc2-web-kit",
+ "raw-window-handle",
+ "serde",
+ "serde_json",
+ "tauri-utils",
+ "thiserror 2.0.18",
+ "url",
+ "webkit2gtk",
+ "webview2-com",
+ "windows",
+]
+
+[[package]]
+name = "tauri-runtime-wry"
+version = "2.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e11ea2e6f801d275fdd890d6c9603736012742a1c33b96d0db788c9cdebf7f9e"
+dependencies = [
+ "gtk",
+ "http",
+ "jni",
+ "log",
+ "objc2",
+ "objc2-app-kit",
+ "once_cell",
+ "percent-encoding",
+ "raw-window-handle",
+ "softbuffer",
+ "tao",
+ "tauri-runtime",
+ "tauri-utils",
+ "url",
+ "webkit2gtk",
+ "webview2-com",
+ "windows",
+ "wry",
+]
+
+[[package]]
+name = "tauri-utils"
+version = "2.8.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "219a1f983a2af3653f75b5747f76733b0da7ff03069c7a41901a5eb3ace4557d"
+dependencies = [
+ "anyhow",
+ "brotli",
+ "cargo_metadata",
+ "ctor",
+ "dunce",
+ "glob",
+ "html5ever",
+ "http",
+ "infer",
+ "json-patch",
+ "kuchikiki",
+ "log",
+ "memchr",
+ "phf 0.11.3",
+ "proc-macro2",
+ "quote",
+ "regex",
+ "schemars 0.8.22",
+ "semver",
+ "serde",
+ "serde-untagged",
+ "serde_json",
+ "serde_with",
+ "swift-rs",
+ "thiserror 2.0.18",
+ "toml 0.9.12+spec-1.1.0",
+ "url",
+ "urlpattern",
+ "uuid",
+ "walkdir",
+]
+
+[[package]]
+name = "tauri-winres"
+version = "0.3.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1087b111fe2b005e42dbdc1990fc18593234238d47453b0c99b7de1c9ab2c1e0"
+dependencies = [
+ "dunce",
+ "embed-resource",
+ "toml 0.9.12+spec-1.1.0",
+]
+
+[[package]]
+name = "tauri-winrt-notification"
+version = "0.7.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b1e66e07de489fe43a46678dd0b8df65e0c973909df1b60ba33874e297ba9b9"
+dependencies = [
+ "quick-xml 0.37.5",
+ "thiserror 2.0.18",
+ "windows",
+ "windows-version",
+]
+
+[[package]]
+name = "tempfile"
+version = "3.26.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "82a72c767771b47409d2345987fda8628641887d5466101319899796367354a0"
+dependencies = [
+ "fastrand",
+ "getrandom 0.4.2",
+ "once_cell",
+ "rustix",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "tendril"
+version = "0.4.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d24a120c5fc464a3458240ee02c299ebcb9d67b5249c8848b09d639dca8d7bb0"
+dependencies = [
+ "futf",
+ "mac",
+ "utf-8",
+]
+
+[[package]]
+name = "termios"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d5d9cf598a6d7ce700a4e6a9199da127e6819a61e64b68609683cc9a01b5683a"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "thiserror"
+version = "1.0.69"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6aaf5339b578ea85b50e080feb250a3e8ae8cfcdff9a461c9ec2904bc923f52"
+dependencies = [
+ "thiserror-impl 1.0.69",
+]
+
+[[package]]
+name = "thiserror"
+version = "2.0.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4288b5bcbc7920c07a1149a35cf9590a2aa808e0bc1eafaade0b80947865fbc4"
+dependencies = [
+ "thiserror-impl 2.0.18",
+]
+
+[[package]]
+name = "thiserror-impl"
+version = "1.0.69"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4fee6c4efc90059e10f81e6d42c60a18f76588c3d74cb83a0b242a2b6c7504c1"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "thiserror-impl"
+version = "2.0.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ebc4ee7f67670e9b64d05fa4253e753e016c6c95ff35b89b7941d6b856dec1d5"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "thread_local"
+version = "1.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f60246a4944f24f6e018aa17cdeffb7818b76356965d03b07d6a9886e8962185"
+dependencies = [
+ "cfg-if",
+]
+
+[[package]]
+name = "time"
+version = "0.3.47"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "743bd48c283afc0388f9b8827b976905fb217ad9e647fae3a379a9283c4def2c"
+dependencies = [
+ "deranged",
+ "itoa",
+ "num-conv",
+ "powerfmt",
+ "serde_core",
+ "time-core",
+ "time-macros",
+]
+
+[[package]]
+name = "time-core"
+version = "0.1.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7694e1cfe791f8d31026952abf09c69ca6f6fa4e1a1229e18988f06a04a12dca"
+
+[[package]]
+name = "time-macros"
+version = "0.2.27"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2e70e4c5a0e0a8a4823ad65dfe1a6930e4f4d756dcd9dd7939022b5e8c501215"
+dependencies = [
+ "num-conv",
+ "time-core",
+]
+
+[[package]]
+name = "tinystr"
+version = "0.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "42d3e9c45c09de15d06dd8acf5f4e0e399e85927b7f00711024eb7ae10fa4869"
+dependencies = [
+ "displaydoc",
+ "zerovec",
+]
+
+[[package]]
+name = "tokio"
+version = "1.50.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "27ad5e34374e03cfffefc301becb44e9dc3c17584f414349ebe29ed26661822d"
+dependencies = [
+ "bytes",
+ "libc",
+ "mio 1.1.1",
+ "parking_lot",
+ "pin-project-lite",
+ "signal-hook-registry",
+ "socket2",
+ "tokio-macros",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "tokio-macros"
+version = "2.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c55a2eff8b69ce66c84f85e1da1c233edc36ceb85a2058d11b0d6a3c7e7569c"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "tokio-native-tls"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bbae76ab933c85776efabc971569dd6119c580d8f5d448769dec1764bf796ef2"
+dependencies = [
+ "native-tls",
+ "tokio",
+]
+
+[[package]]
+name = "tokio-rustls"
+version = "0.26.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1729aa945f29d91ba541258c8df89027d5792d85a8841fb65e8bf0f4ede4ef61"
+dependencies = [
+ "rustls",
+ "tokio",
+]
+
+[[package]]
+name = "tokio-stream"
+version = "0.1.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32da49809aab5c3bc678af03902d4ccddea2a87d028d86392a4b1560c6906c70"
+dependencies = [
+ "futures-core",
+ "pin-project-lite",
+ "tokio",
+]
+
+[[package]]
+name = "tokio-tungstenite"
+version = "0.21.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c83b561d025642014097b66e6c1bb422783339e0909e4429cde4749d1990bc38"
+dependencies = [
+ "futures-util",
+ "log",
+ "native-tls",
+ "tokio",
+ "tokio-native-tls",
+ "tungstenite",
+]
+
+[[package]]
+name = "tokio-util"
+version = "0.7.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ae9cec805b01e8fc3fd2fe289f89149a9b66dd16786abd8b19cfa7b48cb0098"
+dependencies = [
+ "bytes",
+ "futures-core",
+ "futures-sink",
+ "pin-project-lite",
+ "tokio",
+]
+
+[[package]]
+name = "toml"
+version = "0.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "185d8ab0dfbb35cf1399a6344d8484209c088f75f8f68230da55d48d95d43e3d"
+dependencies = [
+ "serde",
+ "serde_spanned 0.6.9",
+ "toml_datetime 0.6.3",
+ "toml_edit 0.20.2",
+]
+
+[[package]]
+name = "toml"
+version = "0.9.12+spec-1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cf92845e79fc2e2def6a5d828f0801e29a2f8acc037becc5ab08595c7d5e9863"
+dependencies = [
+ "indexmap 2.13.0",
+ "serde_core",
+ "serde_spanned 1.0.4",
+ "toml_datetime 0.7.5+spec-1.1.0",
+ "toml_parser",
+ "toml_writer",
+ "winnow 0.7.15",
+]
+
+[[package]]
+name = "toml_datetime"
+version = "0.6.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7cda73e2f1397b1262d6dfdcef8aafae14d1de7748d66822d3bfeeb6d03e5e4b"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "toml_datetime"
+version = "0.7.5+spec-1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "92e1cfed4a3038bc5a127e35a2d360f145e1f4b971b551a2ba5fd7aedf7e1347"
+dependencies = [
+ "serde_core",
+]
+
+[[package]]
+name = "toml_datetime"
+version = "1.0.0+spec-1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32c2555c699578a4f59f0cc68e5116c8d7cabbd45e1409b989d4be085b53f13e"
+dependencies = [
+ "serde_core",
+]
+
+[[package]]
+name = "toml_edit"
+version = "0.19.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1b5bb770da30e5cbfde35a2d7b9b8a2c4b8ef89548a7a6aeab5c9a576e3e7421"
+dependencies = [
+ "indexmap 2.13.0",
+ "toml_datetime 0.6.3",
+ "winnow 0.5.40",
+]
+
+[[package]]
+name = "toml_edit"
+version = "0.20.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "396e4d48bbb2b7554c944bde63101b5ae446cff6ec4a24227428f15eb72ef338"
+dependencies = [
+ "indexmap 2.13.0",
+ "serde",
+ "serde_spanned 0.6.9",
+ "toml_datetime 0.6.3",
+ "winnow 0.5.40",
+]
+
+[[package]]
+name = "toml_edit"
+version = "0.25.4+spec-1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7193cbd0ce53dc966037f54351dbbcf0d5a642c7f0038c382ef9e677ce8c13f2"
+dependencies = [
+ "indexmap 2.13.0",
+ "toml_datetime 1.0.0+spec-1.1.0",
+ "toml_parser",
+ "winnow 0.7.15",
+]
+
+[[package]]
+name = "toml_parser"
+version = "1.0.9+spec-1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "702d4415e08923e7e1ef96cd5727c0dfed80b4d2fa25db9647fe5eb6f7c5a4c4"
+dependencies = [
+ "winnow 0.7.15",
+]
+
+[[package]]
+name = "toml_writer"
+version = "1.0.6+spec-1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ab16f14aed21ee8bfd8ec22513f7287cd4a91aa92e44edfe2c17ddd004e92607"
+
+[[package]]
+name = "tonic"
+version = "0.12.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "877c5b330756d856ffcc4553ab34a5684481ade925ecc54bcd1bf02b1d0d4d52"
+dependencies = [
+ "async-trait",
+ "base64 0.22.1",
+ "bytes",
+ "http",
+ "http-body",
+ "http-body-util",
+ "percent-encoding",
+ "pin-project",
+ "prost",
+ "tokio-stream",
+ "tower-layer",
+ "tower-service",
+ "tracing",
+]
+
+[[package]]
+name = "tower"
+version = "0.5.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ebe5ef63511595f1344e2d5cfa636d973292adc0eec1f0ad45fae9f0851ab1d4"
+dependencies = [
+ "futures-core",
+ "futures-util",
+ "pin-project-lite",
+ "sync_wrapper",
+ "tokio",
+ "tower-layer",
+ "tower-service",
+]
+
+[[package]]
+name = "tower-http"
+version = "0.6.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d4e6559d53cc268e5031cd8429d05415bc4cb4aefc4aa5d6cc35fbf5b924a1f8"
+dependencies = [
+ "bitflags 2.11.0",
+ "bytes",
+ "futures-util",
+ "http",
+ "http-body",
+ "iri-string",
+ "pin-project-lite",
+ "tower",
+ "tower-layer",
+ "tower-service",
+]
+
+[[package]]
+name = "tower-layer"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "121c2a6cda46980bb0fcd1647ffaf6cd3fc79a013de288782836f6df9c48780e"
+
+[[package]]
+name = "tower-service"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8df9b6e13f2d32c91b9bd719c00d1958837bc7dec474d94952798cc8e69eeec3"
+
+[[package]]
+name = "tracing"
+version = "0.1.44"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "63e71662fa4b2a2c3a26f570f037eb95bb1f85397f3cd8076caed2f026a6d100"
+dependencies = [
+ "pin-project-lite",
+ "tracing-attributes",
+ "tracing-core",
+]
+
+[[package]]
+name = "tracing-attributes"
+version = "0.1.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7490cfa5ec963746568740651ac6781f701c9c5ea257c58e057f3ba8cf69e8da"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "tracing-core"
+version = "0.1.36"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "db97caf9d906fbde555dd62fa95ddba9eecfd14cb388e4f491a66d74cd5fb79a"
+dependencies = [
+ "once_cell",
+ "valuable",
+]
+
+[[package]]
+name = "tracing-log"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ee855f1f400bd0e5c02d150ae5de3840039a3f54b025156404e34c23c03f47c3"
+dependencies = [
+ "log",
+ "once_cell",
+ "tracing-core",
+]
+
+[[package]]
+name = "tracing-opentelemetry"
+version = "0.29.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "721f2d2569dce9f3dfbbddee5906941e953bfcdf736a62da3377f5751650cc36"
+dependencies = [
+ "js-sys",
+ "once_cell",
+ "opentelemetry",
+ "opentelemetry_sdk",
+ "smallvec",
+ "tracing",
+ "tracing-core",
+ "tracing-log",
+ "tracing-subscriber",
+ "web-time",
+]
+
+[[package]]
+name = "tracing-serde"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "704b1aeb7be0d0a84fc9828cae51dab5970fee5088f83d1dd7ee6f6246fc6ff1"
+dependencies = [
+ "serde",
+ "tracing-core",
+]
+
+[[package]]
+name = "tracing-subscriber"
+version = "0.3.22"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2f30143827ddab0d256fd843b7a66d164e9f271cfa0dde49142c5ca0ca291f1e"
+dependencies = [
+ "matchers",
+ "nu-ansi-term",
+ "once_cell",
+ "regex-automata",
+ "serde",
+ "serde_json",
+ "sharded-slab",
+ "smallvec",
+ "thread_local",
+ "tracing",
+ "tracing-core",
+ "tracing-log",
+ "tracing-serde",
+]
+
+[[package]]
+name = "tray-icon"
+version = "0.21.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a5e85aa143ceb072062fc4d6356c1b520a51d636e7bc8e77ec94be3608e5e80c"
+dependencies = [
+ "crossbeam-channel",
+ "dirs 6.0.0",
+ "libappindicator",
+ "muda",
+ "objc2",
+ "objc2-app-kit",
+ "objc2-core-foundation",
+ "objc2-core-graphics",
+ "objc2-foundation",
+ "once_cell",
+ "png",
+ "serde",
+ "thiserror 2.0.18",
+ "windows-sys 0.60.2",
+]
+
+[[package]]
+name = "try-lock"
+version = "0.2.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e421abadd41a4225275504ea4d6566923418b7f05506fbc9c0fe86ba7396114b"
+
+[[package]]
+name = "tungstenite"
+version = "0.21.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ef1a641ea34f399a848dea702823bbecfb4c486f911735368f1f137cb8257e1"
+dependencies = [
+ "byteorder",
+ "bytes",
+ "data-encoding",
+ "http",
+ "httparse",
+ "log",
+ "native-tls",
+ "rand 0.8.5",
+ "sha1",
+ "thiserror 1.0.69",
+ "url",
+ "utf-8",
+]
+
+[[package]]
+name = "typeid"
+version = "1.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bc7d623258602320d5c55d1bc22793b57daff0ec7efc270ea7d55ce1d5f5471c"
+
+[[package]]
+name = "typenum"
+version = "1.19.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "562d481066bde0658276a35467c4af00bdc6ee726305698a55b86e61d7ad82bb"
+
+[[package]]
+name = "uds_windows"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "51b70b87d15e91f553711b40df3048faf27a7a04e01e0ddc0cf9309f0af7c2ca"
+dependencies = [
+ "memoffset 0.9.1",
+ "tempfile",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "unic-char-property"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a8c57a407d9b6fa02b4795eb81c5b6652060a15a7903ea981f3d723e6c0be221"
+dependencies = [
+ "unic-char-range",
+]
+
+[[package]]
+name = "unic-char-range"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0398022d5f700414f6b899e10b8348231abf9173fa93144cbc1a43b9793c1fbc"
+
+[[package]]
+name = "unic-common"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "80d7ff825a6a654ee85a63e80f92f054f904f21e7d12da4e22f9834a4aaa35bc"
+
+[[package]]
+name = "unic-ucd-ident"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e230a37c0381caa9219d67cf063aa3a375ffed5bf541a452db16e744bdab6987"
+dependencies = [
+ "unic-char-property",
+ "unic-char-range",
+ "unic-ucd-version",
+]
+
+[[package]]
+name = "unic-ucd-version"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "96bd2f2237fe450fcd0a1d2f5f4e91711124f7857ba2e964247776ebeeb7b0c4"
+dependencies = [
+ "unic-common",
+]
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.24"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75"
+
+[[package]]
+name = "unicode-segmentation"
+version = "1.12.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f6ccf251212114b54433ec949fd6a7841275f9ada20dddd2f29e9ceea4501493"
+
+[[package]]
+name = "unicode-xid"
+version = "0.2.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ebc1c04c71510c7f702b52b7c350734c9ff1295c464a03335b00bb84fc54f853"
+
+[[package]]
+name = "untrusted"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8ecb6da28b8a351d773b68d5825ac39017e680750f980f3a1a85cd8dd28a47c1"
+
+[[package]]
+name = "url"
+version = "2.5.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ff67a8a4397373c3ef660812acab3268222035010ab8680ec4215f38ba3d0eed"
+dependencies = [
+ "form_urlencoded",
+ "idna",
+ "percent-encoding",
+ "serde",
+ "serde_derive",
+]
+
+[[package]]
+name = "urlpattern"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "70acd30e3aa1450bc2eece896ce2ad0d178e9c079493819301573dae3c37ba6d"
+dependencies = [
+ "regex",
+ "serde",
+ "unic-ucd-ident",
+ "url",
+]
+
+[[package]]
+name = "utf-8"
+version = "0.7.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "09cc8ee72d2a9becf2f2febe0205bbed8fc6615b7cb429ad062dc7b7ddd036a9"
+
+[[package]]
+name = "utf8_iter"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6c140620e7ffbb22c2dee59cafe6084a59b5ffc27a8859a5f0d494b5d52b6be"
+
+[[package]]
+name = "utf8parse"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821"
+
+[[package]]
+name = "uuid"
+version = "1.21.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b672338555252d43fd2240c714dc444b8c6fb0a5c5335e65a07bba7742735ddb"
+dependencies = [
+ "getrandom 0.4.2",
+ "js-sys",
+ "serde_core",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "valuable"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ba73ea9cf16a25df0c8caa16c51acb937d5712a8429db78a3ee29d5dcacd3a65"
+
+[[package]]
+name = "vcpkg"
+version = "0.2.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "accd4ea62f7bb7a82fe23066fb0957d48ef677f6eeb8215f372f52e48bb32426"
+
+[[package]]
+name = "version-compare"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "03c2856837ef78f57382f06b2b8563a2f512f7185d732608fd9176cb3b8edf0e"
+
+[[package]]
+name = "version_check"
+version = "0.9.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
+
+[[package]]
+name = "vswhom"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "be979b7f07507105799e854203b470ff7c78a1639e330a58f183b5fea574608b"
+dependencies = [
+ "libc",
+ "vswhom-sys",
+]
+
+[[package]]
+name = "vswhom-sys"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fb067e4cbd1ff067d1df46c9194b5de0e98efd2810bbc95c5d5e5f25a3231150"
+dependencies = [
+ "cc",
+ "libc",
+]
+
+[[package]]
+name = "walkdir"
+version = "2.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "29790946404f91d9c5d06f9874efddea1dc06c5efe94541a7d6863108e3a5e4b"
+dependencies = [
+ "same-file",
+ "winapi-util",
+]
+
+[[package]]
+name = "want"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bfa7760aed19e106de2c7c0b581b509f2f25d3dacaf737cb82ac61bc6d760b0e"
+dependencies = [
+ "try-lock",
+]
+
+[[package]]
+name = "wasi"
+version = "0.9.0+wasi-snapshot-preview1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cccddf32554fecc6acb585f82a32a72e28b48f8c4c1883ddfeeeaa96f7d8e519"
+
+[[package]]
+name = "wasi"
+version = "0.11.1+wasi-snapshot-preview1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ccf3ec651a847eb01de73ccad15eb7d99f80485de043efb2f370cd654f4ea44b"
+
+[[package]]
+name = "wasip2"
+version = "1.0.2+wasi-0.2.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9517f9239f02c069db75e65f174b3da828fe5f5b945c4dd26bd25d89c03ebcf5"
+dependencies = [
+ "wit-bindgen",
+]
+
+[[package]]
+name = "wasip3"
+version = "0.4.0+wasi-0.3.0-rc-2026-01-06"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5428f8bf88ea5ddc08faddef2ac4a67e390b88186c703ce6dbd955e1c145aca5"
+dependencies = [
+ "wit-bindgen",
+]
+
+[[package]]
+name = "wasm-bindgen"
+version = "0.2.114"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6532f9a5c1ece3798cb1c2cfdba640b9b3ba884f5db45973a6f442510a87d38e"
+dependencies = [
+ "cfg-if",
+ "once_cell",
+ "rustversion",
+ "wasm-bindgen-macro",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-futures"
+version = "0.4.64"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e9c5522b3a28661442748e09d40924dfb9ca614b21c00d3fd135720e48b67db8"
+dependencies = [
+ "cfg-if",
+ "futures-util",
+ "js-sys",
+ "once_cell",
+ "wasm-bindgen",
+ "web-sys",
+]
+
+[[package]]
+name = "wasm-bindgen-macro"
+version = "0.2.114"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "18a2d50fcf105fb33bb15f00e7a77b772945a2ee45dcf454961fd843e74c18e6"
+dependencies = [
+ "quote",
+ "wasm-bindgen-macro-support",
+]
+
+[[package]]
+name = "wasm-bindgen-macro-support"
+version = "0.2.114"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "03ce4caeaac547cdf713d280eda22a730824dd11e6b8c3ca9e42247b25c631e3"
+dependencies = [
+ "bumpalo",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-shared"
+version = "0.2.114"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "75a326b8c223ee17883a4251907455a2431acc2791c98c26279376490c378c16"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "wasm-encoder"
+version = "0.244.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "990065f2fe63003fe337b932cfb5e3b80e0b4d0f5ff650e6985b1048f62c8319"
+dependencies = [
+ "leb128fmt",
+ "wasmparser",
+]
+
+[[package]]
+name = "wasm-metadata"
+version = "0.244.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bb0e353e6a2fbdc176932bbaab493762eb1255a7900fe0fea1a2f96c296cc909"
+dependencies = [
+ "anyhow",
+ "indexmap 2.13.0",
+ "wasm-encoder",
+ "wasmparser",
+]
+
+[[package]]
+name = "wasm-streams"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9d1ec4f6517c9e11ae630e200b2b65d193279042e28edd4a2cda233e46670bbb"
+dependencies = [
+ "futures-util",
+ "js-sys",
+ "wasm-bindgen",
+ "wasm-bindgen-futures",
+ "web-sys",
+]
+
+[[package]]
+name = "wasmparser"
+version = "0.244.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "47b807c72e1bac69382b3a6fb3dbe8ea4c0ed87ff5629b8685ae6b9a611028fe"
+dependencies = [
+ "bitflags 2.11.0",
+ "hashbrown 0.15.5",
+ "indexmap 2.13.0",
+ "semver",
+]
+
+[[package]]
+name = "web-sys"
+version = "0.3.91"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "854ba17bb104abfb26ba36da9729addc7ce7f06f5c0f90f3c391f8461cca21f9"
+dependencies = [
+ "js-sys",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "web-time"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5a6580f308b1fad9207618087a65c04e7a10bc77e02c8e84e9b00dd4b12fa0bb"
+dependencies = [
+ "js-sys",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "webkit2gtk"
+version = "2.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a1027150013530fb2eaf806408df88461ae4815a45c541c8975e61d6f2fc4793"
+dependencies = [
+ "bitflags 1.3.2",
+ "cairo-rs",
+ "gdk",
+ "gdk-sys",
+ "gio",
+ "gio-sys",
+ "glib",
+ "glib-sys",
+ "gobject-sys",
+ "gtk",
+ "gtk-sys",
+ "javascriptcore-rs",
+ "libc",
+ "once_cell",
+ "soup3",
+ "webkit2gtk-sys",
+]
+
+[[package]]
+name = "webkit2gtk-sys"
+version = "2.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "916a5f65c2ef0dfe12fff695960a2ec3d4565359fdbb2e9943c974e06c734ea5"
+dependencies = [
+ "bitflags 1.3.2",
+ "cairo-sys-rs",
+ "gdk-sys",
+ "gio-sys",
+ "glib-sys",
+ "gobject-sys",
+ "gtk-sys",
+ "javascriptcore-rs-sys",
+ "libc",
+ "pkg-config",
+ "soup3-sys",
+ "system-deps",
+]
+
+[[package]]
+name = "webpki-root-certs"
+version = "1.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "804f18a4ac2676ffb4e8b5b5fa9ae38af06df08162314f96a68d2a363e21a8ca"
+dependencies = [
+ "rustls-pki-types",
+]
+
+[[package]]
+name = "webview2-com"
+version = "0.38.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7130243a7a5b33c54a444e54842e6a9e133de08b5ad7b5861cd8ed9a6a5bc96a"
+dependencies = [
+ "webview2-com-macros",
+ "webview2-com-sys",
+ "windows",
+ "windows-core 0.61.2",
+ "windows-implement",
+ "windows-interface",
+]
+
+[[package]]
+name = "webview2-com-macros"
+version = "0.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "67a921c1b6914c367b2b823cd4cde6f96beec77d30a939c8199bb377cf9b9b54"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "webview2-com-sys"
+version = "0.38.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "381336cfffd772377d291702245447a5251a2ffa5bad679c99e61bc48bacbf9c"
+dependencies = [
+ "thiserror 2.0.18",
+ "windows",
+ "windows-core 0.61.2",
+]
+
+[[package]]
+name = "winapi"
+version = "0.3.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"
+dependencies = [
+ "winapi-i686-pc-windows-gnu",
+ "winapi-x86_64-pc-windows-gnu",
+]
+
+[[package]]
+name = "winapi-i686-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
+
+[[package]]
+name = "winapi-util"
+version = "0.1.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22"
+dependencies = [
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "winapi-x86_64-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
+
+[[package]]
+name = "window-vibrancy"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d9bec5a31f3f9362f2258fd0e9c9dd61a9ca432e7306cc78c444258f0dce9a9c"
+dependencies = [
+ "objc2",
+ "objc2-app-kit",
+ "objc2-core-foundation",
+ "objc2-foundation",
+ "raw-window-handle",
+ "windows-sys 0.59.0",
+ "windows-version",
+]
+
+[[package]]
+name = "windows"
+version = "0.61.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9babd3a767a4c1aef6900409f85f5d53ce2544ccdfaa86dad48c91782c6d6893"
+dependencies = [
+ "windows-collections",
+ "windows-core 0.61.2",
+ "windows-future",
+ "windows-link 0.1.3",
+ "windows-numerics",
+]
+
+[[package]]
+name = "windows-collections"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3beeceb5e5cfd9eb1d76b381630e82c4241ccd0d27f1a39ed41b2760b255c5e8"
+dependencies = [
+ "windows-core 0.61.2",
+]
+
+[[package]]
+name = "windows-core"
+version = "0.61.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c0fdd3ddb90610c7638aa2b3a3ab2904fb9e5cdbecc643ddb3647212781c4ae3"
+dependencies = [
+ "windows-implement",
+ "windows-interface",
+ "windows-link 0.1.3",
+ "windows-result 0.3.4",
+ "windows-strings 0.4.2",
+]
+
+[[package]]
+name = "windows-core"
+version = "0.62.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b8e83a14d34d0623b51dce9581199302a221863196a1dde71a7663a4c2be9deb"
+dependencies = [
+ "windows-implement",
+ "windows-interface",
+ "windows-link 0.2.1",
+ "windows-result 0.4.1",
+ "windows-strings 0.5.1",
+]
+
+[[package]]
+name = "windows-future"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fc6a41e98427b19fe4b73c550f060b59fa592d7d686537eebf9385621bfbad8e"
+dependencies = [
+ "windows-core 0.61.2",
+ "windows-link 0.1.3",
+ "windows-threading",
+]
+
+[[package]]
+name = "windows-implement"
+version = "0.60.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "053e2e040ab57b9dc951b72c264860db7eb3b0200ba345b4e4c3b14f67855ddf"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "windows-interface"
+version = "0.59.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3f316c4a2570ba26bbec722032c4099d8c8bc095efccdc15688708623367e358"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "windows-link"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5e6ad25900d524eaabdbbb96d20b4311e1e7ae1699af4fb28c17ae66c80d798a"
+
+[[package]]
+name = "windows-link"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5"
+
+[[package]]
+name = "windows-numerics"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9150af68066c4c5c07ddc0ce30421554771e528bde427614c61038bc2c92c2b1"
+dependencies = [
+ "windows-core 0.61.2",
+ "windows-link 0.1.3",
+]
+
+[[package]]
+name = "windows-result"
+version = "0.3.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "56f42bd332cc6c8eac5af113fc0c1fd6a8fd2aa08a0119358686e5160d0586c6"
+dependencies = [
+ "windows-link 0.1.3",
+]
+
+[[package]]
+name = "windows-result"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7781fa89eaf60850ac3d2da7af8e5242a5ea78d1a11c49bf2910bb5a73853eb5"
+dependencies = [
+ "windows-link 0.2.1",
+]
+
+[[package]]
+name = "windows-strings"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "56e6c93f3a0c3b36176cb1327a4958a0353d5d166c2a35cb268ace15e91d3b57"
+dependencies = [
+ "windows-link 0.1.3",
+]
+
+[[package]]
+name = "windows-strings"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7837d08f69c77cf6b07689544538e017c1bfcf57e34b4c0ff58e6c2cd3b37091"
+dependencies = [
+ "windows-link 0.2.1",
+]
+
+[[package]]
+name = "windows-sys"
+version = "0.45.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "75283be5efb2831d37ea142365f009c02ec203cd29a3ebecbc093d52315b66d0"
+dependencies = [
+ "windows-targets 0.42.2",
+]
+
+[[package]]
+name = "windows-sys"
+version = "0.48.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "677d2418bec65e3338edb076e806bc1ec15693c5d0104683f2efe857f61056a9"
+dependencies = [
+ "windows-targets 0.48.5",
+]
+
+[[package]]
+name = "windows-sys"
+version = "0.52.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "282be5f36a8ce781fad8c8ae18fa3f9beff57ec1b52cb3de0789201425d9a33d"
+dependencies = [
+ "windows-targets 0.52.6",
+]
+
+[[package]]
+name = "windows-sys"
+version = "0.59.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b"
+dependencies = [
+ "windows-targets 0.52.6",
+]
+
+[[package]]
+name = "windows-sys"
+version = "0.60.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f2f500e4d28234f72040990ec9d39e3a6b950f9f22d3dba18416c35882612bcb"
+dependencies = [
+ "windows-targets 0.53.5",
+]
+
+[[package]]
+name = "windows-sys"
+version = "0.61.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ae137229bcbd6cdf0f7b80a31df61766145077ddf49416a728b02cb3921ff3fc"
+dependencies = [
+ "windows-link 0.2.1",
+]
+
+[[package]]
+name = "windows-targets"
+version = "0.42.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e5180c00cd44c9b1c88adb3693291f1cd93605ded80c250a75d472756b4d071"
+dependencies = [
+ "windows_aarch64_gnullvm 0.42.2",
+ "windows_aarch64_msvc 0.42.2",
+ "windows_i686_gnu 0.42.2",
+ "windows_i686_msvc 0.42.2",
+ "windows_x86_64_gnu 0.42.2",
+ "windows_x86_64_gnullvm 0.42.2",
+ "windows_x86_64_msvc 0.42.2",
+]
+
+[[package]]
+name = "windows-targets"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9a2fa6e2155d7247be68c096456083145c183cbbbc2764150dda45a87197940c"
+dependencies = [
+ "windows_aarch64_gnullvm 0.48.5",
+ "windows_aarch64_msvc 0.48.5",
+ "windows_i686_gnu 0.48.5",
+ "windows_i686_msvc 0.48.5",
+ "windows_x86_64_gnu 0.48.5",
+ "windows_x86_64_gnullvm 0.48.5",
+ "windows_x86_64_msvc 0.48.5",
+]
+
+[[package]]
+name = "windows-targets"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973"
+dependencies = [
+ "windows_aarch64_gnullvm 0.52.6",
+ "windows_aarch64_msvc 0.52.6",
+ "windows_i686_gnu 0.52.6",
+ "windows_i686_gnullvm 0.52.6",
+ "windows_i686_msvc 0.52.6",
+ "windows_x86_64_gnu 0.52.6",
+ "windows_x86_64_gnullvm 0.52.6",
+ "windows_x86_64_msvc 0.52.6",
+]
+
+[[package]]
+name = "windows-targets"
+version = "0.53.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4945f9f551b88e0d65f3db0bc25c33b8acea4d9e41163edf90dcd0b19f9069f3"
+dependencies = [
+ "windows-link 0.2.1",
+ "windows_aarch64_gnullvm 0.53.1",
+ "windows_aarch64_msvc 0.53.1",
+ "windows_i686_gnu 0.53.1",
+ "windows_i686_gnullvm 0.53.1",
+ "windows_i686_msvc 0.53.1",
+ "windows_x86_64_gnu 0.53.1",
+ "windows_x86_64_gnullvm 0.53.1",
+ "windows_x86_64_msvc 0.53.1",
+]
+
+[[package]]
+name = "windows-threading"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b66463ad2e0ea3bbf808b7f1d371311c80e115c0b71d60efc142cafbcfb057a6"
+dependencies = [
+ "windows-link 0.1.3",
+]
+
+[[package]]
+name = "windows-version"
+version = "0.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e4060a1da109b9d0326b7262c8e12c84df67cc0dbc9e33cf49e01ccc2eb63631"
+dependencies = [
+ "windows-link 0.2.1",
+]
+
+[[package]]
+name = "windows_aarch64_gnullvm"
+version = "0.42.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "597a5118570b68bc08d8d59125332c54f1ba9d9adeedeef5b99b02ba2b0698f8"
+
+[[package]]
+name = "windows_aarch64_gnullvm"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2b38e32f0abccf9987a4e3079dfb67dcd799fb61361e53e2882c3cbaf0d905d8"
+
+[[package]]
+name = "windows_aarch64_gnullvm"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3"
+
+[[package]]
+name = "windows_aarch64_gnullvm"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a9d8416fa8b42f5c947f8482c43e7d89e73a173cead56d044f6a56104a6d1b53"
+
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.42.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e08e8864a60f06ef0d0ff4ba04124db8b0fb3be5776a5cd47641e942e58c4d43"
+
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dc35310971f3b2dbbf3f0690a219f40e2d9afcf64f9ab7cc1be722937c26b4bc"
+
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469"
+
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b9d782e804c2f632e395708e99a94275910eb9100b2114651e04744e9b125006"
+
+[[package]]
+name = "windows_i686_gnu"
+version = "0.42.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c61d927d8da41da96a81f029489353e68739737d3beca43145c8afec9a31a84f"
+
+[[package]]
+name = "windows_i686_gnu"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a75915e7def60c94dcef72200b9a8e58e5091744960da64ec734a6c6e9b3743e"
+
+[[package]]
+name = "windows_i686_gnu"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b"
+
+[[package]]
+name = "windows_i686_gnu"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "960e6da069d81e09becb0ca57a65220ddff016ff2d6af6a223cf372a506593a3"
+
+[[package]]
+name = "windows_i686_gnullvm"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66"
+
+[[package]]
+name = "windows_i686_gnullvm"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fa7359d10048f68ab8b09fa71c3daccfb0e9b559aed648a8f95469c27057180c"
+
+[[package]]
+name = "windows_i686_msvc"
+version = "0.42.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "44d840b6ec649f480a41c8d80f9c65108b92d89345dd94027bfe06ac444d1060"
+
+[[package]]
+name = "windows_i686_msvc"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8f55c233f70c4b27f66c523580f78f1004e8b5a8b659e05a4eb49d4166cca406"
+
+[[package]]
+name = "windows_i686_msvc"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66"
+
+[[package]]
+name = "windows_i686_msvc"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e7ac75179f18232fe9c285163565a57ef8d3c89254a30685b57d83a38d326c2"
+
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.42.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8de912b8b8feb55c064867cf047dda097f92d51efad5b491dfb98f6bbb70cb36"
+
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "53d40abd2583d23e4718fddf1ebec84dbff8381c07cae67ff7768bbf19c6718e"
+
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78"
+
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9c3842cdd74a865a8066ab39c8a7a473c0778a3f29370b5fd6b4b9aa7df4a499"
+
+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.42.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "26d41b46a36d453748aedef1486d5c7a85db22e56aff34643984ea85514e94a3"
+
+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b7b52767868a23d5bab768e390dc5f5c55825b6d30b86c844ff2dc7414044cc"
+
+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d"
+
+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0ffa179e2d07eee8ad8f57493436566c7cc30ac536a3379fdf008f47f6bb7ae1"
+
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.42.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9aec5da331524158c6d1a4ac0ab1541149c0b9505fde06423b02f5ef0106b9f0"
+
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ed94fce61571a4006852b7389a063ab983c02eb1bb37b47f8272ce92d06d9538"
+
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec"
+
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d6bbff5f0aada427a1e5a6da5f1f98158182f26556f345ac9e04d36d0ebed650"
+
+[[package]]
+name = "winnow"
+version = "0.5.40"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f593a95398737aeed53e489c785df13f3618e41dbcd6718c6addbf1395aa6876"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "winnow"
+version = "0.7.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "df79d97927682d2fd8adb29682d1140b343be4ac0f08fd68b7765d9c059d3945"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "winreg"
+version = "0.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "80d0f4e272c85def139476380b12f9ac60926689dd2e01d4923222f40580869d"
+dependencies = [
+ "winapi",
+]
+
+[[package]]
+name = "winreg"
+version = "0.55.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cb5a765337c50e9ec252c2069be9bf91c7df47afb103b642ba3a53bf8101be97"
+dependencies = [
+ "cfg-if",
+ "windows-sys 0.59.0",
+]
+
+[[package]]
+name = "wit-bindgen"
+version = "0.51.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d7249219f66ced02969388cf2bb044a09756a083d0fab1e566056b04d9fbcaa5"
+dependencies = [
+ "wit-bindgen-rust-macro",
+]
+
+[[package]]
+name = "wit-bindgen-core"
+version = "0.51.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ea61de684c3ea68cb082b7a88508a8b27fcc8b797d738bfc99a82facf1d752dc"
+dependencies = [
+ "anyhow",
+ "heck 0.5.0",
+ "wit-parser",
+]
+
+[[package]]
+name = "wit-bindgen-rust"
+version = "0.51.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b7c566e0f4b284dd6561c786d9cb0142da491f46a9fbed79ea69cdad5db17f21"
+dependencies = [
+ "anyhow",
+ "heck 0.5.0",
+ "indexmap 2.13.0",
+ "prettyplease",
+ "syn 2.0.117",
+ "wasm-metadata",
+ "wit-bindgen-core",
+ "wit-component",
+]
+
+[[package]]
+name = "wit-bindgen-rust-macro"
+version = "0.51.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0c0f9bfd77e6a48eccf51359e3ae77140a7f50b1e2ebfe62422d8afdaffab17a"
+dependencies = [
+ "anyhow",
+ "prettyplease",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+ "wit-bindgen-core",
+ "wit-bindgen-rust",
+]
+
+[[package]]
+name = "wit-component"
+version = "0.244.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9d66ea20e9553b30172b5e831994e35fbde2d165325bec84fc43dbf6f4eb9cb2"
+dependencies = [
+ "anyhow",
+ "bitflags 2.11.0",
+ "indexmap 2.13.0",
+ "log",
+ "serde",
+ "serde_derive",
+ "serde_json",
+ "wasm-encoder",
+ "wasm-metadata",
+ "wasmparser",
+ "wit-parser",
+]
+
+[[package]]
+name = "wit-parser"
+version = "0.244.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ecc8ac4bc1dc3381b7f59c34f00b67e18f910c2c0f50015669dde7def656a736"
+dependencies = [
+ "anyhow",
+ "id-arena",
+ "indexmap 2.13.0",
+ "log",
+ "semver",
+ "serde",
+ "serde_derive",
+ "serde_json",
+ "unicode-xid",
+ "wasmparser",
+]
+
+[[package]]
+name = "writeable"
+version = "0.6.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9edde0db4769d2dc68579893f2306b26c6ecfbe0ef499b013d731b7b9247e0b9"
+
+[[package]]
+name = "wry"
+version = "0.54.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bb26159b420aa77684589a744ae9a9461a95395b848764ad12290a14d960a11a"
+dependencies = [
+ "base64 0.22.1",
+ "block2",
+ "cookie",
+ "crossbeam-channel",
+ "dirs 6.0.0",
+ "dpi",
+ "dunce",
+ "gdkx11",
+ "gtk",
+ "html5ever",
+ "http",
+ "javascriptcore-rs",
+ "jni",
+ "kuchikiki",
+ "libc",
+ "ndk",
+ "objc2",
+ "objc2-app-kit",
+ "objc2-core-foundation",
+ "objc2-foundation",
+ "objc2-ui-kit",
+ "objc2-web-kit",
+ "once_cell",
+ "percent-encoding",
+ "raw-window-handle",
+ "sha2",
+ "soup3",
+ "tao-macros",
+ "thiserror 2.0.18",
+ "url",
+ "webkit2gtk",
+ "webkit2gtk-sys",
+ "webview2-com",
+ "windows",
+ "windows-core 0.61.2",
+ "windows-version",
+ "x11-dl",
+]
+
+[[package]]
+name = "x11"
+version = "2.21.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "502da5464ccd04011667b11c435cb992822c2c0dbde1770c988480d312a0db2e"
+dependencies = [
+ "libc",
+ "pkg-config",
+]
+
+[[package]]
+name = "x11-dl"
+version = "2.21.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "38735924fedd5314a6e548792904ed8c6de6636285cb9fec04d5b1db85c1516f"
+dependencies = [
+ "libc",
+ "once_cell",
+ "pkg-config",
+]
+
+[[package]]
+name = "xattr"
+version = "1.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32e45ad4206f6d2479085147f02bc2ef834ac85886624a23575ae137c8aa8156"
+dependencies = [
+ "libc",
+ "rustix",
+]
+
+[[package]]
+name = "yoke"
+version = "0.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "72d6e5c6afb84d73944e5cedb052c4680d5657337201555f9f2a16b7406d4954"
+dependencies = [
+ "stable_deref_trait",
+ "yoke-derive",
+ "zerofrom",
+]
+
+[[package]]
+name = "yoke-derive"
+version = "0.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b659052874eb698efe5b9e8cf382204678a0086ebf46982b79d6ca3182927e5d"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+ "synstructure",
+]
+
+[[package]]
+name = "zbus"
+version = "5.14.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ca82f95dbd3943a40a53cfded6c2d0a2ca26192011846a1810c4256ef92c60bc"
+dependencies = [
+ "async-broadcast",
+ "async-executor",
+ "async-io",
+ "async-lock",
+ "async-process",
+ "async-recursion",
+ "async-task",
+ "async-trait",
+ "blocking",
+ "enumflags2",
+ "event-listener",
+ "futures-core",
+ "futures-lite",
+ "hex",
+ "libc",
+ "ordered-stream",
+ "rustix",
+ "serde",
+ "serde_repr",
+ "tracing",
+ "uds_windows",
+ "uuid",
+ "windows-sys 0.61.2",
+ "winnow 0.7.15",
+ "zbus_macros",
+ "zbus_names",
+ "zvariant",
+]
+
+[[package]]
+name = "zbus_macros"
+version = "5.14.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "897e79616e84aac4b2c46e9132a4f63b93105d54fe8c0e8f6bffc21fa8d49222"
+dependencies = [
+ "proc-macro-crate 3.5.0",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+ "zbus_names",
+ "zvariant",
+ "zvariant_utils",
+]
+
+[[package]]
+name = "zbus_names"
+version = "4.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ffd8af6d5b78619bab301ff3c560a5bd22426150253db278f164d6cf3b72c50f"
+dependencies = [
+ "serde",
+ "winnow 0.7.15",
+ "zvariant",
+]
+
+[[package]]
+name = "zerocopy"
+version = "0.8.40"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a789c6e490b576db9f7e6b6d661bcc9799f7c0ac8352f56ea20193b2681532e5"
+dependencies = [
+ "zerocopy-derive",
+]
+
+[[package]]
+name = "zerocopy-derive"
+version = "0.8.40"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f65c489a7071a749c849713807783f70672b28094011623e200cb86dcb835953"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "zerofrom"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "50cc42e0333e05660c3587f3bf9d0478688e15d870fab3346451ce7f8c9fbea5"
+dependencies = [
+ "zerofrom-derive",
+]
+
+[[package]]
+name = "zerofrom-derive"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d71e5d6e06ab090c67b5e44993ec16b72dcbaabc526db883a360057678b48502"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+ "synstructure",
+]
+
+[[package]]
+name = "zeroize"
+version = "1.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b97154e67e32c85465826e8bcc1c59429aaaf107c1e4a9e53c8d8ccd5eff88d0"
+
+[[package]]
+name = "zerotrie"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2a59c17a5562d507e4b54960e8569ebee33bee890c70aa3fe7b97e85a9fd7851"
+dependencies = [
+ "displaydoc",
+ "yoke",
+ "zerofrom",
+]
+
+[[package]]
+name = "zerovec"
+version = "0.11.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6c28719294829477f525be0186d13efa9a3c602f7ec202ca9e353d310fb9a002"
+dependencies = [
+ "yoke",
+ "zerofrom",
+ "zerovec-derive",
+]
+
+[[package]]
+name = "zerovec-derive"
+version = "0.11.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "eadce39539ca5cb3985590102671f2567e659fca9666581ad3411d59207951f3"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "zip"
+version = "4.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "caa8cd6af31c3b31c6631b8f483848b91589021b28fffe50adada48d4f4d2ed1"
+dependencies = [
+ "arbitrary",
+ "crc32fast",
+ "indexmap 2.13.0",
+ "memchr",
+]
+
+[[package]]
+name = "zmij"
+version = "1.0.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b8848ee67ecc8aedbaf3e4122217aff892639231befc6a1b58d29fff4c2cabaa"
+
+[[package]]
+name = "zvariant"
+version = "5.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5708299b21903bbe348e94729f22c49c55d04720a004aa350f1f9c122fd2540b"
+dependencies = [
+ "endi",
+ "enumflags2",
+ "serde",
+ "winnow 0.7.15",
+ "zvariant_derive",
+ "zvariant_utils",
+]
+
+[[package]]
+name = "zvariant_derive"
+version = "5.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5b59b012ebe9c46656f9cc08d8da8b4c726510aef12559da3e5f1bf72780752c"
+dependencies = [
+ "proc-macro-crate 3.5.0",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+ "zvariant_utils",
+]
+
+[[package]]
+name = "zvariant_utils"
+version = "3.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f75c23a64ef8f40f13a6989991e643554d9bef1d682a281160cf0c1bc389c5e9"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "serde",
+ "syn 2.0.117",
+ "winnow 0.7.15",
+]
diff --git a/v2/Cargo.toml b/v2/Cargo.toml
new file mode 100644
index 0000000..0988feb
--- /dev/null
+++ b/v2/Cargo.toml
@@ -0,0 +1,3 @@
+[workspace]
+members = ["src-tauri", "bterminal-core", "bterminal-relay"]
+resolver = "2"
diff --git a/v2/README.md b/v2/README.md
new file mode 100644
index 0000000..e6cd94f
--- /dev/null
+++ b/v2/README.md
@@ -0,0 +1,47 @@
+# Svelte + TS + Vite
+
+This template should help get you started developing with Svelte and TypeScript in Vite.
+
+## Recommended IDE Setup
+
+[VS Code](https://code.visualstudio.com/) + [Svelte](https://marketplace.visualstudio.com/items?itemName=svelte.svelte-vscode).
+
+## Need an official Svelte framework?
+
+Check out [SvelteKit](https://github.com/sveltejs/kit#readme), which is also powered by Vite. Deploy anywhere with its serverless-first approach and adapt to various platforms, with out of the box support for TypeScript, SCSS, and Less, and easily-added support for mdsvex, GraphQL, PostCSS, Tailwind CSS, and more.
+
+## Technical considerations
+
+**Why use this over SvelteKit?**
+
+- It brings its own routing solution which might not be preferable for some users.
+- It is first and foremost a framework that just happens to use Vite under the hood, not a Vite app.
+
+This template contains as little as possible to get started with Vite + TypeScript + Svelte, while taking into account the developer experience with regards to HMR and intellisense. It demonstrates capabilities on par with the other `create-vite` templates and is a good starting point for beginners dipping their toes into a Vite + Svelte project.
+
+Should you later need the extended capabilities and extensibility provided by SvelteKit, the template has been structured similarly to SvelteKit so that it is easy to migrate.
+
+**Why `global.d.ts` instead of `compilerOptions.types` inside `jsconfig.json` or `tsconfig.json`?**
+
+Setting `compilerOptions.types` shuts out all other types not explicitly listed in the configuration. Using triple-slash references keeps the default TypeScript setting of accepting type information from the entire workspace, while also adding `svelte` and `vite/client` type information.
+
+**Why include `.vscode/extensions.json`?**
+
+Other templates indirectly recommend extensions via the README, but this file allows VS Code to prompt the user to install the recommended extension upon opening the project.
+
+**Why enable `allowJs` in the TS template?**
+
+While `allowJs: false` would indeed prevent the use of `.js` files in the project, it does not prevent the use of JavaScript syntax in `.svelte` files. In addition, it would force `checkJs: false`, bringing the worst of both worlds: not being able to guarantee the entire codebase is TypeScript, and also having worse typechecking for the existing JavaScript. In addition, there are valid use cases in which a mixed codebase may be relevant.
+
+**Why is HMR not preserving my local component state?**
+
+HMR state preservation comes with a number of gotchas! It has been disabled by default in both `svelte-hmr` and `@sveltejs/vite-plugin-svelte` due to its often surprising behavior. You can read the details [here](https://github.com/rixo/svelte-hmr#svelte-hmr).
+
+If you have state that's important to retain within a component, consider creating an external store which would not be replaced by HMR.
+
+```ts
+// store.ts
+// An extremely simple external store
+import { writable } from 'svelte/store'
+export default writable(0)
+```
diff --git a/v2/bterminal-core/Cargo.toml b/v2/bterminal-core/Cargo.toml
new file mode 100644
index 0000000..174a87f
--- /dev/null
+++ b/v2/bterminal-core/Cargo.toml
@@ -0,0 +1,15 @@
+[package]
+name = "bterminal-core"
+version = "0.1.0"
+edition = "2021"
+description = "Shared PTY and sidecar management for BTerminal"
+license = "MIT"
+
+[dependencies]
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"
+log = "0.4"
+portable-pty = "0.8"
+uuid = { version = "1", features = ["v4"] }
+dirs = "5"
+landlock = "0.4"
diff --git a/v2/bterminal-core/src/config.rs b/v2/bterminal-core/src/config.rs
new file mode 100644
index 0000000..0940841
--- /dev/null
+++ b/v2/bterminal-core/src/config.rs
@@ -0,0 +1,209 @@
+// AppConfig — centralized path resolution for all BTerminal subsystems.
+// In production, paths resolve via dirs:: crate defaults.
+// In test mode (BTERMINAL_TEST=1), paths resolve from env var overrides:
+//   BTERMINAL_TEST_DATA_DIR   → replaces dirs::data_dir()/bterminal
+//   BTERMINAL_TEST_CONFIG_DIR → replaces dirs::config_dir()/bterminal
+//   BTERMINAL_TEST_CTX_DIR    → replaces ~/.claude-context
+
+use std::path::PathBuf;
+
+#[derive(Debug, Clone)]
+pub struct AppConfig {
+    /// Data directory for btmsg.db, sessions.db (default: ~/.local/share/bterminal)
+    pub data_dir: PathBuf,
+    /// Config directory for groups.json (default: ~/.config/bterminal)
+    pub config_dir: PathBuf,
+    /// ctx database path (default: ~/.claude-context/context.db)
+    pub ctx_db_path: PathBuf,
+    /// Memora database path (default: ~/.local/share/memora/memories.db)
+    pub memora_db_path: PathBuf,
+    /// Whether we are in test mode
+    pub test_mode: bool,
+}
+
+impl AppConfig {
+    /// Build config from environment. In test mode, uses BTERMINAL_TEST_*_DIR env vars.
+    pub fn from_env() -> Self {
+        let test_mode = std::env::var("BTERMINAL_TEST").map_or(false, |v| v == "1");
+
+        let data_dir = std::env::var("BTERMINAL_TEST_DATA_DIR")
+            .ok()
+            .filter(|_| test_mode)
+            .map(PathBuf::from)
+            .unwrap_or_else(|| {
+                dirs::data_dir()
+                    .unwrap_or_else(|| PathBuf::from("."))
+                    .join("bterminal")
+            });
+
+        let config_dir = std::env::var("BTERMINAL_TEST_CONFIG_DIR")
+            .ok()
+            .filter(|_| test_mode)
+            .map(PathBuf::from)
+            .unwrap_or_else(|| {
+                dirs::config_dir()
+                    .unwrap_or_else(|| PathBuf::from("."))
+                    .join("bterminal")
+            });
+
+        let ctx_db_path = std::env::var("BTERMINAL_TEST_CTX_DIR")
+            .ok()
+            .filter(|_| test_mode)
+            .map(|d| PathBuf::from(d).join("context.db"))
+            .unwrap_or_else(|| {
+                dirs::home_dir()
+                    .unwrap_or_default()
+                    .join(".claude-context")
+                    .join("context.db")
+            });
+
+        let memora_db_path = if test_mode {
+            // In test mode, memora is optional — use data_dir/memora/memories.db
+            data_dir.join("memora").join("memories.db")
+        } else {
+            dirs::data_dir()
+                .unwrap_or_else(|| {
+                    dirs::home_dir()
+                        .unwrap_or_default()
+                        .join(".local/share")
+                })
+                .join("memora")
+                .join("memories.db")
+        };
+
+        Self {
+            data_dir,
+            config_dir,
+            ctx_db_path,
+            memora_db_path,
+            test_mode,
+        }
+    }
+
+    /// Path to btmsg.db (shared between btmsg and bttask)
+    pub fn btmsg_db_path(&self) -> PathBuf {
+        self.data_dir.join("btmsg.db")
+    }
+
+    /// Path to sessions.db
+    pub fn sessions_db_dir(&self) -> &PathBuf {
+        &self.data_dir
+    }
+
+    /// Path to groups.json
+    pub fn groups_json_path(&self) -> PathBuf {
+        self.config_dir.join("groups.json")
+    }
+
+    /// Path to plugins directory
+    pub fn plugins_dir(&self) -> PathBuf {
+        self.config_dir.join("plugins")
+    }
+
+    /// Whether running in test mode (BTERMINAL_TEST=1)
+    pub fn is_test_mode(&self) -> bool {
+        self.test_mode
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::sync::Mutex;
+
+    // Serialize all tests that mutate env vars to prevent race conditions.
+    // Rust runs tests in parallel; set_var/remove_var are process-global.
+    static ENV_LOCK: Mutex<()> = Mutex::new(());
+
+    #[test]
+    fn test_production_paths_use_dirs() {
+        let _lock = ENV_LOCK.lock().unwrap();
+        // Without BTERMINAL_TEST=1, paths should use dirs:: defaults
+        std::env::remove_var("BTERMINAL_TEST");
+        std::env::remove_var("BTERMINAL_TEST_DATA_DIR");
+        std::env::remove_var("BTERMINAL_TEST_CONFIG_DIR");
+        std::env::remove_var("BTERMINAL_TEST_CTX_DIR");
+
+        let config = AppConfig::from_env();
+        assert!(!config.is_test_mode());
+        // Should end with "bterminal" for data and config
+        assert!(config.data_dir.ends_with("bterminal"));
+        assert!(config.config_dir.ends_with("bterminal"));
+        assert!(config.ctx_db_path.ends_with("context.db"));
+        assert!(config.memora_db_path.ends_with("memories.db"));
+    }
+
+    #[test]
+    fn test_btmsg_db_path() {
+        let _lock = ENV_LOCK.lock().unwrap();
+        std::env::remove_var("BTERMINAL_TEST");
+        let config = AppConfig::from_env();
+        let path = config.btmsg_db_path();
+        assert!(path.ends_with("btmsg.db"));
+        assert!(path.parent().unwrap().ends_with("bterminal"));
+    }
+
+    #[test]
+    fn test_groups_json_path() {
+        let _lock = ENV_LOCK.lock().unwrap();
+        std::env::remove_var("BTERMINAL_TEST");
+        let config = AppConfig::from_env();
+        let path = config.groups_json_path();
+        assert!(path.ends_with("groups.json"));
+    }
+
+    #[test]
+    fn test_test_mode_uses_overrides() {
+        let _lock = ENV_LOCK.lock().unwrap();
+        std::env::set_var("BTERMINAL_TEST", "1");
+        std::env::set_var("BTERMINAL_TEST_DATA_DIR", "/tmp/bt-test-data");
+        std::env::set_var("BTERMINAL_TEST_CONFIG_DIR", "/tmp/bt-test-config");
+        std::env::set_var("BTERMINAL_TEST_CTX_DIR", "/tmp/bt-test-ctx");
+
+        let config = AppConfig::from_env();
+        assert!(config.is_test_mode());
+        assert_eq!(config.data_dir, PathBuf::from("/tmp/bt-test-data"));
+        assert_eq!(config.config_dir, PathBuf::from("/tmp/bt-test-config"));
+        assert_eq!(config.ctx_db_path, PathBuf::from("/tmp/bt-test-ctx/context.db"));
+        assert_eq!(config.btmsg_db_path(), PathBuf::from("/tmp/bt-test-data/btmsg.db"));
+        assert_eq!(config.groups_json_path(), PathBuf::from("/tmp/bt-test-config/groups.json"));
+
+        // Cleanup
+        std::env::remove_var("BTERMINAL_TEST");
+        std::env::remove_var("BTERMINAL_TEST_DATA_DIR");
+        std::env::remove_var("BTERMINAL_TEST_CONFIG_DIR");
+        std::env::remove_var("BTERMINAL_TEST_CTX_DIR");
+    }
+
+    #[test]
+    fn test_test_mode_without_overrides_uses_defaults() {
+        let _lock = ENV_LOCK.lock().unwrap();
+        std::env::set_var("BTERMINAL_TEST", "1");
+        std::env::remove_var("BTERMINAL_TEST_DATA_DIR");
+        std::env::remove_var("BTERMINAL_TEST_CONFIG_DIR");
+        std::env::remove_var("BTERMINAL_TEST_CTX_DIR");
+
+        let config = AppConfig::from_env();
+        assert!(config.is_test_mode());
+        // Without override vars, falls back to dirs:: defaults
+        assert!(config.data_dir.ends_with("bterminal"));
+
+        std::env::remove_var("BTERMINAL_TEST");
+    }
+
+    #[test]
+    fn test_test_mode_memora_in_data_dir() {
+        let _lock = ENV_LOCK.lock().unwrap();
+        std::env::set_var("BTERMINAL_TEST", "1");
+        std::env::set_var("BTERMINAL_TEST_DATA_DIR", "/tmp/bt-test-data");
+
+        let config = AppConfig::from_env();
+        assert_eq!(
+            config.memora_db_path,
+            PathBuf::from("/tmp/bt-test-data/memora/memories.db")
+        );
+
+        std::env::remove_var("BTERMINAL_TEST");
+        std::env::remove_var("BTERMINAL_TEST_DATA_DIR");
+    }
+}
diff --git a/v2/bterminal-core/src/event.rs b/v2/bterminal-core/src/event.rs
new file mode 100644
index 0000000..45f3a0b
--- /dev/null
+++ b/v2/bterminal-core/src/event.rs
@@ -0,0 +1,5 @@
+/// Trait for emitting events from PTY and sidecar managers.
+/// Implemented by Tauri's AppHandle (controller) and WebSocket sender (relay).
+pub trait EventSink: Send + Sync {
+    fn emit(&self, event: &str, payload: serde_json::Value);
+}
diff --git a/v2/bterminal-core/src/lib.rs b/v2/bterminal-core/src/lib.rs
new file mode 100644
index 0000000..84c189d
--- /dev/null
+++ b/v2/bterminal-core/src/lib.rs
@@ -0,0 +1,6 @@
+pub mod config;
+pub mod event;
+pub mod pty;
+pub mod sandbox;
+pub mod sidecar;
+pub mod supervisor;
diff --git a/v2/bterminal-core/src/pty.rs b/v2/bterminal-core/src/pty.rs
new file mode 100644
index 0000000..a0ab83e
--- /dev/null
+++ b/v2/bterminal-core/src/pty.rs
@@ -0,0 +1,173 @@
+use portable_pty::{native_pty_system, CommandBuilder, MasterPty, PtySize};
+use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
+use std::io::{BufReader, Write};
+use std::sync::{Arc, Mutex};
+use std::thread;
+use uuid::Uuid;
+
+use crate::event::EventSink;
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct PtyOptions {
+    pub shell: Option<String>,
+    pub cwd: Option<String>,
+    pub args: Option<Vec<String>>,
+    pub cols: Option<u16>,
+    pub rows: Option<u16>,
+}
+
+struct PtyInstance {
+    master: Box<dyn MasterPty + Send>,
+    writer: Box<dyn Write + Send>,
+}
+
+pub struct PtyManager {
+    instances: Arc<Mutex<HashMap<String, PtyInstance>>>,
+    sink: Arc<dyn EventSink>,
+}
+
+impl PtyManager {
+    pub fn new(sink: Arc<dyn EventSink>) -> Self {
+        Self {
+            instances: Arc::new(Mutex::new(HashMap::new())),
+            sink,
+        }
+    }
+
+    pub fn spawn(&self, options: PtyOptions) -> Result<String, String> {
+        let pty_system = native_pty_system();
+        let cols = options.cols.unwrap_or(80);
+        let rows = options.rows.unwrap_or(24);
+
+        let pair = pty_system
+            .openpty(PtySize {
+                rows,
+                cols,
+                pixel_width: 0,
+                pixel_height: 0,
+            })
+            .map_err(|e| format!("Failed to open PTY: {e}"))?;
+
+        let shell = options.shell.unwrap_or_else(|| {
+            std::env::var("SHELL").unwrap_or_else(|_| "/bin/bash".to_string())
+        });
+
+        let mut cmd = CommandBuilder::new(&shell);
+        if let Some(args) = &options.args {
+            for arg in args {
+                cmd.arg(arg);
+            }
+        }
+        if let Some(cwd) = &options.cwd {
+            cmd.cwd(cwd);
+        }
+
+        let _child = pair
+            .slave
+            .spawn_command(cmd)
+            .map_err(|e| format!("Failed to spawn command: {e}"))?;
+
+        drop(pair.slave);
+
+        let id = Uuid::new_v4().to_string();
+        let reader = pair
+            .master
+            .try_clone_reader()
+            .map_err(|e| format!("Failed to clone PTY reader: {e}"))?;
+        let writer = pair
+            .master
+            .take_writer()
+            .map_err(|e| format!("Failed to take PTY writer: {e}"))?;
+
+        let event_id = id.clone();
+        let sink = self.sink.clone();
+        thread::spawn(move || {
+            let mut buf_reader = BufReader::with_capacity(4096, reader);
+            let mut buf = vec![0u8; 4096];
+            loop {
+                match std::io::Read::read(&mut buf_reader, &mut buf) {
+                    Ok(0) => {
+                        sink.emit(
+                            &format!("pty-exit-{event_id}"),
+                            serde_json::Value::Null,
+                        );
+                        break;
+                    }
+                    Ok(n) => {
+                        let data = String::from_utf8_lossy(&buf[..n]).to_string();
+                        sink.emit(
+                            &format!("pty-data-{event_id}"),
+                            serde_json::Value::String(data),
+                        );
+                    }
+                    Err(e) => {
+                        log::error!("PTY read error for {event_id}: {e}");
+                        sink.emit(
+                            &format!("pty-exit-{event_id}"),
+                            serde_json::Value::Null,
+                        );
+                        break;
+                    }
+                }
+            }
+        });
+
+        let instance = PtyInstance {
+            master: pair.master,
+            writer,
+        };
+        self.instances.lock().unwrap().insert(id.clone(), instance);
+
+        log::info!("Spawned PTY {id} ({shell})");
+        Ok(id)
+    }
+
+    pub fn write(&self, id: &str, data: &str) -> Result<(), String> {
+        let mut instances = self.instances.lock().unwrap();
+        let instance = instances
+            .get_mut(id)
+            .ok_or_else(|| format!("PTY {id} not found"))?;
+        instance
+            .writer
+            .write_all(data.as_bytes())
+            .map_err(|e| format!("PTY write error: {e}"))?;
+        instance
+            .writer
+            .flush()
+            .map_err(|e| format!("PTY flush error: {e}"))?;
+        Ok(())
+    }
+
+    pub fn resize(&self, id: &str, cols: u16, rows: u16) -> Result<(), String> {
+        let instances = self.instances.lock().unwrap();
+        let instance = instances
+            .get(id)
+            .ok_or_else(|| format!("PTY {id} not found"))?;
+        instance
+            .master
+            .resize(PtySize {
+                rows,
+                cols,
+                pixel_width: 0,
+                pixel_height: 0,
+            })
+            .map_err(|e| format!("PTY resize error: {e}"))?;
+        Ok(())
+    }
+
+    pub fn kill(&self, id: &str) -> Result<(), String> {
+        let mut instances = self.instances.lock().unwrap();
+        if instances.remove(id).is_some() {
+            log::info!("Killed PTY {id}");
+            Ok(())
+        } else {
+            Err(format!("PTY {id} not found"))
+        }
+    }
+
+    /// List active PTY session IDs.
+    pub fn list_sessions(&self) -> Vec<String> {
+        self.instances.lock().unwrap().keys().cloned().collect()
+    }
+}
diff --git a/v2/bterminal-core/src/sandbox.rs b/v2/bterminal-core/src/sandbox.rs
new file mode 100644
index 0000000..2c41d1b
--- /dev/null
+++ b/v2/bterminal-core/src/sandbox.rs
@@ -0,0 +1,277 @@
+// Landlock-based filesystem sandboxing for sidecar processes.
+//
+// Landlock is a Linux Security Module (LSM) available since kernel 5.13.
+// It restricts filesystem access for the calling process and all its children.
+// Applied via pre_exec() on the sidecar child process before exec.
+//
+// Restrictions can only be tightened after application — never relaxed.
+// The sidecar is long-lived and handles queries for multiple projects,
+// so we apply the union of all project paths at sidecar start time.
+
+use std::path::PathBuf;
+
+use landlock::{
+    Access, AccessFs, PathBeneath, PathFd, Ruleset, RulesetAttr, RulesetCreatedAttr,
+    RulesetStatus, ABI,
+};
+
+/// Target Landlock ABI version. V3 requires kernel 6.2+ (we run 6.12+).
+/// Falls back gracefully on older kernels via best-effort mode.
+const TARGET_ABI: ABI = ABI::V3;
+
+/// Configuration for Landlock filesystem sandboxing.
+#[derive(Debug, Clone)]
+pub struct SandboxConfig {
+    /// Directories with full read+write+execute access (project CWDs, worktrees, tmp)
+    pub rw_paths: Vec<PathBuf>,
+    /// Directories with read-only access (system libs, runtimes, config)
+    pub ro_paths: Vec<PathBuf>,
+    /// Whether sandboxing is enabled
+    pub enabled: bool,
+}
+
+impl Default for SandboxConfig {
+    fn default() -> Self {
+        Self {
+            rw_paths: Vec::new(),
+            ro_paths: Vec::new(),
+            enabled: false,
+        }
+    }
+}
+
+impl SandboxConfig {
+    /// Build a sandbox config for a set of project directories.
+    ///
+    /// `project_cwds` — directories that need read+write access (one per project).
+    /// `worktree_roots` — optional worktree directories (one per project that uses worktrees).
+    ///
+    /// System paths (runtimes, libraries, /etc) are added as read-only automatically.
+    pub fn for_projects(project_cwds: &[&str], worktree_roots: &[&str]) -> Self {
+        let mut rw = Vec::new();
+
+        for cwd in project_cwds {
+            rw.push(PathBuf::from(cwd));
+        }
+        for wt in worktree_roots {
+            rw.push(PathBuf::from(wt));
+        }
+
+        // Temp dir for sidecar scratch files
+        rw.push(std::env::temp_dir());
+
+        let home = dirs::home_dir().unwrap_or_else(|| PathBuf::from("/root"));
+
+        let ro = vec![
+            PathBuf::from("/usr"),     // system binaries + libraries
+            PathBuf::from("/lib"),     // shared libraries
+            PathBuf::from("/lib64"),   // 64-bit shared libraries
+            PathBuf::from("/etc"),     // system configuration (read only)
+            PathBuf::from("/proc"),    // process info (Landlock V3+ handles this)
+            PathBuf::from("/dev"),     // device nodes (stdin/stdout/stderr, /dev/null, urandom)
+            PathBuf::from("/bin"),     // essential binaries (symlink to /usr/bin on most distros)
+            PathBuf::from("/sbin"),    // essential system binaries
+            home.join(".local"),       // ~/.local/bin (claude CLI, user-installed tools)
+            home.join(".deno"),        // Deno runtime cache
+            home.join(".nvm"),         // Node.js version manager
+            home.join(".config"),      // XDG config (claude profiles, bterminal config)
+            home.join(".claude"),      // Claude CLI data (worktrees, skills, settings)
+        ];
+
+        Self {
+            rw_paths: rw,
+            ro_paths: ro,
+            enabled: true,
+        }
+    }
+
+    /// Build a sandbox config for a single project directory.
+    pub fn for_project(cwd: &str, worktree: Option<&str>) -> Self {
+        let worktrees: Vec<&str> = worktree.into_iter().collect();
+        Self::for_projects(&[cwd], &worktrees)
+    }
+
+    /// Apply Landlock restrictions to the current process.
+    ///
+    /// This must be called in the child process (e.g., via `pre_exec`) BEFORE exec.
+    /// Once applied, restrictions are inherited by all child processes and cannot be relaxed.
+    ///
+    /// Returns:
+    /// - `Ok(true)` if Landlock was applied and enforced
+    /// - `Ok(false)` if the kernel does not support Landlock (graceful degradation)
+    /// - `Err(msg)` on configuration or syscall errors
+    pub fn apply(&self) -> Result<bool, String> {
+        if !self.enabled {
+            return Ok(false);
+        }
+
+        let access_all = AccessFs::from_all(TARGET_ABI);
+        let access_read = AccessFs::from_read(TARGET_ABI);
+
+        // Create ruleset handling all filesystem access types
+        let mut ruleset = Ruleset::default()
+            .handle_access(access_all)
+            .map_err(|e| format!("Landlock: failed to handle access: {e}"))?
+            .create()
+            .map_err(|e| format!("Landlock: failed to create ruleset: {e}"))?;
+
+        // Add read+write rules for project directories and tmp
+        for path in &self.rw_paths {
+            if path.exists() {
+                let fd = PathFd::new(path)
+                    .map_err(|e| format!("Landlock: PathFd failed for {}: {e}", path.display()))?;
+                ruleset = ruleset
+                    .add_rule(PathBeneath::new(fd, access_all))
+                    .map_err(|e| {
+                        format!("Landlock: add_rule (rw) failed for {}: {e}", path.display())
+                    })?;
+            } else {
+                log::warn!(
+                    "Landlock: skipping non-existent rw path: {}",
+                    path.display()
+                );
+            }
+        }
+
+        // Add read-only rules for system paths
+        for path in &self.ro_paths {
+            if path.exists() {
+                let fd = PathFd::new(path)
+                    .map_err(|e| format!("Landlock: PathFd failed for {}: {e}", path.display()))?;
+                ruleset = ruleset
+                    .add_rule(PathBeneath::new(fd, access_read))
+                    .map_err(|e| {
+                        format!("Landlock: add_rule (ro) failed for {}: {e}", path.display())
+                    })?;
+            }
+            // Silently skip non-existent read-only paths (e.g., /lib64 on some systems)
+        }
+
+        // Enforce the ruleset on this thread (and inherited by children)
+        let status = ruleset
+            .restrict_self()
+            .map_err(|e| format!("Landlock: restrict_self failed: {e}"))?;
+
+        // Landlock enforcement states:
+        // - Enforced: kernel 6.2+ with ABI V3 (full filesystem restriction)
+        // - NotEnforced: kernel 5.13–6.1 (Landlock exists but ABI too old for V3)
+        // - Error (caught above): kernel <5.13 (no Landlock LSM available)
+        let enforced = status.ruleset != RulesetStatus::NotEnforced;
+        if enforced {
+            log::info!("Landlock sandbox applied ({} rw, {} ro paths)", self.rw_paths.len(), self.ro_paths.len());
+        } else {
+            log::warn!(
+                "Landlock not enforced — sidecar runs without filesystem restrictions. \
+                 Kernel 6.2+ required for enforcement."
+            );
+        }
+
+        Ok(enforced)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_default_is_disabled() {
+        let config = SandboxConfig::default();
+        assert!(!config.enabled);
+        assert!(config.rw_paths.is_empty());
+        assert!(config.ro_paths.is_empty());
+    }
+
+    #[test]
+    fn test_for_project_single_cwd() {
+        let config = SandboxConfig::for_project("/home/user/myproject", None);
+        assert!(config.enabled);
+        assert!(config.rw_paths.contains(&PathBuf::from("/home/user/myproject")));
+        assert!(config.rw_paths.contains(&std::env::temp_dir()));
+        // No worktree path added
+        assert!(!config
+            .rw_paths
+            .iter()
+            .any(|p| p.to_string_lossy().contains("worktree")));
+    }
+
+    #[test]
+    fn test_for_project_with_worktree() {
+        let config = SandboxConfig::for_project(
+            "/home/user/myproject",
+            Some("/home/user/myproject/.claude/worktrees/abc123"),
+        );
+        assert!(config.enabled);
+        assert!(config.rw_paths.contains(&PathBuf::from("/home/user/myproject")));
+        assert!(config.rw_paths.contains(&PathBuf::from(
+            "/home/user/myproject/.claude/worktrees/abc123"
+        )));
+    }
+
+    #[test]
+    fn test_for_projects_multiple_cwds() {
+        let config = SandboxConfig::for_projects(
+            &["/home/user/project-a", "/home/user/project-b"],
+            &["/home/user/project-a/.claude/worktrees/s1"],
+        );
+        assert!(config.enabled);
+        assert!(config.rw_paths.contains(&PathBuf::from("/home/user/project-a")));
+        assert!(config.rw_paths.contains(&PathBuf::from("/home/user/project-b")));
+        assert!(config.rw_paths.contains(&PathBuf::from(
+            "/home/user/project-a/.claude/worktrees/s1"
+        )));
+        // tmp always present
+        assert!(config.rw_paths.contains(&std::env::temp_dir()));
+    }
+
+    #[test]
+    fn test_ro_paths_include_system_dirs() {
+        let config = SandboxConfig::for_project("/tmp/test", None);
+        let ro_strs: Vec<String> = config.ro_paths.iter().map(|p| p.display().to_string()).collect();
+
+        assert!(ro_strs.iter().any(|p| p == "/usr"), "missing /usr");
+        assert!(ro_strs.iter().any(|p| p == "/lib"), "missing /lib");
+        assert!(ro_strs.iter().any(|p| p == "/etc"), "missing /etc");
+        assert!(ro_strs.iter().any(|p| p == "/proc"), "missing /proc");
+        assert!(ro_strs.iter().any(|p| p == "/dev"), "missing /dev");
+        assert!(ro_strs.iter().any(|p| p == "/bin"), "missing /bin");
+    }
+
+    #[test]
+    fn test_ro_paths_include_runtime_dirs() {
+        let config = SandboxConfig::for_project("/tmp/test", None);
+        let home = dirs::home_dir().unwrap();
+
+        assert!(config.ro_paths.contains(&home.join(".local")));
+        assert!(config.ro_paths.contains(&home.join(".deno")));
+        assert!(config.ro_paths.contains(&home.join(".nvm")));
+        assert!(config.ro_paths.contains(&home.join(".config")));
+        assert!(config.ro_paths.contains(&home.join(".claude")));
+    }
+
+    #[test]
+    fn test_disabled_apply_returns_false() {
+        let config = SandboxConfig::default();
+        assert_eq!(config.apply().unwrap(), false);
+    }
+
+    #[test]
+    fn test_rw_paths_count() {
+        // Single project: cwd + tmp = 2
+        let config = SandboxConfig::for_project("/tmp/test", None);
+        assert_eq!(config.rw_paths.len(), 2);
+
+        // With worktree: cwd + worktree + tmp = 3
+        let config = SandboxConfig::for_project("/tmp/test", Some("/tmp/wt"));
+        assert_eq!(config.rw_paths.len(), 3);
+    }
+
+    #[test]
+    fn test_for_projects_empty() {
+        let config = SandboxConfig::for_projects(&[], &[]);
+        assert!(config.enabled);
+        // Only tmp dir in rw
+        assert_eq!(config.rw_paths.len(), 1);
+        assert_eq!(config.rw_paths[0], std::env::temp_dir());
+    }
+}
diff --git a/v2/bterminal-core/src/sidecar.rs b/v2/bterminal-core/src/sidecar.rs
new file mode 100644
index 0000000..3108c3b
--- /dev/null
+++ b/v2/bterminal-core/src/sidecar.rs
@@ -0,0 +1,495 @@
+// Sidecar lifecycle management (Deno-first, Node.js fallback)
+// Spawns bundled agent-runner.mjs via deno or node, communicates via stdio NDJSON
+
+use serde::{Deserialize, Serialize};
+use std::io::{BufRead, BufReader, Write};
+#[cfg(unix)]
+use std::os::unix::process::CommandExt;
+use std::path::PathBuf;
+use std::process::{Child, Command, Stdio};
+use std::sync::{Arc, Mutex};
+use std::thread;
+
+use crate::event::EventSink;
+use crate::sandbox::SandboxConfig;
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct AgentQueryOptions {
+    #[serde(default = "default_provider")]
+    pub provider: String,
+    pub session_id: String,
+    pub prompt: String,
+    pub cwd: Option<String>,
+    pub max_turns: Option<u32>,
+    pub max_budget_usd: Option<f64>,
+    pub resume_session_id: Option<String>,
+    pub permission_mode: Option<String>,
+    pub setting_sources: Option<Vec<String>>,
+    pub system_prompt: Option<String>,
+    pub model: Option<String>,
+    pub claude_config_dir: Option<String>,
+    pub additional_directories: Option<Vec<String>>,
+    /// When set, agent runs in a git worktree for isolation (passed as --worktree <name> CLI flag)
+    pub worktree_name: Option<String>,
+    /// Provider-specific configuration blob (passed through to sidecar as-is)
+    #[serde(default)]
+    pub provider_config: serde_json::Value,
+    /// Extra environment variables injected into the agent process (e.g. BTMSG_AGENT_ID)
+    #[serde(default)]
+    pub extra_env: std::collections::HashMap<String, String>,
+}
+
+fn default_provider() -> String {
+    "claude".to_string()
+}
+
+/// Directories to search for sidecar scripts.
+#[derive(Debug, Clone)]
+pub struct SidecarConfig {
+    pub search_paths: Vec<PathBuf>,
+    /// Extra env vars forwarded to sidecar processes (e.g. BTERMINAL_TEST=1 for test isolation)
+    pub env_overrides: std::collections::HashMap<String, String>,
+    /// Landlock filesystem sandbox configuration (Linux 5.13+, applied via pre_exec)
+    pub sandbox: SandboxConfig,
+}
+
+struct SidecarCommand {
+    program: String,
+    args: Vec<String>,
+}
+
+pub struct SidecarManager {
+    child: Arc<Mutex<Option<Child>>>,
+    stdin_writer: Arc<Mutex<Option<Box<dyn Write + Send>>>>,
+    ready: Arc<Mutex<bool>>,
+    sink: Arc<dyn EventSink>,
+    config: Mutex<SidecarConfig>,
+}
+
+impl SidecarManager {
+    pub fn new(sink: Arc<dyn EventSink>, config: SidecarConfig) -> Self {
+        Self {
+            child: Arc::new(Mutex::new(None)),
+            stdin_writer: Arc::new(Mutex::new(None)),
+            ready: Arc::new(Mutex::new(false)),
+            sink,
+            config: Mutex::new(config),
+        }
+    }
+
+    /// Update the sandbox configuration. Takes effect on next sidecar (re)start.
+    pub fn set_sandbox(&self, sandbox: SandboxConfig) {
+        self.config.lock().unwrap().sandbox = sandbox;
+    }
+
+    pub fn start(&self) -> Result<(), String> {
+        let mut child_lock = self.child.lock().unwrap();
+        if child_lock.is_some() {
+            return Err("Sidecar already running".to_string());
+        }
+
+        let config = self.config.lock().unwrap();
+        let cmd = self.resolve_sidecar_command_with_config(&config)?;
+
+        log::info!("Starting sidecar: {} {}", cmd.program, cmd.args.join(" "));
+
+        // Build a clean environment stripping provider-specific vars to prevent
+        // SDKs from detecting nesting when BTerminal is launched from a provider terminal.
+        // Per-provider prefixes: CLAUDE* (whitelist CLAUDE_CODE_EXPERIMENTAL_*),
+        // CODEX* and OLLAMA* for future providers.
+        let clean_env: Vec<(String, String)> = std::env::vars()
+            .filter(|(k, _)| {
+                strip_provider_env_var(k)
+            })
+            .collect();
+
+        let mut command = Command::new(&cmd.program);
+        command
+            .args(&cmd.args)
+            .env_clear()
+            .envs(clean_env)
+            .envs(config.env_overrides.iter().map(|(k, v)| (k.as_str(), v.as_str())))
+            .stdin(Stdio::piped())
+            .stdout(Stdio::piped())
+            .stderr(Stdio::piped());
+
+        // Apply Landlock sandbox in child process before exec (Linux only).
+        // Restrictions are inherited by all child processes (provider CLIs).
+        #[cfg(unix)]
+        if config.sandbox.enabled {
+            let sandbox = config.sandbox.clone();
+            unsafe {
+                command.pre_exec(move || {
+                    sandbox.apply().map(|enforced| {
+                        if !enforced {
+                            log::warn!("Landlock sandbox not enforced in sidecar child");
+                        }
+                    }).map_err(|e| std::io::Error::new(std::io::ErrorKind::Other, e))
+                });
+            }
+        }
+
+        // Drop config lock before spawn (pre_exec closure owns the sandbox clone)
+        drop(config);
+
+        let mut child = command
+            .spawn()
+            .map_err(|e| format!("Failed to start sidecar: {e}"))?;
+
+        let child_stdin = child
+            .stdin
+            .take()
+            .ok_or("Failed to capture sidecar stdin")?;
+        let child_stdout = child
+            .stdout
+            .take()
+            .ok_or("Failed to capture sidecar stdout")?;
+        let child_stderr = child
+            .stderr
+            .take()
+            .ok_or("Failed to capture sidecar stderr")?;
+
+        *self.stdin_writer.lock().unwrap() = Some(Box::new(child_stdin));
+
+        // Stdout reader thread — forwards NDJSON to event sink
+        let sink = self.sink.clone();
+        let ready = self.ready.clone();
+        thread::spawn(move || {
+            let reader = BufReader::new(child_stdout);
+            for line in reader.lines() {
+                match line {
+                    Ok(line) => {
+                        if line.trim().is_empty() {
+                            continue;
+                        }
+                        match serde_json::from_str::<serde_json::Value>(&line) {
+                            Ok(msg) => {
+                                if msg.get("type").and_then(|t| t.as_str()) == Some("ready") {
+                                    *ready.lock().unwrap() = true;
+                                    log::info!("Sidecar ready");
+                                }
+                                sink.emit("sidecar-message", msg);
+                            }
+                            Err(e) => {
+                                log::warn!("Invalid JSON from sidecar: {e}: {line}");
+                            }
+                        }
+                    }
+                    Err(e) => {
+                        log::error!("Sidecar stdout read error: {e}");
+                        break;
+                    }
+                }
+            }
+            log::info!("Sidecar stdout reader exited");
+            sink.emit("sidecar-exited", serde_json::Value::Null);
+        });
+
+        // Stderr reader thread — logs only
+        thread::spawn(move || {
+            let reader = BufReader::new(child_stderr);
+            for line in reader.lines() {
+                match line {
+                    Ok(line) => log::info!("[sidecar stderr] {line}"),
+                    Err(e) => {
+                        log::error!("Sidecar stderr read error: {e}");
+                        break;
+                    }
+                }
+            }
+        });
+
+        *child_lock = Some(child);
+        Ok(())
+    }
+
+    pub fn send_message(&self, msg: &serde_json::Value) -> Result<(), String> {
+        let mut writer_lock = self.stdin_writer.lock().unwrap();
+        let writer = writer_lock.as_mut().ok_or("Sidecar not running")?;
+
+        let line =
+            serde_json::to_string(msg).map_err(|e| format!("JSON serialize error: {e}"))?;
+
+        writer
+            .write_all(line.as_bytes())
+            .map_err(|e| format!("Sidecar write error: {e}"))?;
+        writer
+            .write_all(b"\n")
+            .map_err(|e| format!("Sidecar write error: {e}"))?;
+        writer
+            .flush()
+            .map_err(|e| format!("Sidecar flush error: {e}"))?;
+
+        Ok(())
+    }
+
+    pub fn query(&self, options: &AgentQueryOptions) -> Result<(), String> {
+        if !*self.ready.lock().unwrap() {
+            return Err("Sidecar not ready".to_string());
+        }
+
+        // Validate that the requested provider has a runner available
+        let runner_name = format!("{}-runner.mjs", options.provider);
+        let config = self.config.lock().unwrap();
+        let runner_exists = config
+            .search_paths
+            .iter()
+            .any(|base| base.join("dist").join(&runner_name).exists());
+        drop(config);
+        if !runner_exists {
+            return Err(format!(
+                "No sidecar runner found for provider '{}' (expected {})",
+                options.provider, runner_name
+            ));
+        }
+
+        let msg = serde_json::json!({
+            "type": "query",
+            "provider": options.provider,
+            "sessionId": options.session_id,
+            "prompt": options.prompt,
+            "cwd": options.cwd,
+            "maxTurns": options.max_turns,
+            "maxBudgetUsd": options.max_budget_usd,
+            "resumeSessionId": options.resume_session_id,
+            "permissionMode": options.permission_mode,
+            "settingSources": options.setting_sources,
+            "systemPrompt": options.system_prompt,
+            "model": options.model,
+            "claudeConfigDir": options.claude_config_dir,
+            "additionalDirectories": options.additional_directories,
+            "worktreeName": options.worktree_name,
+            "providerConfig": options.provider_config,
+            "extraEnv": options.extra_env,
+        });
+
+        self.send_message(&msg)
+    }
+
+    pub fn stop_session(&self, session_id: &str) -> Result<(), String> {
+        let msg = serde_json::json!({
+            "type": "stop",
+            "sessionId": session_id,
+        });
+        self.send_message(&msg)
+    }
+
+    pub fn restart(&self) -> Result<(), String> {
+        log::info!("Restarting sidecar");
+        let _ = self.shutdown();
+        self.start()
+    }
+
+    pub fn shutdown(&self) -> Result<(), String> {
+        let mut child_lock = self.child.lock().unwrap();
+        if let Some(ref mut child) = *child_lock {
+            log::info!("Shutting down sidecar");
+            *self.stdin_writer.lock().unwrap() = None;
+            let _ = child.kill();
+            let _ = child.wait();
+        }
+        *child_lock = None;
+        *self.ready.lock().unwrap() = false;
+        Ok(())
+    }
+
+    pub fn is_ready(&self) -> bool {
+        *self.ready.lock().unwrap()
+    }
+
+    /// Resolve a sidecar runner command. Uses the default claude-runner for startup.
+    /// Future providers will have their own runners (e.g. codex-runner.mjs).
+    fn resolve_sidecar_command_with_config(&self, config: &SidecarConfig) -> Result<SidecarCommand, String> {
+        Self::resolve_sidecar_for_provider_with_config(config, "claude")
+    }
+
+    /// Resolve a sidecar command for a specific provider's runner file.
+    fn resolve_sidecar_for_provider_with_config(config: &SidecarConfig, provider: &str) -> Result<SidecarCommand, String> {
+        let runner_name = format!("{}-runner.mjs", provider);
+
+        // Try Deno first (faster startup, better perf), fall back to Node.js.
+        let has_deno = Command::new("deno")
+            .arg("--version")
+            .stdout(Stdio::null())
+            .stderr(Stdio::null())
+            .status()
+            .is_ok();
+        let has_node = Command::new("node")
+            .arg("--version")
+            .stdout(Stdio::null())
+            .stderr(Stdio::null())
+            .status()
+            .is_ok();
+
+        let mut checked = Vec::new();
+
+        for base in &config.search_paths {
+            let mjs_path = base.join("dist").join(&runner_name);
+            if mjs_path.exists() {
+                if has_deno {
+                    return Ok(SidecarCommand {
+                        program: "deno".to_string(),
+                        args: vec![
+                            "run".to_string(),
+                            "--allow-run".to_string(),
+                            "--allow-env".to_string(),
+                            "--allow-read".to_string(),
+                            "--allow-write".to_string(),
+                            "--allow-net".to_string(),
+                            mjs_path.to_string_lossy().to_string(),
+                        ],
+                    });
+                }
+                if has_node {
+                    return Ok(SidecarCommand {
+                        program: "node".to_string(),
+                        args: vec![mjs_path.to_string_lossy().to_string()],
+                    });
+                }
+            }
+            checked.push(mjs_path);
+        }
+
+        let paths: Vec<_> = checked.iter().map(|p| p.display().to_string()).collect();
+        let runtime_note = if !has_deno && !has_node {
+            ". Neither deno nor node found in PATH"
+        } else {
+            ""
+        };
+        Err(format!(
+            "Sidecar not found for provider '{}'. Checked: {}{}",
+            provider,
+            paths.join(", "),
+            runtime_note,
+        ))
+    }
+}
+
+/// Returns true if the env var should be KEPT (not stripped).
+/// First line of defense: strips provider-specific prefixes to prevent nesting detection
+/// and credential leakage. JS runners apply a second layer of provider-specific stripping.
+///
+/// Stripped prefixes: CLAUDE*, CODEX*, OLLAMA*, ANTHROPIC_*
+/// Whitelisted: CLAUDE_CODE_EXPERIMENTAL_* (feature flags like agent teams)
+///
+/// Note: OPENAI_* is NOT stripped here because the Codex runner needs OPENAI_API_KEY
+/// from the environment (it re-injects it after its own stripping). If Codex support
+/// moves to extraEnv-based key injection, add OPENAI to this list.
+fn strip_provider_env_var(key: &str) -> bool {
+    if key.starts_with("CLAUDE_CODE_EXPERIMENTAL_") {
+        return true;
+    }
+    if key.starts_with("CLAUDE")
+        || key.starts_with("CODEX")
+        || key.starts_with("OLLAMA")
+        || key.starts_with("ANTHROPIC_")
+    {
+        return false;
+    }
+    true
+}
+
+impl Drop for SidecarManager {
+    fn drop(&mut self) {
+        let _ = self.shutdown();
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    // ---- strip_provider_env_var unit tests ----
+
+    #[test]
+    fn test_keeps_normal_env_vars() {
+        assert!(strip_provider_env_var("HOME"));
+        assert!(strip_provider_env_var("PATH"));
+        assert!(strip_provider_env_var("USER"));
+        assert!(strip_provider_env_var("SHELL"));
+        assert!(strip_provider_env_var("TERM"));
+        assert!(strip_provider_env_var("XDG_DATA_HOME"));
+        assert!(strip_provider_env_var("RUST_LOG"));
+    }
+
+    #[test]
+    fn test_strips_claude_vars() {
+        assert!(!strip_provider_env_var("CLAUDE_CONFIG_DIR"));
+        assert!(!strip_provider_env_var("CLAUDE_SESSION_ID"));
+        assert!(!strip_provider_env_var("CLAUDECODE"));
+        assert!(!strip_provider_env_var("CLAUDE_API_KEY"));
+    }
+
+    #[test]
+    fn test_whitelists_claude_code_experimental() {
+        assert!(strip_provider_env_var("CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS"));
+        assert!(strip_provider_env_var("CLAUDE_CODE_EXPERIMENTAL_TOOLS"));
+        assert!(strip_provider_env_var("CLAUDE_CODE_EXPERIMENTAL_SOMETHING_NEW"));
+    }
+
+    #[test]
+    fn test_strips_codex_vars() {
+        assert!(!strip_provider_env_var("CODEX_API_KEY"));
+        assert!(!strip_provider_env_var("CODEX_SESSION"));
+        assert!(!strip_provider_env_var("CODEX_CONFIG"));
+    }
+
+    #[test]
+    fn test_strips_ollama_vars() {
+        assert!(!strip_provider_env_var("OLLAMA_HOST"));
+        assert!(!strip_provider_env_var("OLLAMA_MODELS"));
+        assert!(!strip_provider_env_var("OLLAMA_NUM_PARALLEL"));
+    }
+
+    #[test]
+    fn test_strips_anthropic_vars() {
+        // ANTHROPIC_* vars stripped at Rust layer (defense in depth)
+        // Claude CLI has its own auth via credentials file
+        assert!(!strip_provider_env_var("ANTHROPIC_API_KEY"));
+        assert!(!strip_provider_env_var("ANTHROPIC_BASE_URL"));
+        assert!(!strip_provider_env_var("ANTHROPIC_LOG"));
+    }
+
+    #[test]
+    fn test_keeps_openai_vars() {
+        // OPENAI_* vars are NOT stripped by the Rust layer
+        // (they're stripped in the JS codex-runner layer instead)
+        assert!(strip_provider_env_var("OPENAI_API_KEY"));
+        assert!(strip_provider_env_var("OPENAI_BASE_URL"));
+    }
+
+    #[test]
+    fn test_env_filtering_integration() {
+        let test_env = vec![
+            ("HOME", "/home/user"),
+            ("PATH", "/usr/bin"),
+            ("CLAUDE_CONFIG_DIR", "/tmp/claude"),
+            ("CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS", "1"),
+            ("CODEX_API_KEY", "sk-test"),
+            ("OLLAMA_HOST", "localhost"),
+            ("ANTHROPIC_API_KEY", "sk-ant-xxx"),
+            ("OPENAI_API_KEY", "sk-openai-xxx"),
+            ("RUST_LOG", "debug"),
+            ("BTMSG_AGENT_ID", "a1"),
+        ];
+
+        let kept: Vec<&str> = test_env
+            .iter()
+            .filter(|(k, _)| strip_provider_env_var(k))
+            .map(|(k, _)| *k)
+            .collect();
+
+        assert!(kept.contains(&"HOME"));
+        assert!(kept.contains(&"PATH"));
+        assert!(kept.contains(&"CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS"));
+        assert!(kept.contains(&"RUST_LOG"));
+        assert!(kept.contains(&"BTMSG_AGENT_ID"));
+        // OPENAI_* passes through Rust layer (Codex runner needs it)
+        assert!(kept.contains(&"OPENAI_API_KEY"));
+        // These are stripped:
+        assert!(!kept.contains(&"CLAUDE_CONFIG_DIR"));
+        assert!(!kept.contains(&"CODEX_API_KEY"));
+        assert!(!kept.contains(&"OLLAMA_HOST"));
+        assert!(!kept.contains(&"ANTHROPIC_API_KEY"));
+    }
+}
diff --git a/v2/bterminal-core/src/supervisor.rs b/v2/bterminal-core/src/supervisor.rs
new file mode 100644
index 0000000..119a962
--- /dev/null
+++ b/v2/bterminal-core/src/supervisor.rs
@@ -0,0 +1,684 @@
+// Sidecar crash recovery and supervision.
+// Wraps a SidecarManager with automatic restart, exponential backoff,
+// and health status tracking. Emits `sidecar-health-changed` events.
+
+use serde::{Deserialize, Serialize};
+use std::sync::{Arc, Mutex};
+use std::time::{Duration, Instant};
+
+use crate::event::EventSink;
+use crate::sidecar::{AgentQueryOptions, SidecarConfig, SidecarManager};
+
+/// Health status of the supervised sidecar process.
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+#[serde(tag = "status", rename_all = "camelCase")]
+pub enum SidecarHealth {
+    Healthy,
+    Degraded {
+        restart_count: u32,
+    },
+    Failed {
+        #[serde(default)]
+        last_error: String,
+    },
+}
+
+/// Configuration for supervisor restart behavior.
+#[derive(Debug, Clone)]
+pub struct SupervisorConfig {
+    /// Maximum restart attempts before entering Failed state (default: 5)
+    pub max_retries: u32,
+    /// Base backoff in milliseconds, doubled each retry (default: 1000, cap: 30000)
+    pub backoff_base_ms: u64,
+    /// Maximum backoff in milliseconds (default: 30000)
+    pub backoff_cap_ms: u64,
+    /// Stable operation duration before restart_count resets (default: 5 minutes)
+    pub stability_window: Duration,
+}
+
+impl Default for SupervisorConfig {
+    fn default() -> Self {
+        Self {
+            max_retries: 5,
+            backoff_base_ms: 1000,
+            backoff_cap_ms: 30_000,
+            stability_window: Duration::from_secs(300),
+        }
+    }
+}
+
+/// Internal state shared between the supervisor and its event interceptor.
+struct SupervisorState {
+    health: SidecarHealth,
+    restart_count: u32,
+    last_crash_time: Option<Instant>,
+    last_start_time: Option<Instant>,
+}
+
+impl SupervisorState {
+    fn new() -> Self {
+        Self {
+            health: SidecarHealth::Healthy,
+            restart_count: 0,
+            last_crash_time: None,
+            last_start_time: None,
+        }
+    }
+}
+
+/// Compute exponential backoff: base_ms * 2^attempt, capped at cap_ms.
+fn compute_backoff(base_ms: u64, attempt: u32, cap_ms: u64) -> Duration {
+    let backoff = base_ms.saturating_mul(1u64.checked_shl(attempt).unwrap_or(u64::MAX));
+    Duration::from_millis(backoff.min(cap_ms))
+}
+
+/// EventSink wrapper that intercepts `sidecar-exited` events and triggers
+/// supervisor restart logic, while forwarding all other events unchanged.
+struct SupervisorSink {
+    outer_sink: Arc<dyn EventSink>,
+    state: Arc<Mutex<SupervisorState>>,
+    config: SupervisorConfig,
+    sidecar_config: SidecarConfig,
+}
+
+impl EventSink for SupervisorSink {
+    fn emit(&self, event: &str, payload: serde_json::Value) {
+        if event == "sidecar-exited" {
+            self.handle_exit();
+        } else {
+            self.outer_sink.emit(event, payload);
+        }
+    }
+}
+
+impl SupervisorSink {
+    fn handle_exit(&self) {
+        let (should_restart, backoff, restart_count) = {
+            let mut state = self.state.lock().unwrap();
+
+            // Check if stable operation has elapsed since last start — reset counter
+            if let Some(start_time) = state.last_start_time {
+                if start_time.elapsed() >= self.config.stability_window {
+                    log::info!(
+                        "Sidecar ran stable for {:?}, resetting restart count",
+                        start_time.elapsed()
+                    );
+                    state.restart_count = 0;
+                }
+            }
+
+            state.restart_count += 1;
+            state.last_crash_time = Some(Instant::now());
+            let count = state.restart_count;
+
+            if count > self.config.max_retries {
+                let error = format!("Exceeded max retries ({})", self.config.max_retries);
+                log::error!("Sidecar supervisor: {}", error);
+                state.health = SidecarHealth::Failed {
+                    last_error: error.clone(),
+                };
+                self.emit_health(&state.health);
+                // Forward the original exited event so frontend knows
+                self.outer_sink
+                    .emit("sidecar-exited", serde_json::Value::Null);
+                return;
+            }
+
+            state.health = SidecarHealth::Degraded {
+                restart_count: count,
+            };
+            self.emit_health(&state.health);
+
+            let backoff = compute_backoff(
+                self.config.backoff_base_ms,
+                count - 1,
+                self.config.backoff_cap_ms,
+            );
+
+            (true, backoff, count)
+        };
+
+        if !should_restart {
+            return;
+        }
+
+        log::warn!(
+            "Sidecar crashed (attempt {}/{}), restarting in {:?}",
+            restart_count,
+            self.config.max_retries,
+            backoff
+        );
+
+        // Restart on a background thread to avoid blocking the stdout reader
+        let outer_sink = self.outer_sink.clone();
+        let state = self.state.clone();
+        let sidecar_config = self.sidecar_config.clone();
+        let supervisor_state = self.state.clone();
+        let stability_window = self.config.stability_window;
+        let max_retries = self.config.max_retries;
+        let backoff_base_ms = self.config.backoff_base_ms;
+        let backoff_cap_ms = self.config.backoff_cap_ms;
+
+        std::thread::spawn(move || {
+            std::thread::sleep(backoff);
+
+            // Create a new SidecarManager that shares our supervisor sink.
+            // We need a new interceptor sink to capture the next exit event.
+            let new_state = state.clone();
+            let new_outer = outer_sink.clone();
+            let new_sidecar_config = sidecar_config.clone();
+
+            let interceptor: Arc<dyn EventSink> = Arc::new(SupervisorSink {
+                outer_sink: new_outer.clone(),
+                state: new_state.clone(),
+                config: SupervisorConfig {
+                    max_retries,
+                    backoff_base_ms,
+                    backoff_cap_ms,
+                    stability_window,
+                },
+                sidecar_config: new_sidecar_config.clone(),
+            });
+
+            let new_manager = SidecarManager::new(interceptor, new_sidecar_config);
+            match new_manager.start() {
+                Ok(()) => {
+                    let mut s = supervisor_state.lock().unwrap();
+                    s.last_start_time = Some(Instant::now());
+                    log::info!("Sidecar restarted successfully (attempt {})", restart_count);
+                    // Note: we cannot replace the manager reference in the outer
+                    // SidecarSupervisor from here. The restart creates a new manager
+                    // that handles its own lifecycle. The outer manager reference
+                    // becomes stale. This is acceptable because:
+                    // 1. The new manager's stdout reader will emit through our sink chain
+                    // 2. The old manager's child process is already dead
+                    // For a more sophisticated approach, the supervisor would need
+                    // interior mutability on the manager reference. We do that below.
+                }
+                Err(e) => {
+                    log::error!("Sidecar restart failed: {}", e);
+                    let mut s = supervisor_state.lock().unwrap();
+                    s.health = SidecarHealth::Failed {
+                        last_error: e.clone(),
+                    };
+                    // Emit health change + forward exited
+                    drop(s);
+                    let health = SidecarHealth::Failed { last_error: e };
+                    emit_health_event(&new_outer, &health);
+                    new_outer
+                        .emit("sidecar-exited", serde_json::Value::Null);
+                }
+            }
+        });
+    }
+
+    fn emit_health(&self, health: &SidecarHealth) {
+        emit_health_event(&self.outer_sink, health);
+    }
+}
+
+fn emit_health_event(sink: &Arc<dyn EventSink>, health: &SidecarHealth) {
+    let payload = serde_json::to_value(health).unwrap_or(serde_json::Value::Null);
+    sink.emit("sidecar-health-changed", payload);
+}
+
+/// Supervised sidecar process with automatic crash recovery.
+///
+/// Wraps a `SidecarManager` and intercepts exit events to perform automatic
+/// restarts with exponential backoff. Tracks health status and emits
+/// `sidecar-health-changed` events.
+pub struct SidecarSupervisor {
+    manager: Arc<Mutex<SidecarManager>>,
+    state: Arc<Mutex<SupervisorState>>,
+    outer_sink: Arc<dyn EventSink>,
+    #[allow(dead_code)]
+    supervisor_config: SupervisorConfig,
+    #[allow(dead_code)]
+    sidecar_config: SidecarConfig,
+}
+
+impl SidecarSupervisor {
+    pub fn new(
+        sink: Arc<dyn EventSink>,
+        sidecar_config: SidecarConfig,
+        supervisor_config: SupervisorConfig,
+    ) -> Self {
+        let state = Arc::new(Mutex::new(SupervisorState::new()));
+
+        let interceptor: Arc<dyn EventSink> = Arc::new(SupervisorSink {
+            outer_sink: sink.clone(),
+            state: state.clone(),
+            config: supervisor_config.clone(),
+            sidecar_config: sidecar_config.clone(),
+        });
+
+        let manager = SidecarManager::new(interceptor, sidecar_config.clone());
+
+        Self {
+            manager: Arc::new(Mutex::new(manager)),
+            state,
+            outer_sink: sink,
+            supervisor_config,
+            sidecar_config,
+        }
+    }
+
+    /// Start the supervised sidecar process.
+    pub fn start(&self) -> Result<(), String> {
+        let manager = self.manager.lock().unwrap();
+        let result = manager.start();
+        if result.is_ok() {
+            let mut state = self.state.lock().unwrap();
+            state.last_start_time = Some(Instant::now());
+            state.health = SidecarHealth::Healthy;
+        }
+        result
+    }
+
+    /// Send a raw JSON message to the sidecar.
+    pub fn send_message(&self, msg: &serde_json::Value) -> Result<(), String> {
+        self.manager.lock().unwrap().send_message(msg)
+    }
+
+    /// Send an agent query to the sidecar.
+    pub fn query(&self, options: &AgentQueryOptions) -> Result<(), String> {
+        self.manager.lock().unwrap().query(options)
+    }
+
+    /// Stop a specific agent session.
+    pub fn stop_session(&self, session_id: &str) -> Result<(), String> {
+        self.manager.lock().unwrap().stop_session(session_id)
+    }
+
+    /// Check if the sidecar is ready to accept queries.
+    pub fn is_ready(&self) -> bool {
+        self.manager.lock().unwrap().is_ready()
+    }
+
+    /// Shut down the sidecar process.
+    pub fn shutdown(&self) -> Result<(), String> {
+        let mut state = self.state.lock().unwrap();
+        state.health = SidecarHealth::Healthy;
+        state.restart_count = 0;
+        drop(state);
+        self.manager.lock().unwrap().shutdown()
+    }
+
+    /// Get the current health status.
+    pub fn health(&self) -> SidecarHealth {
+        self.state.lock().unwrap().health.clone()
+    }
+
+    /// Get the current restart count.
+    pub fn restart_count(&self) -> u32 {
+        self.state.lock().unwrap().restart_count
+    }
+
+    /// Manually reset the supervisor state (e.g., after user intervention).
+    pub fn reset(&self) {
+        let mut state = self.state.lock().unwrap();
+        state.health = SidecarHealth::Healthy;
+        state.restart_count = 0;
+        state.last_crash_time = None;
+        emit_health_event(&self.outer_sink, &state.health);
+    }
+}
+
+impl Drop for SidecarSupervisor {
+    fn drop(&mut self) {
+        let _ = self.shutdown();
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::sync::atomic::{AtomicU32, Ordering};
+
+    // ---- compute_backoff tests ----
+
+    #[test]
+    fn test_backoff_base_case() {
+        let d = compute_backoff(1000, 0, 30_000);
+        assert_eq!(d, Duration::from_millis(1000));
+    }
+
+    #[test]
+    fn test_backoff_exponential() {
+        assert_eq!(compute_backoff(1000, 1, 30_000), Duration::from_millis(2000));
+        assert_eq!(compute_backoff(1000, 2, 30_000), Duration::from_millis(4000));
+        assert_eq!(compute_backoff(1000, 3, 30_000), Duration::from_millis(8000));
+        assert_eq!(compute_backoff(1000, 4, 30_000), Duration::from_millis(16000));
+    }
+
+    #[test]
+    fn test_backoff_capped() {
+        assert_eq!(compute_backoff(1000, 5, 30_000), Duration::from_millis(30_000));
+        assert_eq!(compute_backoff(1000, 10, 30_000), Duration::from_millis(30_000));
+    }
+
+    #[test]
+    fn test_backoff_overflow_safe() {
+        // Very large attempt should not panic, just cap
+        assert_eq!(compute_backoff(1000, 63, 30_000), Duration::from_millis(30_000));
+        assert_eq!(compute_backoff(1000, 100, 30_000), Duration::from_millis(30_000));
+    }
+
+    #[test]
+    fn test_backoff_custom_base() {
+        assert_eq!(compute_backoff(500, 0, 10_000), Duration::from_millis(500));
+        assert_eq!(compute_backoff(500, 1, 10_000), Duration::from_millis(1000));
+        assert_eq!(compute_backoff(500, 5, 10_000), Duration::from_millis(10_000));
+    }
+
+    // ---- SidecarHealth serialization tests ----
+
+    #[test]
+    fn test_health_serialize_healthy() {
+        let h = SidecarHealth::Healthy;
+        let json = serde_json::to_value(&h).unwrap();
+        assert_eq!(json["status"], "healthy");
+    }
+
+    #[test]
+    fn test_health_serialize_degraded() {
+        let h = SidecarHealth::Degraded { restart_count: 3 };
+        let json = serde_json::to_value(&h).unwrap();
+        assert_eq!(json["status"], "degraded");
+        assert_eq!(json["restart_count"], 3);
+    }
+
+    #[test]
+    fn test_health_serialize_failed() {
+        let h = SidecarHealth::Failed {
+            last_error: "process killed".to_string(),
+        };
+        let json = serde_json::to_value(&h).unwrap();
+        assert_eq!(json["status"], "failed");
+        assert_eq!(json["last_error"], "process killed");
+    }
+
+    #[test]
+    fn test_health_deserialize_roundtrip() {
+        let cases = vec![
+            SidecarHealth::Healthy,
+            SidecarHealth::Degraded { restart_count: 2 },
+            SidecarHealth::Failed {
+                last_error: "OOM".to_string(),
+            },
+        ];
+        for h in cases {
+            let json = serde_json::to_string(&h).unwrap();
+            let back: SidecarHealth = serde_json::from_str(&json).unwrap();
+            assert_eq!(h, back);
+        }
+    }
+
+    // ---- SupervisorConfig defaults ----
+
+    #[test]
+    fn test_supervisor_config_defaults() {
+        let cfg = SupervisorConfig::default();
+        assert_eq!(cfg.max_retries, 5);
+        assert_eq!(cfg.backoff_base_ms, 1000);
+        assert_eq!(cfg.backoff_cap_ms, 30_000);
+        assert_eq!(cfg.stability_window, Duration::from_secs(300));
+    }
+
+    // ---- SupervisorState tests ----
+
+    #[test]
+    fn test_initial_state() {
+        let state = SupervisorState::new();
+        assert_eq!(state.health, SidecarHealth::Healthy);
+        assert_eq!(state.restart_count, 0);
+        assert!(state.last_crash_time.is_none());
+        assert!(state.last_start_time.is_none());
+    }
+
+    // ---- Event interception tests (using mock sink) ----
+
+    /// Mock EventSink that records emitted events.
+    struct MockSink {
+        events: Mutex<Vec<(String, serde_json::Value)>>,
+        exit_count: AtomicU32,
+    }
+
+    impl MockSink {
+        fn new() -> Self {
+            Self {
+                events: Mutex::new(Vec::new()),
+                exit_count: AtomicU32::new(0),
+            }
+        }
+
+        fn events(&self) -> Vec<(String, serde_json::Value)> {
+            self.events.lock().unwrap().clone()
+        }
+
+        fn health_events(&self) -> Vec<SidecarHealth> {
+            self.events
+                .lock()
+                .unwrap()
+                .iter()
+                .filter(|(name, _)| name == "sidecar-health-changed")
+                .filter_map(|(_, payload)| serde_json::from_value(payload.clone()).ok())
+                .collect()
+        }
+    }
+
+    impl EventSink for MockSink {
+        fn emit(&self, event: &str, payload: serde_json::Value) {
+            if event == "sidecar-exited" {
+                self.exit_count.fetch_add(1, Ordering::SeqCst);
+            }
+            self.events
+                .lock()
+                .unwrap()
+                .push((event.to_string(), payload));
+        }
+    }
+
+    #[test]
+    fn test_non_exit_events_forwarded() {
+        let outer = Arc::new(MockSink::new());
+        let state = Arc::new(Mutex::new(SupervisorState::new()));
+        let sink = SupervisorSink {
+            outer_sink: outer.clone(),
+            state,
+            config: SupervisorConfig::default(),
+            sidecar_config: SidecarConfig {
+                search_paths: vec![],
+                env_overrides: Default::default(),
+                sandbox: Default::default(),
+            },
+        };
+
+        let payload = serde_json::json!({"type": "ready"});
+        sink.emit("sidecar-message", payload.clone());
+
+        let events = outer.events();
+        assert_eq!(events.len(), 1);
+        assert_eq!(events[0].0, "sidecar-message");
+        assert_eq!(events[0].1, payload);
+    }
+
+    #[test]
+    fn test_exit_triggers_degraded_health() {
+        let outer = Arc::new(MockSink::new());
+        let state = Arc::new(Mutex::new(SupervisorState::new()));
+        let sink = SupervisorSink {
+            outer_sink: outer.clone(),
+            state: state.clone(),
+            config: SupervisorConfig {
+                max_retries: 5,
+                backoff_base_ms: 100,
+                backoff_cap_ms: 1000,
+                stability_window: Duration::from_secs(300),
+            },
+            sidecar_config: SidecarConfig {
+                search_paths: vec![],
+                env_overrides: Default::default(),
+                sandbox: Default::default(),
+            },
+        };
+
+        // Simulate exit
+        sink.emit("sidecar-exited", serde_json::Value::Null);
+
+        let s = state.lock().unwrap();
+        assert_eq!(s.restart_count, 1);
+        assert!(s.last_crash_time.is_some());
+        match &s.health {
+            SidecarHealth::Degraded { restart_count } => assert_eq!(*restart_count, 1),
+            other => panic!("Expected Degraded, got {:?}", other),
+        }
+
+        // Should have emitted health-changed event
+        let health_events = outer.health_events();
+        assert_eq!(health_events.len(), 1);
+        assert_eq!(
+            health_events[0],
+            SidecarHealth::Degraded { restart_count: 1 }
+        );
+    }
+
+    #[test]
+    fn test_exit_exceeding_max_retries_fails() {
+        let outer = Arc::new(MockSink::new());
+        let state = Arc::new(Mutex::new(SupervisorState {
+            health: SidecarHealth::Degraded { restart_count: 5 },
+            restart_count: 5,
+            last_crash_time: Some(Instant::now()),
+            last_start_time: Some(Instant::now()),
+        }));
+
+        let sink = SupervisorSink {
+            outer_sink: outer.clone(),
+            state: state.clone(),
+            config: SupervisorConfig {
+                max_retries: 5,
+                ..SupervisorConfig::default()
+            },
+            sidecar_config: SidecarConfig {
+                search_paths: vec![],
+                env_overrides: Default::default(),
+                sandbox: Default::default(),
+            },
+        };
+
+        // This is attempt 6, which exceeds max_retries=5
+        sink.emit("sidecar-exited", serde_json::Value::Null);
+
+        let s = state.lock().unwrap();
+        assert_eq!(s.restart_count, 6);
+        match &s.health {
+            SidecarHealth::Failed { last_error } => {
+                assert!(last_error.contains("Exceeded max retries"));
+            }
+            other => panic!("Expected Failed, got {:?}", other),
+        }
+
+        // Should have emitted health-changed with Failed + forwarded sidecar-exited
+        let events = outer.events();
+        let health_changed = events
+            .iter()
+            .filter(|(name, _)| name == "sidecar-health-changed")
+            .count();
+        let exited = events
+            .iter()
+            .filter(|(name, _)| name == "sidecar-exited")
+            .count();
+        assert_eq!(health_changed, 1);
+        assert_eq!(exited, 1); // Forwarded after max retries
+    }
+
+    #[test]
+    fn test_stability_window_resets_count() {
+        let outer = Arc::new(MockSink::new());
+        // Simulate: started 6 minutes ago, ran stable
+        let state = Arc::new(Mutex::new(SupervisorState {
+            health: SidecarHealth::Degraded { restart_count: 3 },
+            restart_count: 3,
+            last_crash_time: Some(Instant::now() - Duration::from_secs(400)),
+            last_start_time: Some(Instant::now() - Duration::from_secs(360)),
+        }));
+
+        let sink = SupervisorSink {
+            outer_sink: outer.clone(),
+            state: state.clone(),
+            config: SupervisorConfig {
+                max_retries: 5,
+                stability_window: Duration::from_secs(300), // 5 min
+                backoff_base_ms: 100,
+                backoff_cap_ms: 1000,
+            },
+            sidecar_config: SidecarConfig {
+                search_paths: vec![],
+                env_overrides: Default::default(),
+                sandbox: Default::default(),
+            },
+        };
+
+        sink.emit("sidecar-exited", serde_json::Value::Null);
+
+        let s = state.lock().unwrap();
+        // Count was reset to 0 then incremented to 1
+        assert_eq!(s.restart_count, 1);
+        match &s.health {
+            SidecarHealth::Degraded { restart_count } => assert_eq!(*restart_count, 1),
+            other => panic!("Expected Degraded(1), got {:?}", other),
+        }
+    }
+
+    #[test]
+    fn test_multiple_crashes_increment_count() {
+        let outer = Arc::new(MockSink::new());
+        let state = Arc::new(Mutex::new(SupervisorState::new()));
+
+        let sink = SupervisorSink {
+            outer_sink: outer.clone(),
+            state: state.clone(),
+            config: SupervisorConfig {
+                max_retries: 10,
+                backoff_base_ms: 100,
+                backoff_cap_ms: 1000,
+                stability_window: Duration::from_secs(300),
+            },
+            sidecar_config: SidecarConfig {
+                search_paths: vec![],
+                env_overrides: Default::default(),
+                sandbox: Default::default(),
+            },
+        };
+
+        for i in 1..=3 {
+            sink.emit("sidecar-exited", serde_json::Value::Null);
+            let s = state.lock().unwrap();
+            assert_eq!(s.restart_count, i);
+        }
+
+        let health_events = outer.health_events();
+        assert_eq!(health_events.len(), 3);
+        assert_eq!(
+            health_events[2],
+            SidecarHealth::Degraded { restart_count: 3 }
+        );
+    }
+
+    #[test]
+    fn test_health_equality() {
+        assert_eq!(SidecarHealth::Healthy, SidecarHealth::Healthy);
+        assert_eq!(
+            SidecarHealth::Degraded { restart_count: 2 },
+            SidecarHealth::Degraded { restart_count: 2 }
+        );
+        assert_ne!(
+            SidecarHealth::Degraded { restart_count: 1 },
+            SidecarHealth::Degraded { restart_count: 2 }
+        );
+        assert_ne!(SidecarHealth::Healthy, SidecarHealth::Failed {
+            last_error: String::new(),
+        });
+    }
+}
diff --git a/v2/bterminal-relay/Cargo.toml b/v2/bterminal-relay/Cargo.toml
new file mode 100644
index 0000000..3e95c7e
--- /dev/null
+++ b/v2/bterminal-relay/Cargo.toml
@@ -0,0 +1,24 @@
+[package]
+name = "bterminal-relay"
+version = "0.1.0"
+edition = "2021"
+description = "Remote relay server for BTerminal multi-machine support"
+license = "MIT"
+
+[[bin]]
+name = "bterminal-relay"
+path = "src/main.rs"
+
+[dependencies]
+bterminal-core = { path = "../bterminal-core" }
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"
+log = "0.4"
+env_logger = "0.11"
+tokio = { version = "1", features = ["full"] }
+tokio-tungstenite = { version = "0.21", features = ["native-tls"] }
+tokio-native-tls = "0.3"
+native-tls = "0.2"
+futures-util = "0.3"
+clap = { version = "4", features = ["derive"] }
+uuid = { version = "1", features = ["v4"] }
diff --git a/v2/bterminal-relay/src/main.rs b/v2/bterminal-relay/src/main.rs
new file mode 100644
index 0000000..7e98edf
--- /dev/null
+++ b/v2/bterminal-relay/src/main.rs
@@ -0,0 +1,441 @@
+// bterminal-relay — WebSocket relay server for remote PTY and agent management
+
+use bterminal_core::event::EventSink;
+use bterminal_core::pty::{PtyManager, PtyOptions};
+use bterminal_core::sidecar::{AgentQueryOptions, SidecarConfig, SidecarManager};
+use clap::Parser;
+use futures_util::{SinkExt, StreamExt};
+use serde::{Deserialize, Serialize};
+use std::net::SocketAddr;
+use std::sync::Arc;
+use tokio::net::{TcpListener, TcpStream};
+use tokio::sync::mpsc;
+use tokio_tungstenite::tungstenite::Message;
+use tokio_tungstenite::tungstenite::http;
+
+#[derive(Parser)]
+#[command(name = "bterminal-relay", about = "BTerminal remote relay server")]
+struct Cli {
+    /// Port to listen on
+    #[arg(short, long, default_value = "9750")]
+    port: u16,
+
+    /// Authentication token (required)
+    #[arg(short, long)]
+    token: String,
+
+    /// Allow insecure ws:// connections (dev mode only)
+    #[arg(long, default_value = "false")]
+    insecure: bool,
+
+    /// TLS certificate file (PEM format). Enables wss:// when provided with --tls-key.
+    #[arg(long)]
+    tls_cert: Option<String>,
+
+    /// TLS private key file (PEM format). Required when --tls-cert is provided.
+    #[arg(long)]
+    tls_key: Option<String>,
+
+    /// Additional sidecar search paths
+    #[arg(long)]
+    sidecar_path: Vec<String>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+struct RelayCommand {
+    id: String,
+    #[serde(rename = "type")]
+    type_: String,
+    payload: serde_json::Value,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+struct RelayEvent {
+    #[serde(rename = "type")]
+    type_: String,
+    #[serde(rename = "sessionId", skip_serializing_if = "Option::is_none")]
+    session_id: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    payload: Option<serde_json::Value>,
+}
+
+/// EventSink that sends events as JSON over an mpsc channel (forwarded to WebSocket).
+struct WsEventSink {
+    tx: mpsc::UnboundedSender<RelayEvent>,
+}
+
+impl EventSink for WsEventSink {
+    fn emit(&self, event: &str, payload: serde_json::Value) {
+        // Parse event name to extract session ID for PTY events like "pty-data-{id}"
+        let (type_, session_id) = if let Some(id) = event.strip_prefix("pty-data-") {
+            ("pty_data".to_string(), Some(id.to_string()))
+        } else if let Some(id) = event.strip_prefix("pty-exit-") {
+            ("pty_exit".to_string(), Some(id.to_string()))
+        } else {
+            (event.replace('-', "_"), None)
+        };
+
+        let _ = self.tx.send(RelayEvent {
+            type_,
+            session_id,
+            payload: if payload.is_null() { None } else { Some(payload) },
+        });
+    }
+}
+
+/// Build a native-tls TLS acceptor from PEM cert and key files.
+fn build_tls_acceptor(cert_path: &str, key_path: &str) -> Result<tokio_native_tls::TlsAcceptor, String> {
+    let cert_pem = std::fs::read(cert_path)
+        .map_err(|e| format!("Failed to read TLS cert '{}': {}", cert_path, e))?;
+    let key_pem = std::fs::read(key_path)
+        .map_err(|e| format!("Failed to read TLS key '{}': {}", key_path, e))?;
+
+    let identity = native_tls::Identity::from_pkcs8(&cert_pem, &key_pem)
+        .map_err(|e| format!("Failed to parse TLS identity (cert+key): {e}"))?;
+
+    let tls_acceptor = native_tls::TlsAcceptor::builder(identity)
+        .min_protocol_version(Some(native_tls::Protocol::Tlsv12))
+        .build()
+        .map_err(|e| format!("Failed to build TLS acceptor: {e}"))?;
+
+    Ok(tokio_native_tls::TlsAcceptor::from(tls_acceptor))
+}
+
+#[tokio::main]
+async fn main() {
+    env_logger::init();
+    let cli = Cli::parse();
+
+    // Validate TLS args
+    let tls_acceptor = match (&cli.tls_cert, &cli.tls_key) {
+        (Some(cert), Some(key)) => {
+            let acceptor = build_tls_acceptor(cert, key).expect("TLS setup failed");
+            log::info!("TLS enabled (cert: {cert}, key: {key})");
+            Some(Arc::new(acceptor))
+        }
+        (Some(_), None) | (None, Some(_)) => {
+            eprintln!("Error: --tls-cert and --tls-key must both be provided");
+            std::process::exit(1);
+        }
+        (None, None) => {
+            if !cli.insecure {
+                log::warn!("Running without TLS. Use --tls-cert/--tls-key for encrypted connections, or --insecure to suppress this warning.");
+            }
+            None
+        }
+    };
+
+    let addr = SocketAddr::from(([0, 0, 0, 0], cli.port));
+    let listener = TcpListener::bind(&addr).await.expect("Failed to bind");
+    let protocol = if tls_acceptor.is_some() { "wss" } else { "ws" };
+    log::info!("bterminal-relay listening on {protocol}://{addr}");
+
+    // Build sidecar config
+    let mut search_paths: Vec<std::path::PathBuf> = cli
+        .sidecar_path
+        .iter()
+        .map(std::path::PathBuf::from)
+        .collect();
+    // Default: look in current dir and next to binary
+    if let Ok(exe_dir) = std::env::current_exe().map(|p| p.parent().unwrap().to_path_buf()) {
+        search_paths.push(exe_dir.join("sidecar"));
+    }
+    search_paths.push(std::path::PathBuf::from("sidecar"));
+
+    let sidecar_config = SidecarConfig {
+        search_paths,
+        env_overrides: std::collections::HashMap::new(),
+        sandbox: Default::default(),
+    };
+    let token = Arc::new(cli.token);
+
+    // Rate limiting state for auth failures
+    let auth_failures: Arc<tokio::sync::Mutex<std::collections::HashMap<SocketAddr, (u32, std::time::Instant)>>> =
+        Arc::new(tokio::sync::Mutex::new(std::collections::HashMap::new()));
+
+    while let Ok((stream, peer)) = listener.accept().await {
+        let token = token.clone();
+        let sidecar_config = sidecar_config.clone();
+        let auth_failures = auth_failures.clone();
+        let tls = tls_acceptor.clone();
+
+        tokio::spawn(async move {
+            // Check rate limit
+            {
+                let mut failures = auth_failures.lock().await;
+                if let Some((count, last)) = failures.get(&peer) {
+                    if *count >= 10 && last.elapsed() < std::time::Duration::from_secs(300) {
+                        log::warn!("Rate limited: {peer}");
+                        return;
+                    }
+                    // Reset after cooldown
+                    if last.elapsed() >= std::time::Duration::from_secs(300) {
+                        failures.remove(&peer);
+                    }
+                }
+            }
+
+            if let Some(tls_acceptor) = tls {
+                // TLS path: wrap TCP stream with TLS, then upgrade to WebSocket
+                match tls_acceptor.accept(stream).await {
+                    Ok(tls_stream) => {
+                        if let Err(e) = handle_tls_connection(tls_stream, peer, &token, &sidecar_config, &auth_failures).await {
+                            log::error!("TLS connection error from {peer}: {e}");
+                        }
+                    }
+                    Err(e) => {
+                        log::error!("TLS handshake failed from {peer}: {e}");
+                    }
+                }
+            } else {
+                // Plain WebSocket path
+                if let Err(e) = handle_connection(stream, peer, &token, &sidecar_config, &auth_failures).await {
+                    log::error!("Connection error from {peer}: {e}");
+                }
+            }
+        });
+    }
+}
+
+async fn handle_connection(
+    stream: TcpStream,
+    peer: SocketAddr,
+    expected_token: &str,
+    sidecar_config: &SidecarConfig,
+    auth_failures: &tokio::sync::Mutex<std::collections::HashMap<SocketAddr, (u32, std::time::Instant)>>,
+) -> Result<(), String> {
+    let ws_stream = accept_ws_with_auth(stream, expected_token, peer, auth_failures).await?;
+    run_ws_session(ws_stream, peer, sidecar_config).await
+}
+
+async fn handle_tls_connection(
+    stream: tokio_native_tls::TlsStream<TcpStream>,
+    peer: SocketAddr,
+    expected_token: &str,
+    sidecar_config: &SidecarConfig,
+    auth_failures: &tokio::sync::Mutex<std::collections::HashMap<SocketAddr, (u32, std::time::Instant)>>,
+) -> Result<(), String> {
+    let ws_stream = accept_ws_with_auth(stream, expected_token, peer, auth_failures).await?;
+    run_ws_session(ws_stream, peer, sidecar_config).await
+}
+
+/// Accept a WebSocket connection with Bearer token auth validation.
+async fn accept_ws_with_auth<S>(
+    stream: S,
+    expected_token: &str,
+    peer: SocketAddr,
+    auth_failures: &tokio::sync::Mutex<std::collections::HashMap<SocketAddr, (u32, std::time::Instant)>>,
+) -> Result<tokio_tungstenite::WebSocketStream<S>, String>
+where
+    S: tokio::io::AsyncRead + tokio::io::AsyncWrite + Unpin,
+{
+    let expected = format!("Bearer {expected_token}");
+    tokio_tungstenite::accept_hdr_async(stream, |req: &http::Request<()>, response: http::Response<()>| {
+        let auth = req.headers().get("authorization").and_then(|v| v.to_str().ok());
+        match auth {
+            Some(value) if value == expected => Ok(response),
+            _ => {
+                Err(http::Response::builder()
+                    .status(http::StatusCode::UNAUTHORIZED)
+                    .body(Some("Invalid token".to_string()))
+                    .unwrap())
+            }
+        }
+    })
+    .await
+    .map_err(|e| {
+        let _ = auth_failures.try_lock().map(|mut f| {
+            let entry = f.entry(peer).or_insert((0, std::time::Instant::now()));
+            entry.0 += 1;
+            entry.1 = std::time::Instant::now();
+        });
+        format!("WebSocket handshake failed: {e}")
+    })
+}
+
+/// Run the WebSocket session (managers, event forwarding, command processing).
+async fn run_ws_session<S>(
+    ws_stream: tokio_tungstenite::WebSocketStream<S>,
+    peer: SocketAddr,
+    sidecar_config: &SidecarConfig,
+) -> Result<(), String>
+where
+    S: tokio::io::AsyncRead + tokio::io::AsyncWrite + Unpin + Send + 'static,
+{
+    log::info!("Client connected: {peer}");
+
+    // Set up event channel — shared between EventSink and command response sender
+    let (event_tx, mut event_rx) = mpsc::unbounded_channel::<RelayEvent>();
+    let sink_tx = event_tx.clone();
+    let sink: Arc<dyn EventSink> = Arc::new(WsEventSink { tx: event_tx });
+
+    // Create managers for this connection
+    let pty_manager = Arc::new(PtyManager::new(sink.clone()));
+    let sidecar_manager = Arc::new(SidecarManager::new(sink, sidecar_config.clone()));
+
+    // Start sidecar
+    if let Err(e) = sidecar_manager.start() {
+        log::warn!("Sidecar startup failed for {peer}: {e}");
+    }
+
+    let (mut ws_tx, mut ws_rx) = ws_stream.split();
+
+    // Send ready signal
+    let ready_event = RelayEvent {
+        type_: "ready".to_string(),
+        session_id: None,
+        payload: None,
+    };
+    let _ = ws_tx
+        .send(Message::Text(serde_json::to_string(&ready_event).unwrap()))
+        .await;
+
+    // Forward events to WebSocket
+    let event_writer = tokio::spawn(async move {
+        while let Some(event) = event_rx.recv().await {
+            if let Ok(json) = serde_json::to_string(&event) {
+                if ws_tx.send(Message::Text(json)).await.is_err() {
+                    break;
+                }
+            }
+        }
+    });
+
+    // Process incoming commands
+    let pty_mgr = pty_manager.clone();
+    let sidecar_mgr = sidecar_manager.clone();
+    let response_tx = sink_tx;
+    let command_reader = tokio::spawn(async move {
+        while let Some(msg) = ws_rx.next().await {
+            match msg {
+                Ok(Message::Text(text)) => {
+                    if let Ok(cmd) = serde_json::from_str::<RelayCommand>(&text) {
+                        handle_relay_command(&pty_mgr, &sidecar_mgr, &response_tx, cmd).await;
+                    }
+                }
+                Ok(Message::Close(_)) => break,
+                Err(e) => {
+                    log::error!("WebSocket read error from {peer}: {e}");
+                    break;
+                }
+                _ => {}
+            }
+        }
+    });
+
+    // Wait for either task to finish
+    tokio::select! {
+        _ = event_writer => {}
+        _ = command_reader => {}
+    }
+
+    // Cleanup
+    let _ = sidecar_manager.shutdown();
+    log::info!("Client disconnected: {peer}");
+
+    Ok(())
+}
+
+async fn handle_relay_command(
+    pty: &PtyManager,
+    sidecar: &SidecarManager,
+    response_tx: &mpsc::UnboundedSender<RelayEvent>,
+    cmd: RelayCommand,
+) {
+    match cmd.type_.as_str() {
+        "ping" => {
+            let _ = response_tx.send(RelayEvent {
+                type_: "pong".to_string(),
+                session_id: None,
+                payload: None,
+            });
+        }
+        "pty_create" => {
+            let options: PtyOptions = match serde_json::from_value(cmd.payload) {
+                Ok(opts) => opts,
+                Err(e) => {
+                    send_error(response_tx, &cmd.id, &format!("Invalid pty_create payload: {e}"));
+                    return;
+                }
+            };
+            match pty.spawn(options) {
+                Ok(pty_id) => {
+                    log::info!("Spawned remote PTY: {pty_id}");
+                    let _ = response_tx.send(RelayEvent {
+                        type_: "pty_created".to_string(),
+                        session_id: Some(pty_id),
+                        payload: Some(serde_json::json!({ "commandId": cmd.id })),
+                    });
+                }
+                Err(e) => send_error(response_tx, &cmd.id, &format!("Failed to spawn PTY: {e}")),
+            }
+        }
+        "pty_write" => {
+            if let (Some(id), Some(data)) = (
+                cmd.payload.get("id").and_then(|v| v.as_str()),
+                cmd.payload.get("data").and_then(|v| v.as_str()),
+            ) {
+                if let Err(e) = pty.write(id, data) {
+                    send_error(response_tx, &cmd.id, &format!("PTY write error: {e}"));
+                }
+            }
+        }
+        "pty_resize" => {
+            if let (Some(id), Some(cols), Some(rows)) = (
+                cmd.payload.get("id").and_then(|v| v.as_str()),
+                cmd.payload.get("cols").and_then(|v| v.as_u64()),
+                cmd.payload.get("rows").and_then(|v| v.as_u64()),
+            ) {
+                if let Err(e) = pty.resize(id, cols as u16, rows as u16) {
+                    send_error(response_tx, &cmd.id, &format!("PTY resize error: {e}"));
+                }
+            }
+        }
+        "pty_close" => {
+            if let Some(id) = cmd.payload.get("id").and_then(|v| v.as_str()) {
+                if let Err(e) = pty.kill(id) {
+                    send_error(response_tx, &cmd.id, &format!("PTY kill error: {e}"));
+                }
+            }
+        }
+        "agent_query" => {
+            let options: AgentQueryOptions = match serde_json::from_value(cmd.payload) {
+                Ok(opts) => opts,
+                Err(e) => {
+                    send_error(response_tx, &cmd.id, &format!("Invalid agent_query payload: {e}"));
+                    return;
+                }
+            };
+            if let Err(e) = sidecar.query(&options) {
+                send_error(response_tx, &cmd.id, &format!("Agent query error: {e}"));
+            }
+        }
+        "agent_stop" => {
+            if let Some(session_id) = cmd.payload.get("sessionId").and_then(|v| v.as_str()) {
+                if let Err(e) = sidecar.stop_session(session_id) {
+                    send_error(response_tx, &cmd.id, &format!("Agent stop error: {e}"));
+                }
+            }
+        }
+        "sidecar_restart" => {
+            if let Err(e) = sidecar.restart() {
+                send_error(response_tx, &cmd.id, &format!("Sidecar restart error: {e}"));
+            }
+        }
+        other => {
+            log::warn!("Unknown relay command: {other}");
+        }
+    }
+}
+
+fn send_error(tx: &mpsc::UnboundedSender<RelayEvent>, cmd_id: &str, message: &str) {
+    log::error!("{message}");
+    let _ = tx.send(RelayEvent {
+        type_: "error".to_string(),
+        session_id: None,
+        payload: Some(serde_json::json!({
+            "commandId": cmd_id,
+            "message": message,
+        })),
+    });
+}
diff --git a/v2/index.html b/v2/index.html
new file mode 100644
index 0000000..3a22257
--- /dev/null
+++ b/v2/index.html
@@ -0,0 +1,12 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>BTerminal</title>
+  </head>
+  <body>
+    <div id="app"></div>
+    <script type="module" src="/src/main.ts"></script>
+  </body>
+</html>
diff --git a/v2/package-lock.json b/v2/package-lock.json
new file mode 100644
index 0000000..c98a04e
--- /dev/null
+++ b/v2/package-lock.json
@@ -0,0 +1,9722 @@
+{
+  "name": "bterminal-v2",
+  "version": "0.1.0",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "bterminal-v2",
+      "version": "0.1.0",
+      "dependencies": {
+        "@anthropic-ai/claude-agent-sdk": "^0.2.70",
+        "@codemirror/lang-cpp": "^6.0.3",
+        "@codemirror/lang-css": "^6.3.1",
+        "@codemirror/lang-go": "^6.0.1",
+        "@codemirror/lang-html": "^6.4.11",
+        "@codemirror/lang-java": "^6.0.2",
+        "@codemirror/lang-javascript": "^6.2.5",
+        "@codemirror/lang-json": "^6.0.2",
+        "@codemirror/lang-markdown": "^6.5.0",
+        "@codemirror/lang-php": "^6.0.2",
+        "@codemirror/lang-python": "^6.2.1",
+        "@codemirror/lang-rust": "^6.0.2",
+        "@codemirror/lang-sql": "^6.10.0",
+        "@codemirror/lang-xml": "^6.1.0",
+        "@codemirror/lang-yaml": "^6.1.2",
+        "@tauri-apps/api": "^2.10.1",
+        "@tauri-apps/plugin-dialog": "^2.6.0",
+        "@tauri-apps/plugin-updater": "^2.10.0",
+        "@xterm/addon-canvas": "^0.7.0",
+        "@xterm/addon-fit": "^0.11.0",
+        "@xterm/xterm": "^6.0.0",
+        "codemirror": "^6.0.2",
+        "marked": "^17.0.4",
+        "pdfjs-dist": "^5.5.207",
+        "shiki": "^4.0.1"
+      },
+      "devDependencies": {
+        "@sveltejs/vite-plugin-svelte": "^6.2.1",
+        "@tsconfig/svelte": "^5.0.6",
+        "@types/node": "^24.10.1",
+        "@wdio/cli": "^9.24.0",
+        "@wdio/local-runner": "^9.24.0",
+        "@wdio/mocha-framework": "^9.24.0",
+        "@wdio/spec-reporter": "^9.24.0",
+        "svelte": "^5.45.2",
+        "svelte-check": "^4.3.4",
+        "typescript": "~5.9.3",
+        "vite": "^7.3.1",
+        "vitest": "^4.0.18"
+      }
+    },
+    "node_modules/@anthropic-ai/claude-agent-sdk": {
+      "version": "0.2.70",
+      "resolved": "https://registry.npmjs.org/@anthropic-ai/claude-agent-sdk/-/claude-agent-sdk-0.2.70.tgz",
+      "integrity": "sha512-ABaB37jWt7dZXfIDHebHv99jX9GIyqc0aSjcz9nxq79eauOpa+64Cah5hx/yzhsWz7m5GEtjbMIZCClTfnRRhg==",
+      "license": "SEE LICENSE IN README.md",
+      "engines": {
+        "node": ">=18.0.0"
+      },
+      "optionalDependencies": {
+        "@img/sharp-darwin-arm64": "^0.34.2",
+        "@img/sharp-darwin-x64": "^0.34.2",
+        "@img/sharp-linux-arm": "^0.34.2",
+        "@img/sharp-linux-arm64": "^0.34.2",
+        "@img/sharp-linux-x64": "^0.34.2",
+        "@img/sharp-linuxmusl-arm64": "^0.34.2",
+        "@img/sharp-linuxmusl-x64": "^0.34.2",
+        "@img/sharp-win32-arm64": "^0.34.2",
+        "@img/sharp-win32-x64": "^0.34.2"
+      },
+      "peerDependencies": {
+        "zod": "^4.0.0"
+      }
+    },
+    "node_modules/@babel/code-frame": {
+      "version": "7.29.0",
+      "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.29.0.tgz",
+      "integrity": "sha512-9NhCeYjq9+3uxgdtp20LSiJXJvN0FeCtNGpJxuMFZ1Kv3cWUNb6DOhJwUvcVCzKGR66cw4njwM6hrJLqgOwbcw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-validator-identifier": "^7.28.5",
+        "js-tokens": "^4.0.0",
+        "picocolors": "^1.1.1"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-validator-identifier": {
+      "version": "7.28.5",
+      "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.28.5.tgz",
+      "integrity": "sha512-qSs4ifwzKJSV39ucNjsvc6WVHs6b7S03sOh2OcHF9UHfVPqWWALUsNUVzhSBiItjRZoLHx7nIarVjqKVusUZ1Q==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@codemirror/autocomplete": {
+      "version": "6.20.1",
+      "resolved": "https://registry.npmjs.org/@codemirror/autocomplete/-/autocomplete-6.20.1.tgz",
+      "integrity": "sha512-1cvg3Vz1dSSToCNlJfRA2WSI4ht3K+WplO0UMOgmUYPivCyy2oueZY6Lx7M9wThm7SDUBViRmuT+OG/i8+ON9A==",
+      "license": "MIT",
+      "dependencies": {
+        "@codemirror/language": "^6.0.0",
+        "@codemirror/state": "^6.0.0",
+        "@codemirror/view": "^6.17.0",
+        "@lezer/common": "^1.0.0"
+      }
+    },
+    "node_modules/@codemirror/commands": {
+      "version": "6.10.2",
+      "resolved": "https://registry.npmjs.org/@codemirror/commands/-/commands-6.10.2.tgz",
+      "integrity": "sha512-vvX1fsih9HledO1c9zdotZYUZnE4xV0m6i3m25s5DIfXofuprk6cRcLUZvSk3CASUbwjQX21tOGbkY2BH8TpnQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@codemirror/language": "^6.0.0",
+        "@codemirror/state": "^6.4.0",
+        "@codemirror/view": "^6.27.0",
+        "@lezer/common": "^1.1.0"
+      }
+    },
+    "node_modules/@codemirror/lang-cpp": {
+      "version": "6.0.3",
+      "resolved": "https://registry.npmjs.org/@codemirror/lang-cpp/-/lang-cpp-6.0.3.tgz",
+      "integrity": "sha512-URM26M3vunFFn9/sm6rzqrBzDgfWuDixp85uTY49wKudToc2jTHUrKIGGKs+QWND+YLofNNZpxcNGRynFJfvgA==",
+      "license": "MIT",
+      "dependencies": {
+        "@codemirror/language": "^6.0.0",
+        "@lezer/cpp": "^1.0.0"
+      }
+    },
+    "node_modules/@codemirror/lang-css": {
+      "version": "6.3.1",
+      "resolved": "https://registry.npmjs.org/@codemirror/lang-css/-/lang-css-6.3.1.tgz",
+      "integrity": "sha512-kr5fwBGiGtmz6l0LSJIbno9QrifNMUusivHbnA1H6Dmqy4HZFte3UAICix1VuKo0lMPKQr2rqB+0BkKi/S3Ejg==",
+      "license": "MIT",
+      "dependencies": {
+        "@codemirror/autocomplete": "^6.0.0",
+        "@codemirror/language": "^6.0.0",
+        "@codemirror/state": "^6.0.0",
+        "@lezer/common": "^1.0.2",
+        "@lezer/css": "^1.1.7"
+      }
+    },
+    "node_modules/@codemirror/lang-go": {
+      "version": "6.0.1",
+      "resolved": "https://registry.npmjs.org/@codemirror/lang-go/-/lang-go-6.0.1.tgz",
+      "integrity": "sha512-7fNvbyNylvqCphW9HD6WFnRpcDjr+KXX/FgqXy5H5ZS0eC5edDljukm/yNgYkwTsgp2busdod50AOTIy6Jikfg==",
+      "license": "MIT",
+      "dependencies": {
+        "@codemirror/autocomplete": "^6.0.0",
+        "@codemirror/language": "^6.6.0",
+        "@codemirror/state": "^6.0.0",
+        "@lezer/common": "^1.0.0",
+        "@lezer/go": "^1.0.0"
+      }
+    },
+    "node_modules/@codemirror/lang-html": {
+      "version": "6.4.11",
+      "resolved": "https://registry.npmjs.org/@codemirror/lang-html/-/lang-html-6.4.11.tgz",
+      "integrity": "sha512-9NsXp7Nwp891pQchI7gPdTwBuSuT3K65NGTHWHNJ55HjYcHLllr0rbIZNdOzas9ztc1EUVBlHou85FFZS4BNnw==",
+      "license": "MIT",
+      "dependencies": {
+        "@codemirror/autocomplete": "^6.0.0",
+        "@codemirror/lang-css": "^6.0.0",
+        "@codemirror/lang-javascript": "^6.0.0",
+        "@codemirror/language": "^6.4.0",
+        "@codemirror/state": "^6.0.0",
+        "@codemirror/view": "^6.17.0",
+        "@lezer/common": "^1.0.0",
+        "@lezer/css": "^1.1.0",
+        "@lezer/html": "^1.3.12"
+      }
+    },
+    "node_modules/@codemirror/lang-java": {
+      "version": "6.0.2",
+      "resolved": "https://registry.npmjs.org/@codemirror/lang-java/-/lang-java-6.0.2.tgz",
+      "integrity": "sha512-m5Nt1mQ/cznJY7tMfQTJchmrjdjQ71IDs+55d1GAa8DGaB8JXWsVCkVT284C3RTASaY43YknrK2X3hPO/J3MOQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@codemirror/language": "^6.0.0",
+        "@lezer/java": "^1.0.0"
+      }
+    },
+    "node_modules/@codemirror/lang-javascript": {
+      "version": "6.2.5",
+      "resolved": "https://registry.npmjs.org/@codemirror/lang-javascript/-/lang-javascript-6.2.5.tgz",
+      "integrity": "sha512-zD4e5mS+50htS7F+TYjBPsiIFGanfVqg4HyUz6WNFikgOPf2BgKlx+TQedI1w6n/IqRBVBbBWmGFdLB/7uxO4A==",
+      "license": "MIT",
+      "dependencies": {
+        "@codemirror/autocomplete": "^6.0.0",
+        "@codemirror/language": "^6.6.0",
+        "@codemirror/lint": "^6.0.0",
+        "@codemirror/state": "^6.0.0",
+        "@codemirror/view": "^6.17.0",
+        "@lezer/common": "^1.0.0",
+        "@lezer/javascript": "^1.0.0"
+      }
+    },
+    "node_modules/@codemirror/lang-json": {
+      "version": "6.0.2",
+      "resolved": "https://registry.npmjs.org/@codemirror/lang-json/-/lang-json-6.0.2.tgz",
+      "integrity": "sha512-x2OtO+AvwEHrEwR0FyyPtfDUiloG3rnVTSZV1W8UteaLL8/MajQd8DpvUb2YVzC+/T18aSDv0H9mu+xw0EStoQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@codemirror/language": "^6.0.0",
+        "@lezer/json": "^1.0.0"
+      }
+    },
+    "node_modules/@codemirror/lang-markdown": {
+      "version": "6.5.0",
+      "resolved": "https://registry.npmjs.org/@codemirror/lang-markdown/-/lang-markdown-6.5.0.tgz",
+      "integrity": "sha512-0K40bZ35jpHya6FriukbgaleaqzBLZfOh7HuzqbMxBXkbYMJDxfF39c23xOgxFezR+3G+tR2/Mup+Xk865OMvw==",
+      "license": "MIT",
+      "dependencies": {
+        "@codemirror/autocomplete": "^6.7.1",
+        "@codemirror/lang-html": "^6.0.0",
+        "@codemirror/language": "^6.3.0",
+        "@codemirror/state": "^6.0.0",
+        "@codemirror/view": "^6.0.0",
+        "@lezer/common": "^1.2.1",
+        "@lezer/markdown": "^1.0.0"
+      }
+    },
+    "node_modules/@codemirror/lang-php": {
+      "version": "6.0.2",
+      "resolved": "https://registry.npmjs.org/@codemirror/lang-php/-/lang-php-6.0.2.tgz",
+      "integrity": "sha512-ZKy2v1n8Fc8oEXj0Th0PUMXzQJ0AIR6TaZU+PbDHExFwdu+guzOA4jmCHS1Nz4vbFezwD7LyBdDnddSJeScMCA==",
+      "license": "MIT",
+      "dependencies": {
+        "@codemirror/lang-html": "^6.0.0",
+        "@codemirror/language": "^6.0.0",
+        "@codemirror/state": "^6.0.0",
+        "@lezer/common": "^1.0.0",
+        "@lezer/php": "^1.0.0"
+      }
+    },
+    "node_modules/@codemirror/lang-python": {
+      "version": "6.2.1",
+      "resolved": "https://registry.npmjs.org/@codemirror/lang-python/-/lang-python-6.2.1.tgz",
+      "integrity": "sha512-IRjC8RUBhn9mGR9ywecNhB51yePWCGgvHfY1lWN/Mrp3cKuHr0isDKia+9HnvhiWNnMpbGhWrkhuWOc09exRyw==",
+      "license": "MIT",
+      "dependencies": {
+        "@codemirror/autocomplete": "^6.3.2",
+        "@codemirror/language": "^6.8.0",
+        "@codemirror/state": "^6.0.0",
+        "@lezer/common": "^1.2.1",
+        "@lezer/python": "^1.1.4"
+      }
+    },
+    "node_modules/@codemirror/lang-rust": {
+      "version": "6.0.2",
+      "resolved": "https://registry.npmjs.org/@codemirror/lang-rust/-/lang-rust-6.0.2.tgz",
+      "integrity": "sha512-EZaGjCUegtiU7kSMvOfEZpaCReowEf3yNidYu7+vfuGTm9ow4mthAparY5hisJqOHmJowVH3Upu+eJlUji6qqA==",
+      "license": "MIT",
+      "dependencies": {
+        "@codemirror/language": "^6.0.0",
+        "@lezer/rust": "^1.0.0"
+      }
+    },
+    "node_modules/@codemirror/lang-sql": {
+      "version": "6.10.0",
+      "resolved": "https://registry.npmjs.org/@codemirror/lang-sql/-/lang-sql-6.10.0.tgz",
+      "integrity": "sha512-6ayPkEd/yRw0XKBx5uAiToSgGECo/GY2NoJIHXIIQh1EVwLuKoU8BP/qK0qH5NLXAbtJRLuT73hx7P9X34iO4w==",
+      "license": "MIT",
+      "dependencies": {
+        "@codemirror/autocomplete": "^6.0.0",
+        "@codemirror/language": "^6.0.0",
+        "@codemirror/state": "^6.0.0",
+        "@lezer/common": "^1.2.0",
+        "@lezer/highlight": "^1.0.0",
+        "@lezer/lr": "^1.0.0"
+      }
+    },
+    "node_modules/@codemirror/lang-xml": {
+      "version": "6.1.0",
+      "resolved": "https://registry.npmjs.org/@codemirror/lang-xml/-/lang-xml-6.1.0.tgz",
+      "integrity": "sha512-3z0blhicHLfwi2UgkZYRPioSgVTo9PV5GP5ducFH6FaHy0IAJRg+ixj5gTR1gnT/glAIC8xv4w2VL1LoZfs+Jg==",
+      "license": "MIT",
+      "dependencies": {
+        "@codemirror/autocomplete": "^6.0.0",
+        "@codemirror/language": "^6.4.0",
+        "@codemirror/state": "^6.0.0",
+        "@codemirror/view": "^6.0.0",
+        "@lezer/common": "^1.0.0",
+        "@lezer/xml": "^1.0.0"
+      }
+    },
+    "node_modules/@codemirror/lang-yaml": {
+      "version": "6.1.2",
+      "resolved": "https://registry.npmjs.org/@codemirror/lang-yaml/-/lang-yaml-6.1.2.tgz",
+      "integrity": "sha512-dxrfG8w5Ce/QbT7YID7mWZFKhdhsaTNOYjOkSIMt1qmC4VQnXSDSYVHHHn8k6kJUfIhtLo8t1JJgltlxWdsITw==",
+      "license": "MIT",
+      "dependencies": {
+        "@codemirror/autocomplete": "^6.0.0",
+        "@codemirror/language": "^6.0.0",
+        "@codemirror/state": "^6.0.0",
+        "@lezer/common": "^1.2.0",
+        "@lezer/highlight": "^1.2.0",
+        "@lezer/lr": "^1.0.0",
+        "@lezer/yaml": "^1.0.0"
+      }
+    },
+    "node_modules/@codemirror/language": {
+      "version": "6.12.2",
+      "resolved": "https://registry.npmjs.org/@codemirror/language/-/language-6.12.2.tgz",
+      "integrity": "sha512-jEPmz2nGGDxhRTg3lTpzmIyGKxz3Gp3SJES4b0nAuE5SWQoKdT5GoQ69cwMmFd+wvFUhYirtDTr0/DRHpQAyWg==",
+      "license": "MIT",
+      "dependencies": {
+        "@codemirror/state": "^6.0.0",
+        "@codemirror/view": "^6.23.0",
+        "@lezer/common": "^1.5.0",
+        "@lezer/highlight": "^1.0.0",
+        "@lezer/lr": "^1.0.0",
+        "style-mod": "^4.0.0"
+      }
+    },
+    "node_modules/@codemirror/lint": {
+      "version": "6.9.5",
+      "resolved": "https://registry.npmjs.org/@codemirror/lint/-/lint-6.9.5.tgz",
+      "integrity": "sha512-GElsbU9G7QT9xXhpUg1zWGmftA/7jamh+7+ydKRuT0ORpWS3wOSP0yT1FOlIZa7mIJjpVPipErsyvVqB9cfTFA==",
+      "license": "MIT",
+      "dependencies": {
+        "@codemirror/state": "^6.0.0",
+        "@codemirror/view": "^6.35.0",
+        "crelt": "^1.0.5"
+      }
+    },
+    "node_modules/@codemirror/search": {
+      "version": "6.6.0",
+      "resolved": "https://registry.npmjs.org/@codemirror/search/-/search-6.6.0.tgz",
+      "integrity": "sha512-koFuNXcDvyyotWcgOnZGmY7LZqEOXZaaxD/j6n18TCLx2/9HieZJ5H6hs1g8FiRxBD0DNfs0nXn17g872RmYdw==",
+      "license": "MIT",
+      "dependencies": {
+        "@codemirror/state": "^6.0.0",
+        "@codemirror/view": "^6.37.0",
+        "crelt": "^1.0.5"
+      }
+    },
+    "node_modules/@codemirror/state": {
+      "version": "6.5.4",
+      "resolved": "https://registry.npmjs.org/@codemirror/state/-/state-6.5.4.tgz",
+      "integrity": "sha512-8y7xqG/hpB53l25CIoit9/ngxdfoG+fx+V3SHBrinnhOtLvKHRyAJJuHzkWrR4YXXLX8eXBsejgAAxHUOdW1yw==",
+      "license": "MIT",
+      "dependencies": {
+        "@marijn/find-cluster-break": "^1.0.0"
+      }
+    },
+    "node_modules/@codemirror/view": {
+      "version": "6.39.16",
+      "resolved": "https://registry.npmjs.org/@codemirror/view/-/view-6.39.16.tgz",
+      "integrity": "sha512-m6S22fFpKtOWhq8HuhzsI1WzUP/hB9THbDj0Tl5KX4gbO6Y91hwBl7Yky33NdvB6IffuRFiBxf1R8kJMyXmA4Q==",
+      "license": "MIT",
+      "dependencies": {
+        "@codemirror/state": "^6.5.0",
+        "crelt": "^1.0.6",
+        "style-mod": "^4.1.0",
+        "w3c-keyname": "^2.2.4"
+      }
+    },
+    "node_modules/@esbuild/aix-ppc64": {
+      "version": "0.27.3",
+      "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.27.3.tgz",
+      "integrity": "sha512-9fJMTNFTWZMh5qwrBItuziu834eOCUcEqymSH7pY+zoMVEZg3gcPuBNxH1EvfVYe9h0x/Ptw8KBzv7qxb7l8dg==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "aix"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/android-arm": {
+      "version": "0.27.3",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.27.3.tgz",
+      "integrity": "sha512-i5D1hPY7GIQmXlXhs2w8AWHhenb00+GxjxRncS2ZM7YNVGNfaMxgzSGuO8o8SJzRc/oZwU2bcScvVERk03QhzA==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/android-arm64": {
+      "version": "0.27.3",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.27.3.tgz",
+      "integrity": "sha512-YdghPYUmj/FX2SYKJ0OZxf+iaKgMsKHVPF1MAq/P8WirnSpCStzKJFjOjzsW0QQ7oIAiccHdcqjbHmJxRb/dmg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/android-x64": {
+      "version": "0.27.3",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.27.3.tgz",
+      "integrity": "sha512-IN/0BNTkHtk8lkOM8JWAYFg4ORxBkZQf9zXiEOfERX/CzxW3Vg1ewAhU7QSWQpVIzTW+b8Xy+lGzdYXV6UZObQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/darwin-arm64": {
+      "version": "0.27.3",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.27.3.tgz",
+      "integrity": "sha512-Re491k7ByTVRy0t3EKWajdLIr0gz2kKKfzafkth4Q8A5n1xTHrkqZgLLjFEHVD+AXdUGgQMq+Godfq45mGpCKg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/darwin-x64": {
+      "version": "0.27.3",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.27.3.tgz",
+      "integrity": "sha512-vHk/hA7/1AckjGzRqi6wbo+jaShzRowYip6rt6q7VYEDX4LEy1pZfDpdxCBnGtl+A5zq8iXDcyuxwtv3hNtHFg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/freebsd-arm64": {
+      "version": "0.27.3",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.27.3.tgz",
+      "integrity": "sha512-ipTYM2fjt3kQAYOvo6vcxJx3nBYAzPjgTCk7QEgZG8AUO3ydUhvelmhrbOheMnGOlaSFUoHXB6un+A7q4ygY9w==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/freebsd-x64": {
+      "version": "0.27.3",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.27.3.tgz",
+      "integrity": "sha512-dDk0X87T7mI6U3K9VjWtHOXqwAMJBNN2r7bejDsc+j03SEjtD9HrOl8gVFByeM0aJksoUuUVU9TBaZa2rgj0oA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-arm": {
+      "version": "0.27.3",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.27.3.tgz",
+      "integrity": "sha512-s6nPv2QkSupJwLYyfS+gwdirm0ukyTFNl3KTgZEAiJDd+iHZcbTPPcWCcRYH+WlNbwChgH2QkE9NSlNrMT8Gfw==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-arm64": {
+      "version": "0.27.3",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.27.3.tgz",
+      "integrity": "sha512-sZOuFz/xWnZ4KH3YfFrKCf1WyPZHakVzTiqji3WDc0BCl2kBwiJLCXpzLzUBLgmp4veFZdvN5ChW4Eq/8Fc2Fg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-ia32": {
+      "version": "0.27.3",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.27.3.tgz",
+      "integrity": "sha512-yGlQYjdxtLdh0a3jHjuwOrxQjOZYD/C9PfdbgJJF3TIZWnm/tMd/RcNiLngiu4iwcBAOezdnSLAwQDPqTmtTYg==",
+      "cpu": [
+        "ia32"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-loong64": {
+      "version": "0.27.3",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.27.3.tgz",
+      "integrity": "sha512-WO60Sn8ly3gtzhyjATDgieJNet/KqsDlX5nRC5Y3oTFcS1l0KWba+SEa9Ja1GfDqSF1z6hif/SkpQJbL63cgOA==",
+      "cpu": [
+        "loong64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-mips64el": {
+      "version": "0.27.3",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.27.3.tgz",
+      "integrity": "sha512-APsymYA6sGcZ4pD6k+UxbDjOFSvPWyZhjaiPyl/f79xKxwTnrn5QUnXR5prvetuaSMsb4jgeHewIDCIWljrSxw==",
+      "cpu": [
+        "mips64el"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-ppc64": {
+      "version": "0.27.3",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.27.3.tgz",
+      "integrity": "sha512-eizBnTeBefojtDb9nSh4vvVQ3V9Qf9Df01PfawPcRzJH4gFSgrObw+LveUyDoKU3kxi5+9RJTCWlj4FjYXVPEA==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-riscv64": {
+      "version": "0.27.3",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.27.3.tgz",
+      "integrity": "sha512-3Emwh0r5wmfm3ssTWRQSyVhbOHvqegUDRd0WhmXKX2mkHJe1SFCMJhagUleMq+Uci34wLSipf8Lagt4LlpRFWQ==",
+      "cpu": [
+        "riscv64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-s390x": {
+      "version": "0.27.3",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.27.3.tgz",
+      "integrity": "sha512-pBHUx9LzXWBc7MFIEEL0yD/ZVtNgLytvx60gES28GcWMqil8ElCYR4kvbV2BDqsHOvVDRrOxGySBM9Fcv744hw==",
+      "cpu": [
+        "s390x"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-x64": {
+      "version": "0.27.3",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.27.3.tgz",
+      "integrity": "sha512-Czi8yzXUWIQYAtL/2y6vogER8pvcsOsk5cpwL4Gk5nJqH5UZiVByIY8Eorm5R13gq+DQKYg0+JyQoytLQas4dA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/netbsd-arm64": {
+      "version": "0.27.3",
+      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-arm64/-/netbsd-arm64-0.27.3.tgz",
+      "integrity": "sha512-sDpk0RgmTCR/5HguIZa9n9u+HVKf40fbEUt+iTzSnCaGvY9kFP0YKBWZtJaraonFnqef5SlJ8/TiPAxzyS+UoA==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "netbsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/netbsd-x64": {
+      "version": "0.27.3",
+      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.27.3.tgz",
+      "integrity": "sha512-P14lFKJl/DdaE00LItAukUdZO5iqNH7+PjoBm+fLQjtxfcfFE20Xf5CrLsmZdq5LFFZzb5JMZ9grUwvtVYzjiA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "netbsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/openbsd-arm64": {
+      "version": "0.27.3",
+      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-arm64/-/openbsd-arm64-0.27.3.tgz",
+      "integrity": "sha512-AIcMP77AvirGbRl/UZFTq5hjXK+2wC7qFRGoHSDrZ5v5b8DK/GYpXW3CPRL53NkvDqb9D+alBiC/dV0Fb7eJcw==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openbsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/openbsd-x64": {
+      "version": "0.27.3",
+      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.27.3.tgz",
+      "integrity": "sha512-DnW2sRrBzA+YnE70LKqnM3P+z8vehfJWHXECbwBmH/CU51z6FiqTQTHFenPlHmo3a8UgpLyH3PT+87OViOh1AQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openbsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/openharmony-arm64": {
+      "version": "0.27.3",
+      "resolved": "https://registry.npmjs.org/@esbuild/openharmony-arm64/-/openharmony-arm64-0.27.3.tgz",
+      "integrity": "sha512-NinAEgr/etERPTsZJ7aEZQvvg/A6IsZG/LgZy+81wON2huV7SrK3e63dU0XhyZP4RKGyTm7aOgmQk0bGp0fy2g==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openharmony"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/sunos-x64": {
+      "version": "0.27.3",
+      "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.27.3.tgz",
+      "integrity": "sha512-PanZ+nEz+eWoBJ8/f8HKxTTD172SKwdXebZ0ndd953gt1HRBbhMsaNqjTyYLGLPdoWHy4zLU7bDVJztF5f3BHA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "sunos"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/win32-arm64": {
+      "version": "0.27.3",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.27.3.tgz",
+      "integrity": "sha512-B2t59lWWYrbRDw/tjiWOuzSsFh1Y/E95ofKz7rIVYSQkUYBjfSgf6oeYPNWHToFRr2zx52JKApIcAS/D5TUBnA==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/win32-ia32": {
+      "version": "0.27.3",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.27.3.tgz",
+      "integrity": "sha512-QLKSFeXNS8+tHW7tZpMtjlNb7HKau0QDpwm49u0vUp9y1WOF+PEzkU84y9GqYaAVW8aH8f3GcBck26jh54cX4Q==",
+      "cpu": [
+        "ia32"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/win32-x64": {
+      "version": "0.27.3",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.27.3.tgz",
+      "integrity": "sha512-4uJGhsxuptu3OcpVAzli+/gWusVGwZZHTlS63hh++ehExkVT8SgiEf7/uC/PclrPPkLhZqGgCTjd0VWLo6xMqA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@img/sharp-darwin-arm64": {
+      "version": "0.34.5",
+      "resolved": "https://registry.npmjs.org/@img/sharp-darwin-arm64/-/sharp-darwin-arm64-0.34.5.tgz",
+      "integrity": "sha512-imtQ3WMJXbMY4fxb/Ndp6HBTNVtWCUI0WdobyheGf5+ad6xX8VIDO8u2xE4qc/fr08CKG/7dDseFtn6M6g/r3w==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "Apache-2.0",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": "^18.17.0 || ^20.3.0 || >=21.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      },
+      "optionalDependencies": {
+        "@img/sharp-libvips-darwin-arm64": "1.2.4"
+      }
+    },
+    "node_modules/@img/sharp-darwin-x64": {
+      "version": "0.34.5",
+      "resolved": "https://registry.npmjs.org/@img/sharp-darwin-x64/-/sharp-darwin-x64-0.34.5.tgz",
+      "integrity": "sha512-YNEFAF/4KQ/PeW0N+r+aVVsoIY0/qxxikF2SWdp+NRkmMB7y9LBZAVqQ4yhGCm/H3H270OSykqmQMKLBhBJDEw==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "Apache-2.0",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": "^18.17.0 || ^20.3.0 || >=21.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      },
+      "optionalDependencies": {
+        "@img/sharp-libvips-darwin-x64": "1.2.4"
+      }
+    },
+    "node_modules/@img/sharp-libvips-darwin-arm64": {
+      "version": "1.2.4",
+      "resolved": "https://registry.npmjs.org/@img/sharp-libvips-darwin-arm64/-/sharp-libvips-darwin-arm64-1.2.4.tgz",
+      "integrity": "sha512-zqjjo7RatFfFoP0MkQ51jfuFZBnVE2pRiaydKJ1G/rHZvnsrHAOcQALIi9sA5co5xenQdTugCvtb1cuf78Vf4g==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "LGPL-3.0-or-later",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      }
+    },
+    "node_modules/@img/sharp-libvips-darwin-x64": {
+      "version": "1.2.4",
+      "resolved": "https://registry.npmjs.org/@img/sharp-libvips-darwin-x64/-/sharp-libvips-darwin-x64-1.2.4.tgz",
+      "integrity": "sha512-1IOd5xfVhlGwX+zXv2N93k0yMONvUlANylbJw1eTah8K/Jtpi15KC+WSiaX/nBmbm2HxRM1gZ0nSdjSsrZbGKg==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "LGPL-3.0-or-later",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      }
+    },
+    "node_modules/@img/sharp-libvips-linux-arm": {
+      "version": "1.2.4",
+      "resolved": "https://registry.npmjs.org/@img/sharp-libvips-linux-arm/-/sharp-libvips-linux-arm-1.2.4.tgz",
+      "integrity": "sha512-bFI7xcKFELdiNCVov8e44Ia4u2byA+l3XtsAj+Q8tfCwO6BQ8iDojYdvoPMqsKDkuoOo+X6HZA0s0q11ANMQ8A==",
+      "cpu": [
+        "arm"
+      ],
+      "license": "LGPL-3.0-or-later",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      }
+    },
+    "node_modules/@img/sharp-libvips-linux-arm64": {
+      "version": "1.2.4",
+      "resolved": "https://registry.npmjs.org/@img/sharp-libvips-linux-arm64/-/sharp-libvips-linux-arm64-1.2.4.tgz",
+      "integrity": "sha512-excjX8DfsIcJ10x1Kzr4RcWe1edC9PquDRRPx3YVCvQv+U5p7Yin2s32ftzikXojb1PIFc/9Mt28/y+iRklkrw==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "LGPL-3.0-or-later",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      }
+    },
+    "node_modules/@img/sharp-libvips-linux-x64": {
+      "version": "1.2.4",
+      "resolved": "https://registry.npmjs.org/@img/sharp-libvips-linux-x64/-/sharp-libvips-linux-x64-1.2.4.tgz",
+      "integrity": "sha512-tJxiiLsmHc9Ax1bz3oaOYBURTXGIRDODBqhveVHonrHJ9/+k89qbLl0bcJns+e4t4rvaNBxaEZsFtSfAdquPrw==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "LGPL-3.0-or-later",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      }
+    },
+    "node_modules/@img/sharp-libvips-linuxmusl-arm64": {
+      "version": "1.2.4",
+      "resolved": "https://registry.npmjs.org/@img/sharp-libvips-linuxmusl-arm64/-/sharp-libvips-linuxmusl-arm64-1.2.4.tgz",
+      "integrity": "sha512-FVQHuwx1IIuNow9QAbYUzJ+En8KcVm9Lk5+uGUQJHaZmMECZmOlix9HnH7n1TRkXMS0pGxIJokIVB9SuqZGGXw==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "LGPL-3.0-or-later",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      }
+    },
+    "node_modules/@img/sharp-libvips-linuxmusl-x64": {
+      "version": "1.2.4",
+      "resolved": "https://registry.npmjs.org/@img/sharp-libvips-linuxmusl-x64/-/sharp-libvips-linuxmusl-x64-1.2.4.tgz",
+      "integrity": "sha512-+LpyBk7L44ZIXwz/VYfglaX/okxezESc6UxDSoyo2Ks6Jxc4Y7sGjpgU9s4PMgqgjj1gZCylTieNamqA1MF7Dg==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "LGPL-3.0-or-later",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      }
+    },
+    "node_modules/@img/sharp-linux-arm": {
+      "version": "0.34.5",
+      "resolved": "https://registry.npmjs.org/@img/sharp-linux-arm/-/sharp-linux-arm-0.34.5.tgz",
+      "integrity": "sha512-9dLqsvwtg1uuXBGZKsxem9595+ujv0sJ6Vi8wcTANSFpwV/GONat5eCkzQo/1O6zRIkh0m/8+5BjrRr7jDUSZw==",
+      "cpu": [
+        "arm"
+      ],
+      "license": "Apache-2.0",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": "^18.17.0 || ^20.3.0 || >=21.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      },
+      "optionalDependencies": {
+        "@img/sharp-libvips-linux-arm": "1.2.4"
+      }
+    },
+    "node_modules/@img/sharp-linux-arm64": {
+      "version": "0.34.5",
+      "resolved": "https://registry.npmjs.org/@img/sharp-linux-arm64/-/sharp-linux-arm64-0.34.5.tgz",
+      "integrity": "sha512-bKQzaJRY/bkPOXyKx5EVup7qkaojECG6NLYswgktOZjaXecSAeCWiZwwiFf3/Y+O1HrauiE3FVsGxFg8c24rZg==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "Apache-2.0",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": "^18.17.0 || ^20.3.0 || >=21.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      },
+      "optionalDependencies": {
+        "@img/sharp-libvips-linux-arm64": "1.2.4"
+      }
+    },
+    "node_modules/@img/sharp-linux-x64": {
+      "version": "0.34.5",
+      "resolved": "https://registry.npmjs.org/@img/sharp-linux-x64/-/sharp-linux-x64-0.34.5.tgz",
+      "integrity": "sha512-MEzd8HPKxVxVenwAa+JRPwEC7QFjoPWuS5NZnBt6B3pu7EG2Ge0id1oLHZpPJdn3OQK+BQDiw9zStiHBTJQQQQ==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "Apache-2.0",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": "^18.17.0 || ^20.3.0 || >=21.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      },
+      "optionalDependencies": {
+        "@img/sharp-libvips-linux-x64": "1.2.4"
+      }
+    },
+    "node_modules/@img/sharp-linuxmusl-arm64": {
+      "version": "0.34.5",
+      "resolved": "https://registry.npmjs.org/@img/sharp-linuxmusl-arm64/-/sharp-linuxmusl-arm64-0.34.5.tgz",
+      "integrity": "sha512-fprJR6GtRsMt6Kyfq44IsChVZeGN97gTD331weR1ex1c1rypDEABN6Tm2xa1wE6lYb5DdEnk03NZPqA7Id21yg==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "Apache-2.0",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": "^18.17.0 || ^20.3.0 || >=21.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      },
+      "optionalDependencies": {
+        "@img/sharp-libvips-linuxmusl-arm64": "1.2.4"
+      }
+    },
+    "node_modules/@img/sharp-linuxmusl-x64": {
+      "version": "0.34.5",
+      "resolved": "https://registry.npmjs.org/@img/sharp-linuxmusl-x64/-/sharp-linuxmusl-x64-0.34.5.tgz",
+      "integrity": "sha512-Jg8wNT1MUzIvhBFxViqrEhWDGzqymo3sV7z7ZsaWbZNDLXRJZoRGrjulp60YYtV4wfY8VIKcWidjojlLcWrd8Q==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "Apache-2.0",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": "^18.17.0 || ^20.3.0 || >=21.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      },
+      "optionalDependencies": {
+        "@img/sharp-libvips-linuxmusl-x64": "1.2.4"
+      }
+    },
+    "node_modules/@img/sharp-win32-arm64": {
+      "version": "0.34.5",
+      "resolved": "https://registry.npmjs.org/@img/sharp-win32-arm64/-/sharp-win32-arm64-0.34.5.tgz",
+      "integrity": "sha512-WQ3AgWCWYSb2yt+IG8mnC6Jdk9Whs7O0gxphblsLvdhSpSTtmu69ZG1Gkb6NuvxsNACwiPV6cNSZNzt0KPsw7g==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "Apache-2.0 AND LGPL-3.0-or-later",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": "^18.17.0 || ^20.3.0 || >=21.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      }
+    },
+    "node_modules/@img/sharp-win32-x64": {
+      "version": "0.34.5",
+      "resolved": "https://registry.npmjs.org/@img/sharp-win32-x64/-/sharp-win32-x64-0.34.5.tgz",
+      "integrity": "sha512-+29YMsqY2/9eFEiW93eqWnuLcWcufowXewwSNIT6UwZdUUCrM3oFjMWH/Z6/TMmb4hlFenmfAVbpWeup2jryCw==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "Apache-2.0 AND LGPL-3.0-or-later",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": "^18.17.0 || ^20.3.0 || >=21.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      }
+    },
+    "node_modules/@inquirer/ansi": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/@inquirer/ansi/-/ansi-1.0.2.tgz",
+      "integrity": "sha512-S8qNSZiYzFd0wAcyG5AXCvUHC5Sr7xpZ9wZ2py9XR88jUz8wooStVx5M6dRzczbBWjic9NP7+rY0Xi7qqK/aMQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@inquirer/checkbox": {
+      "version": "4.3.2",
+      "resolved": "https://registry.npmjs.org/@inquirer/checkbox/-/checkbox-4.3.2.tgz",
+      "integrity": "sha512-VXukHf0RR1doGe6Sm4F0Em7SWYLTHSsbGfJdS9Ja2bX5/D5uwVOEjr07cncLROdBvmnvCATYEWlHqYmXv2IlQA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@inquirer/ansi": "^1.0.2",
+        "@inquirer/core": "^10.3.2",
+        "@inquirer/figures": "^1.0.15",
+        "@inquirer/type": "^3.0.10",
+        "yoctocolors-cjs": "^2.1.3"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "peerDependencies": {
+        "@types/node": ">=18"
+      },
+      "peerDependenciesMeta": {
+        "@types/node": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@inquirer/confirm": {
+      "version": "5.1.21",
+      "resolved": "https://registry.npmjs.org/@inquirer/confirm/-/confirm-5.1.21.tgz",
+      "integrity": "sha512-KR8edRkIsUayMXV+o3Gv+q4jlhENF9nMYUZs9PA2HzrXeHI8M5uDag70U7RJn9yyiMZSbtF5/UexBtAVtZGSbQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@inquirer/core": "^10.3.2",
+        "@inquirer/type": "^3.0.10"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "peerDependencies": {
+        "@types/node": ">=18"
+      },
+      "peerDependenciesMeta": {
+        "@types/node": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@inquirer/core": {
+      "version": "10.3.2",
+      "resolved": "https://registry.npmjs.org/@inquirer/core/-/core-10.3.2.tgz",
+      "integrity": "sha512-43RTuEbfP8MbKzedNqBrlhhNKVwoK//vUFNW3Q3vZ88BLcrs4kYpGg+B2mm5p2K/HfygoCxuKwJJiv8PbGmE0A==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@inquirer/ansi": "^1.0.2",
+        "@inquirer/figures": "^1.0.15",
+        "@inquirer/type": "^3.0.10",
+        "cli-width": "^4.1.0",
+        "mute-stream": "^2.0.0",
+        "signal-exit": "^4.1.0",
+        "wrap-ansi": "^6.2.0",
+        "yoctocolors-cjs": "^2.1.3"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "peerDependencies": {
+        "@types/node": ">=18"
+      },
+      "peerDependenciesMeta": {
+        "@types/node": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@inquirer/editor": {
+      "version": "4.2.23",
+      "resolved": "https://registry.npmjs.org/@inquirer/editor/-/editor-4.2.23.tgz",
+      "integrity": "sha512-aLSROkEwirotxZ1pBaP8tugXRFCxW94gwrQLxXfrZsKkfjOYC1aRvAZuhpJOb5cu4IBTJdsCigUlf2iCOu4ZDQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@inquirer/core": "^10.3.2",
+        "@inquirer/external-editor": "^1.0.3",
+        "@inquirer/type": "^3.0.10"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "peerDependencies": {
+        "@types/node": ">=18"
+      },
+      "peerDependenciesMeta": {
+        "@types/node": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@inquirer/expand": {
+      "version": "4.0.23",
+      "resolved": "https://registry.npmjs.org/@inquirer/expand/-/expand-4.0.23.tgz",
+      "integrity": "sha512-nRzdOyFYnpeYTTR2qFwEVmIWypzdAx/sIkCMeTNTcflFOovfqUk+HcFhQQVBftAh9gmGrpFj6QcGEqrDMDOiew==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@inquirer/core": "^10.3.2",
+        "@inquirer/type": "^3.0.10",
+        "yoctocolors-cjs": "^2.1.3"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "peerDependencies": {
+        "@types/node": ">=18"
+      },
+      "peerDependenciesMeta": {
+        "@types/node": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@inquirer/external-editor": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/@inquirer/external-editor/-/external-editor-1.0.3.tgz",
+      "integrity": "sha512-RWbSrDiYmO4LbejWY7ttpxczuwQyZLBUyygsA9Nsv95hpzUWwnNTVQmAq3xuh7vNwCp07UTmE5i11XAEExx4RA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "chardet": "^2.1.1",
+        "iconv-lite": "^0.7.0"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "peerDependencies": {
+        "@types/node": ">=18"
+      },
+      "peerDependenciesMeta": {
+        "@types/node": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@inquirer/figures": {
+      "version": "1.0.15",
+      "resolved": "https://registry.npmjs.org/@inquirer/figures/-/figures-1.0.15.tgz",
+      "integrity": "sha512-t2IEY+unGHOzAaVM5Xx6DEWKeXlDDcNPeDyUpsRc6CUhBfU3VQOEl+Vssh7VNp1dR8MdUJBWhuObjXCsVpjN5g==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@inquirer/input": {
+      "version": "4.3.1",
+      "resolved": "https://registry.npmjs.org/@inquirer/input/-/input-4.3.1.tgz",
+      "integrity": "sha512-kN0pAM4yPrLjJ1XJBjDxyfDduXOuQHrBB8aLDMueuwUGn+vNpF7Gq7TvyVxx8u4SHlFFj4trmj+a2cbpG4Jn1g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@inquirer/core": "^10.3.2",
+        "@inquirer/type": "^3.0.10"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "peerDependencies": {
+        "@types/node": ">=18"
+      },
+      "peerDependenciesMeta": {
+        "@types/node": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@inquirer/number": {
+      "version": "3.0.23",
+      "resolved": "https://registry.npmjs.org/@inquirer/number/-/number-3.0.23.tgz",
+      "integrity": "sha512-5Smv0OK7K0KUzUfYUXDXQc9jrf8OHo4ktlEayFlelCjwMXz0299Y8OrI+lj7i4gCBY15UObk76q0QtxjzFcFcg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@inquirer/core": "^10.3.2",
+        "@inquirer/type": "^3.0.10"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "peerDependencies": {
+        "@types/node": ">=18"
+      },
+      "peerDependenciesMeta": {
+        "@types/node": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@inquirer/password": {
+      "version": "4.0.23",
+      "resolved": "https://registry.npmjs.org/@inquirer/password/-/password-4.0.23.tgz",
+      "integrity": "sha512-zREJHjhT5vJBMZX/IUbyI9zVtVfOLiTO66MrF/3GFZYZ7T4YILW5MSkEYHceSii/KtRk+4i3RE7E1CUXA2jHcA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@inquirer/ansi": "^1.0.2",
+        "@inquirer/core": "^10.3.2",
+        "@inquirer/type": "^3.0.10"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "peerDependencies": {
+        "@types/node": ">=18"
+      },
+      "peerDependenciesMeta": {
+        "@types/node": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@inquirer/prompts": {
+      "version": "7.10.1",
+      "resolved": "https://registry.npmjs.org/@inquirer/prompts/-/prompts-7.10.1.tgz",
+      "integrity": "sha512-Dx/y9bCQcXLI5ooQ5KyvA4FTgeo2jYj/7plWfV5Ak5wDPKQZgudKez2ixyfz7tKXzcJciTxqLeK7R9HItwiByg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@inquirer/checkbox": "^4.3.2",
+        "@inquirer/confirm": "^5.1.21",
+        "@inquirer/editor": "^4.2.23",
+        "@inquirer/expand": "^4.0.23",
+        "@inquirer/input": "^4.3.1",
+        "@inquirer/number": "^3.0.23",
+        "@inquirer/password": "^4.0.23",
+        "@inquirer/rawlist": "^4.1.11",
+        "@inquirer/search": "^3.2.2",
+        "@inquirer/select": "^4.4.2"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "peerDependencies": {
+        "@types/node": ">=18"
+      },
+      "peerDependenciesMeta": {
+        "@types/node": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@inquirer/rawlist": {
+      "version": "4.1.11",
+      "resolved": "https://registry.npmjs.org/@inquirer/rawlist/-/rawlist-4.1.11.tgz",
+      "integrity": "sha512-+LLQB8XGr3I5LZN/GuAHo+GpDJegQwuPARLChlMICNdwW7OwV2izlCSCxN6cqpL0sMXmbKbFcItJgdQq5EBXTw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@inquirer/core": "^10.3.2",
+        "@inquirer/type": "^3.0.10",
+        "yoctocolors-cjs": "^2.1.3"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "peerDependencies": {
+        "@types/node": ">=18"
+      },
+      "peerDependenciesMeta": {
+        "@types/node": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@inquirer/search": {
+      "version": "3.2.2",
+      "resolved": "https://registry.npmjs.org/@inquirer/search/-/search-3.2.2.tgz",
+      "integrity": "sha512-p2bvRfENXCZdWF/U2BXvnSI9h+tuA8iNqtUKb9UWbmLYCRQxd8WkvwWvYn+3NgYaNwdUkHytJMGG4MMLucI1kA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@inquirer/core": "^10.3.2",
+        "@inquirer/figures": "^1.0.15",
+        "@inquirer/type": "^3.0.10",
+        "yoctocolors-cjs": "^2.1.3"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "peerDependencies": {
+        "@types/node": ">=18"
+      },
+      "peerDependenciesMeta": {
+        "@types/node": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@inquirer/select": {
+      "version": "4.4.2",
+      "resolved": "https://registry.npmjs.org/@inquirer/select/-/select-4.4.2.tgz",
+      "integrity": "sha512-l4xMuJo55MAe+N7Qr4rX90vypFwCajSakx59qe/tMaC1aEHWLyw68wF4o0A4SLAY4E0nd+Vt+EyskeDIqu1M6w==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@inquirer/ansi": "^1.0.2",
+        "@inquirer/core": "^10.3.2",
+        "@inquirer/figures": "^1.0.15",
+        "@inquirer/type": "^3.0.10",
+        "yoctocolors-cjs": "^2.1.3"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "peerDependencies": {
+        "@types/node": ">=18"
+      },
+      "peerDependenciesMeta": {
+        "@types/node": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@inquirer/type": {
+      "version": "3.0.10",
+      "resolved": "https://registry.npmjs.org/@inquirer/type/-/type-3.0.10.tgz",
+      "integrity": "sha512-BvziSRxfz5Ov8ch0z/n3oijRSEcEsHnhggm4xFZe93DHcUCTlutlq9Ox4SVENAfcRD22UQq7T/atg9Wr3k09eA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      },
+      "peerDependencies": {
+        "@types/node": ">=18"
+      },
+      "peerDependenciesMeta": {
+        "@types/node": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@isaacs/cliui": {
+      "version": "8.0.2",
+      "resolved": "https://registry.npmjs.org/@isaacs/cliui/-/cliui-8.0.2.tgz",
+      "integrity": "sha512-O8jcjabXaleOG9DQ0+ARXWZBTfnP4WNAqzuiJK7ll44AmxGKv/J2M4TPjxjY3znBCfvBXFzucm1twdyFybFqEA==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "string-width": "^5.1.2",
+        "string-width-cjs": "npm:string-width@^4.2.0",
+        "strip-ansi": "^7.0.1",
+        "strip-ansi-cjs": "npm:strip-ansi@^6.0.1",
+        "wrap-ansi": "^8.1.0",
+        "wrap-ansi-cjs": "npm:wrap-ansi@^7.0.0"
+      },
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@isaacs/cliui/node_modules/ansi-styles": {
+      "version": "6.2.3",
+      "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-6.2.3.tgz",
+      "integrity": "sha512-4Dj6M28JB+oAH8kFkTLUo+a2jwOFkuqb3yucU0CANcRRUbxS0cP0nZYCGjcc3BNXwRIsUVmDGgzawme7zvJHvg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/ansi-styles?sponsor=1"
+      }
+    },
+    "node_modules/@isaacs/cliui/node_modules/wrap-ansi": {
+      "version": "8.1.0",
+      "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-8.1.0.tgz",
+      "integrity": "sha512-si7QWI6zUMq56bESFvagtmzMdGOtoxfR+Sez11Mobfc7tm+VkUckk9bW2UeffTGVUbOksxmSw0AA2gs8g71NCQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "ansi-styles": "^6.1.0",
+        "string-width": "^5.0.1",
+        "strip-ansi": "^7.0.1"
+      },
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/wrap-ansi?sponsor=1"
+      }
+    },
+    "node_modules/@jest/diff-sequences": {
+      "version": "30.0.1",
+      "resolved": "https://registry.npmjs.org/@jest/diff-sequences/-/diff-sequences-30.0.1.tgz",
+      "integrity": "sha512-n5H8QLDJ47QqbCNn5SuFjCRDrOLEZ0h8vAHCK5RL9Ls7Xa8AQLa/YxAc9UjFqoEDM48muwtBGjtMY5cr0PLDCw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": "^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0"
+      }
+    },
+    "node_modules/@jest/expect-utils": {
+      "version": "30.2.0",
+      "resolved": "https://registry.npmjs.org/@jest/expect-utils/-/expect-utils-30.2.0.tgz",
+      "integrity": "sha512-1JnRfhqpD8HGpOmQp180Fo9Zt69zNtC+9lR+kT7NVL05tNXIi+QC8Csz7lfidMoVLPD3FnOtcmp0CEFnxExGEA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jest/get-type": "30.1.0"
+      },
+      "engines": {
+        "node": "^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0"
+      }
+    },
+    "node_modules/@jest/get-type": {
+      "version": "30.1.0",
+      "resolved": "https://registry.npmjs.org/@jest/get-type/-/get-type-30.1.0.tgz",
+      "integrity": "sha512-eMbZE2hUnx1WV0pmURZY9XoXPkUYjpc55mb0CrhtdWLtzMQPFvu/rZkTLZFTsdaVQa+Tr4eWAteqcUzoawq/uA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": "^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0"
+      }
+    },
+    "node_modules/@jest/pattern": {
+      "version": "30.0.1",
+      "resolved": "https://registry.npmjs.org/@jest/pattern/-/pattern-30.0.1.tgz",
+      "integrity": "sha512-gWp7NfQW27LaBQz3TITS8L7ZCQ0TLvtmI//4OwlQRx4rnWxcPNIYjxZpDcN4+UlGxgm3jS5QPz8IPTCkb59wZA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/node": "*",
+        "jest-regex-util": "30.0.1"
+      },
+      "engines": {
+        "node": "^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0"
+      }
+    },
+    "node_modules/@jest/schemas": {
+      "version": "30.0.5",
+      "resolved": "https://registry.npmjs.org/@jest/schemas/-/schemas-30.0.5.tgz",
+      "integrity": "sha512-DmdYgtezMkh3cpU8/1uyXakv3tJRcmcXxBOcO0tbaozPwpmh4YMsnWrQm9ZmZMfa5ocbxzbFk6O4bDPEc/iAnA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@sinclair/typebox": "^0.34.0"
+      },
+      "engines": {
+        "node": "^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0"
+      }
+    },
+    "node_modules/@jest/types": {
+      "version": "30.2.0",
+      "resolved": "https://registry.npmjs.org/@jest/types/-/types-30.2.0.tgz",
+      "integrity": "sha512-H9xg1/sfVvyfU7o3zMfBEjQ1gcsdeTMgqHoYdN79tuLqfTtuu7WckRA1R5whDwOzxaZAeMKTYWqP+WCAi0CHsg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jest/pattern": "30.0.1",
+        "@jest/schemas": "30.0.5",
+        "@types/istanbul-lib-coverage": "^2.0.6",
+        "@types/istanbul-reports": "^3.0.4",
+        "@types/node": "*",
+        "@types/yargs": "^17.0.33",
+        "chalk": "^4.1.2"
+      },
+      "engines": {
+        "node": "^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0"
+      }
+    },
+    "node_modules/@jest/types/node_modules/ansi-styles": {
+      "version": "4.3.0",
+      "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz",
+      "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "color-convert": "^2.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/ansi-styles?sponsor=1"
+      }
+    },
+    "node_modules/@jest/types/node_modules/chalk": {
+      "version": "4.1.2",
+      "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz",
+      "integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "ansi-styles": "^4.1.0",
+        "supports-color": "^7.1.0"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/chalk?sponsor=1"
+      }
+    },
+    "node_modules/@jest/types/node_modules/supports-color": {
+      "version": "7.2.0",
+      "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz",
+      "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "has-flag": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/@jridgewell/gen-mapping": {
+      "version": "0.3.13",
+      "resolved": "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.3.13.tgz",
+      "integrity": "sha512-2kkt/7niJ6MgEPxF0bYdQ6etZaA+fQvDcLKckhy1yIQOzaoKjBBjSj63/aLVjYE3qhRt5dvM+uUyfCg6UKCBbA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jridgewell/sourcemap-codec": "^1.5.0",
+        "@jridgewell/trace-mapping": "^0.3.24"
+      }
+    },
+    "node_modules/@jridgewell/remapping": {
+      "version": "2.3.5",
+      "resolved": "https://registry.npmjs.org/@jridgewell/remapping/-/remapping-2.3.5.tgz",
+      "integrity": "sha512-LI9u/+laYG4Ds1TDKSJW2YPrIlcVYOwi2fUC6xB43lueCjgxV4lffOCZCtYFiH6TNOX+tQKXx97T4IKHbhyHEQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jridgewell/gen-mapping": "^0.3.5",
+        "@jridgewell/trace-mapping": "^0.3.24"
+      }
+    },
+    "node_modules/@jridgewell/resolve-uri": {
+      "version": "3.1.2",
+      "resolved": "https://registry.npmjs.org/@jridgewell/resolve-uri/-/resolve-uri-3.1.2.tgz",
+      "integrity": "sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.0.0"
+      }
+    },
+    "node_modules/@jridgewell/sourcemap-codec": {
+      "version": "1.5.5",
+      "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.5.5.tgz",
+      "integrity": "sha512-cYQ9310grqxueWbl+WuIUIaiUaDcj7WOq5fVhEljNVgRfOUhY9fy2zTvfoqWsnebh8Sl70VScFbICvJnLKB0Og==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@jridgewell/trace-mapping": {
+      "version": "0.3.31",
+      "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.31.tgz",
+      "integrity": "sha512-zzNR+SdQSDJzc8joaeP8QQoCQr8NuYx2dIIytl1QeBEZHJ9uW6hebsrYgbz8hJwUQao3TWCMtmfV8Nu1twOLAw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jridgewell/resolve-uri": "^3.1.0",
+        "@jridgewell/sourcemap-codec": "^1.4.14"
+      }
+    },
+    "node_modules/@lezer/common": {
+      "version": "1.5.1",
+      "resolved": "https://registry.npmjs.org/@lezer/common/-/common-1.5.1.tgz",
+      "integrity": "sha512-6YRVG9vBkaY7p1IVxL4s44n5nUnaNnGM2/AckNgYOnxTG2kWh1vR8BMxPseWPjRNpb5VtXnMpeYAEAADoRV1Iw==",
+      "license": "MIT"
+    },
+    "node_modules/@lezer/cpp": {
+      "version": "1.1.5",
+      "resolved": "https://registry.npmjs.org/@lezer/cpp/-/cpp-1.1.5.tgz",
+      "integrity": "sha512-DIhSXmYtJKLehrjzDFN+2cPt547ySQ41nA8yqcDf/GxMc+YM736xqltFkvADL2M0VebU5I+3+4ks2Vv+Kyq3Aw==",
+      "license": "MIT",
+      "dependencies": {
+        "@lezer/common": "^1.2.0",
+        "@lezer/highlight": "^1.0.0",
+        "@lezer/lr": "^1.0.0"
+      }
+    },
+    "node_modules/@lezer/css": {
+      "version": "1.3.1",
+      "resolved": "https://registry.npmjs.org/@lezer/css/-/css-1.3.1.tgz",
+      "integrity": "sha512-PYAKeUVBo3HFThruRyp/iK91SwiZJnzXh8QzkQlwijB5y+N5iB28+iLk78o2zmKqqV0uolNhCwFqB8LA7b0Svg==",
+      "license": "MIT",
+      "dependencies": {
+        "@lezer/common": "^1.2.0",
+        "@lezer/highlight": "^1.0.0",
+        "@lezer/lr": "^1.3.0"
+      }
+    },
+    "node_modules/@lezer/go": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/@lezer/go/-/go-1.0.1.tgz",
+      "integrity": "sha512-xToRsYxwsgJNHTgNdStpcvmbVuKxTapV0dM0wey1geMMRc9aggoVyKgzYp41D2/vVOx+Ii4hmE206kvxIXBVXQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@lezer/common": "^1.2.0",
+        "@lezer/highlight": "^1.0.0",
+        "@lezer/lr": "^1.3.0"
+      }
+    },
+    "node_modules/@lezer/highlight": {
+      "version": "1.2.3",
+      "resolved": "https://registry.npmjs.org/@lezer/highlight/-/highlight-1.2.3.tgz",
+      "integrity": "sha512-qXdH7UqTvGfdVBINrgKhDsVTJTxactNNxLk7+UMwZhU13lMHaOBlJe9Vqp907ya56Y3+ed2tlqzys7jDkTmW0g==",
+      "license": "MIT",
+      "dependencies": {
+        "@lezer/common": "^1.3.0"
+      }
+    },
+    "node_modules/@lezer/html": {
+      "version": "1.3.13",
+      "resolved": "https://registry.npmjs.org/@lezer/html/-/html-1.3.13.tgz",
+      "integrity": "sha512-oI7n6NJml729m7pjm9lvLvmXbdoMoi2f+1pwSDJkl9d68zGr7a9Btz8NdHTGQZtW2DA25ybeuv/SyDb9D5tseg==",
+      "license": "MIT",
+      "dependencies": {
+        "@lezer/common": "^1.2.0",
+        "@lezer/highlight": "^1.0.0",
+        "@lezer/lr": "^1.0.0"
+      }
+    },
+    "node_modules/@lezer/java": {
+      "version": "1.1.3",
+      "resolved": "https://registry.npmjs.org/@lezer/java/-/java-1.1.3.tgz",
+      "integrity": "sha512-yHquUfujwg6Yu4Fd1GNHCvidIvJwi/1Xu2DaKl/pfWIA2c1oXkVvawH3NyXhCaFx4OdlYBVX5wvz2f7Aoa/4Xw==",
+      "license": "MIT",
+      "dependencies": {
+        "@lezer/common": "^1.2.0",
+        "@lezer/highlight": "^1.0.0",
+        "@lezer/lr": "^1.0.0"
+      }
+    },
+    "node_modules/@lezer/javascript": {
+      "version": "1.5.4",
+      "resolved": "https://registry.npmjs.org/@lezer/javascript/-/javascript-1.5.4.tgz",
+      "integrity": "sha512-vvYx3MhWqeZtGPwDStM2dwgljd5smolYD2lR2UyFcHfxbBQebqx8yjmFmxtJ/E6nN6u1D9srOiVWm3Rb4tmcUA==",
+      "license": "MIT",
+      "dependencies": {
+        "@lezer/common": "^1.2.0",
+        "@lezer/highlight": "^1.1.3",
+        "@lezer/lr": "^1.3.0"
+      }
+    },
+    "node_modules/@lezer/json": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/@lezer/json/-/json-1.0.3.tgz",
+      "integrity": "sha512-BP9KzdF9Y35PDpv04r0VeSTKDeox5vVr3efE7eBbx3r4s3oNLfunchejZhjArmeieBH+nVOpgIiBJpEAv8ilqQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@lezer/common": "^1.2.0",
+        "@lezer/highlight": "^1.0.0",
+        "@lezer/lr": "^1.0.0"
+      }
+    },
+    "node_modules/@lezer/lr": {
+      "version": "1.4.8",
+      "resolved": "https://registry.npmjs.org/@lezer/lr/-/lr-1.4.8.tgz",
+      "integrity": "sha512-bPWa0Pgx69ylNlMlPvBPryqeLYQjyJjqPx+Aupm5zydLIF3NE+6MMLT8Yi23Bd9cif9VS00aUebn+6fDIGBcDA==",
+      "license": "MIT",
+      "dependencies": {
+        "@lezer/common": "^1.0.0"
+      }
+    },
+    "node_modules/@lezer/markdown": {
+      "version": "1.6.3",
+      "resolved": "https://registry.npmjs.org/@lezer/markdown/-/markdown-1.6.3.tgz",
+      "integrity": "sha512-jpGm5Ps+XErS+xA4urw7ogEGkeZOahVQF21Z6oECF0sj+2liwZopd2+I8uH5I/vZsRuuze3OxBREIANLf6KKUw==",
+      "license": "MIT",
+      "dependencies": {
+        "@lezer/common": "^1.5.0",
+        "@lezer/highlight": "^1.0.0"
+      }
+    },
+    "node_modules/@lezer/php": {
+      "version": "1.0.5",
+      "resolved": "https://registry.npmjs.org/@lezer/php/-/php-1.0.5.tgz",
+      "integrity": "sha512-W7asp9DhM6q0W6DYNwIkLSKOvxlXRrif+UXBMxzsJUuqmhE7oVU+gS3THO4S/Puh7Xzgm858UNaFi6dxTP8dJA==",
+      "license": "MIT",
+      "dependencies": {
+        "@lezer/common": "^1.2.0",
+        "@lezer/highlight": "^1.0.0",
+        "@lezer/lr": "^1.1.0"
+      }
+    },
+    "node_modules/@lezer/python": {
+      "version": "1.1.18",
+      "resolved": "https://registry.npmjs.org/@lezer/python/-/python-1.1.18.tgz",
+      "integrity": "sha512-31FiUrU7z9+d/ElGQLJFXl+dKOdx0jALlP3KEOsGTex8mvj+SoE1FgItcHWK/axkxCHGUSpqIHt6JAWfWu9Rhg==",
+      "license": "MIT",
+      "dependencies": {
+        "@lezer/common": "^1.2.0",
+        "@lezer/highlight": "^1.0.0",
+        "@lezer/lr": "^1.0.0"
+      }
+    },
+    "node_modules/@lezer/rust": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/@lezer/rust/-/rust-1.0.2.tgz",
+      "integrity": "sha512-Lz5sIPBdF2FUXcWeCu1//ojFAZqzTQNRga0aYv6dYXqJqPfMdCAI0NzajWUd4Xijj1IKJLtjoXRPMvTKWBcqKg==",
+      "license": "MIT",
+      "dependencies": {
+        "@lezer/common": "^1.2.0",
+        "@lezer/highlight": "^1.0.0",
+        "@lezer/lr": "^1.0.0"
+      }
+    },
+    "node_modules/@lezer/xml": {
+      "version": "1.0.6",
+      "resolved": "https://registry.npmjs.org/@lezer/xml/-/xml-1.0.6.tgz",
+      "integrity": "sha512-CdDwirL0OEaStFue/66ZmFSeppuL6Dwjlk8qk153mSQwiSH/Dlri4GNymrNWnUmPl2Um7QfV1FO9KFUyX3Twww==",
+      "license": "MIT",
+      "dependencies": {
+        "@lezer/common": "^1.2.0",
+        "@lezer/highlight": "^1.0.0",
+        "@lezer/lr": "^1.0.0"
+      }
+    },
+    "node_modules/@lezer/yaml": {
+      "version": "1.0.4",
+      "resolved": "https://registry.npmjs.org/@lezer/yaml/-/yaml-1.0.4.tgz",
+      "integrity": "sha512-2lrrHqxalACEbxIbsjhqGpSW8kWpUKuY6RHgnSAFZa6qK62wvnPxA8hGOwOoDbwHcOFs5M4o27mjGu+P7TvBmw==",
+      "license": "MIT",
+      "dependencies": {
+        "@lezer/common": "^1.2.0",
+        "@lezer/highlight": "^1.0.0",
+        "@lezer/lr": "^1.4.0"
+      }
+    },
+    "node_modules/@marijn/find-cluster-break": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/@marijn/find-cluster-break/-/find-cluster-break-1.0.2.tgz",
+      "integrity": "sha512-l0h88YhZFyKdXIFNfSWpyjStDjGHwZ/U7iobcK1cQQD8sejsONdQtTVU+1wVN1PBw40PiiHB1vA5S7VTfQiP9g==",
+      "license": "MIT"
+    },
+    "node_modules/@napi-rs/canvas": {
+      "version": "0.1.96",
+      "resolved": "https://registry.npmjs.org/@napi-rs/canvas/-/canvas-0.1.96.tgz",
+      "integrity": "sha512-6NNmNxvoJKeucVjxaaRUt3La2i5jShgiAbaY3G/72s1Vp3U06XPrAIxkAjBxpDcamEn/t+WJ4OOlGmvILo4/Ew==",
+      "license": "MIT",
+      "optional": true,
+      "workspaces": [
+        "e2e/*"
+      ],
+      "engines": {
+        "node": ">= 10"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/Brooooooklyn"
+      },
+      "optionalDependencies": {
+        "@napi-rs/canvas-android-arm64": "0.1.96",
+        "@napi-rs/canvas-darwin-arm64": "0.1.96",
+        "@napi-rs/canvas-darwin-x64": "0.1.96",
+        "@napi-rs/canvas-linux-arm-gnueabihf": "0.1.96",
+        "@napi-rs/canvas-linux-arm64-gnu": "0.1.96",
+        "@napi-rs/canvas-linux-arm64-musl": "0.1.96",
+        "@napi-rs/canvas-linux-riscv64-gnu": "0.1.96",
+        "@napi-rs/canvas-linux-x64-gnu": "0.1.96",
+        "@napi-rs/canvas-linux-x64-musl": "0.1.96",
+        "@napi-rs/canvas-win32-arm64-msvc": "0.1.96",
+        "@napi-rs/canvas-win32-x64-msvc": "0.1.96"
+      }
+    },
+    "node_modules/@napi-rs/canvas-android-arm64": {
+      "version": "0.1.96",
+      "resolved": "https://registry.npmjs.org/@napi-rs/canvas-android-arm64/-/canvas-android-arm64-0.1.96.tgz",
+      "integrity": "sha512-ew1sPrN3dGdZ3L4FoohPfnjq0f9/Jk7o+wP7HkQZokcXgIUD6FIyICEWGhMYzv53j63wUcPvZeAwgewX58/egg==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">= 10"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/Brooooooklyn"
+      }
+    },
+    "node_modules/@napi-rs/canvas-darwin-arm64": {
+      "version": "0.1.96",
+      "resolved": "https://registry.npmjs.org/@napi-rs/canvas-darwin-arm64/-/canvas-darwin-arm64-0.1.96.tgz",
+      "integrity": "sha512-Q/wOXZ5PzTqpdmA5eUOcegCf4Go/zz3aZ5DlzSeDpOjFmfwMKh8EzLAoweQ+mJVagcHQyzoJhaTEnrO68TNyNg==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">= 10"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/Brooooooklyn"
+      }
+    },
+    "node_modules/@napi-rs/canvas-darwin-x64": {
+      "version": "0.1.96",
+      "resolved": "https://registry.npmjs.org/@napi-rs/canvas-darwin-x64/-/canvas-darwin-x64-0.1.96.tgz",
+      "integrity": "sha512-UrXiQz28tQEvGM1qvyptewOAfmUrrd5+wvi6Rzjj2VprZI8iZ2KIvBD2lTTG1bVF95AbeDeG7PJA0D9sLKaOFA==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">= 10"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/Brooooooklyn"
+      }
+    },
+    "node_modules/@napi-rs/canvas-linux-arm-gnueabihf": {
+      "version": "0.1.96",
+      "resolved": "https://registry.npmjs.org/@napi-rs/canvas-linux-arm-gnueabihf/-/canvas-linux-arm-gnueabihf-0.1.96.tgz",
+      "integrity": "sha512-I90ODxweD8aEP6XKU/NU+biso95MwCtQ2F46dUvhec1HesFi0tq/tAJkYic/1aBSiO/1kGKmSeD1B0duOHhEHQ==",
+      "cpu": [
+        "arm"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">= 10"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/Brooooooklyn"
+      }
+    },
+    "node_modules/@napi-rs/canvas-linux-arm64-gnu": {
+      "version": "0.1.96",
+      "resolved": "https://registry.npmjs.org/@napi-rs/canvas-linux-arm64-gnu/-/canvas-linux-arm64-gnu-0.1.96.tgz",
+      "integrity": "sha512-Dx/0+RFV++w3PcRy+4xNXkghhXjA5d0Mw1bs95emn5Llinp1vihMaA6WJt3oYv2LAHc36+gnrhIBsPhUyI2SGw==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">= 10"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/Brooooooklyn"
+      }
+    },
+    "node_modules/@napi-rs/canvas-linux-arm64-musl": {
+      "version": "0.1.96",
+      "resolved": "https://registry.npmjs.org/@napi-rs/canvas-linux-arm64-musl/-/canvas-linux-arm64-musl-0.1.96.tgz",
+      "integrity": "sha512-UvOi7fii3IE2KDfEfhh8m+LpzSRvhGK7o1eho99M2M0HTik11k3GX+2qgVx9EtujN3/bhFFS1kSO3+vPMaJ0Mg==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">= 10"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/Brooooooklyn"
+      }
+    },
+    "node_modules/@napi-rs/canvas-linux-riscv64-gnu": {
+      "version": "0.1.96",
+      "resolved": "https://registry.npmjs.org/@napi-rs/canvas-linux-riscv64-gnu/-/canvas-linux-riscv64-gnu-0.1.96.tgz",
+      "integrity": "sha512-MBSukhGCQ5nRtf9NbFYWOU080yqkZU1PbuH4o1ROvB4CbPl12fchDR35tU83Wz8gWIM9JTn99lBn9DenPIv7Ig==",
+      "cpu": [
+        "riscv64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">= 10"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/Brooooooklyn"
+      }
+    },
+    "node_modules/@napi-rs/canvas-linux-x64-gnu": {
+      "version": "0.1.96",
+      "resolved": "https://registry.npmjs.org/@napi-rs/canvas-linux-x64-gnu/-/canvas-linux-x64-gnu-0.1.96.tgz",
+      "integrity": "sha512-I/ccu2SstyKiV3HIeVzyBIWfrJo8cN7+MSQZPnabewWV6hfJ2nY7Df2WqOHmobBRUw84uGR6zfQHsUEio/m5Vg==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">= 10"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/Brooooooklyn"
+      }
+    },
+    "node_modules/@napi-rs/canvas-linux-x64-musl": {
+      "version": "0.1.96",
+      "resolved": "https://registry.npmjs.org/@napi-rs/canvas-linux-x64-musl/-/canvas-linux-x64-musl-0.1.96.tgz",
+      "integrity": "sha512-H3uov7qnTl73GDT4h52lAqpJPsl1tIUyNPWJyhQ6gHakohNqqRq3uf80+NEpzcytKGEOENP1wX3yGwZxhjiWEQ==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">= 10"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/Brooooooklyn"
+      }
+    },
+    "node_modules/@napi-rs/canvas-win32-arm64-msvc": {
+      "version": "0.1.96",
+      "resolved": "https://registry.npmjs.org/@napi-rs/canvas-win32-arm64-msvc/-/canvas-win32-arm64-msvc-0.1.96.tgz",
+      "integrity": "sha512-ATp6Y+djOjYtkfV/VRH7CZ8I1MEtkUQBmKUbuWw5zWEHHqfL0cEcInE4Cxgx7zkNAhEdBbnH8HMVrqNp+/gwxA==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">= 10"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/Brooooooklyn"
+      }
+    },
+    "node_modules/@napi-rs/canvas-win32-x64-msvc": {
+      "version": "0.1.96",
+      "resolved": "https://registry.npmjs.org/@napi-rs/canvas-win32-x64-msvc/-/canvas-win32-x64-msvc-0.1.96.tgz",
+      "integrity": "sha512-UYGdTltVd+Z8mcIuoqGmAXXUvwH5CLf2M6mIB5B0/JmX5J041jETjqtSYl7gN+aj3k1by/SG6sS0hAwCqyK7zw==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">= 10"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/Brooooooklyn"
+      }
+    },
+    "node_modules/@pkgjs/parseargs": {
+      "version": "0.11.0",
+      "resolved": "https://registry.npmjs.org/@pkgjs/parseargs/-/parseargs-0.11.0.tgz",
+      "integrity": "sha512-+1VkjdD0QBLPodGrJUeqarH8VAIvQODIbwh9XpP5Syisf7YoQgsJKPNFoqqLQlu+VQ/tVSshMR6loPMn8U+dPg==",
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "engines": {
+        "node": ">=14"
+      }
+    },
+    "node_modules/@promptbook/utils": {
+      "version": "0.69.5",
+      "resolved": "https://registry.npmjs.org/@promptbook/utils/-/utils-0.69.5.tgz",
+      "integrity": "sha512-xm5Ti/Hp3o4xHrsK9Yy3MS6KbDxYbq485hDsFvxqaNA7equHLPdo8H8faTitTeb14QCDfLW4iwCxdVYu5sn6YQ==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "individual",
+          "url": "https://buymeacoffee.com/hejny"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/webgptorg/promptbook/blob/main/README.md#%EF%B8%8F-contributing"
+        }
+      ],
+      "license": "CC-BY-4.0",
+      "dependencies": {
+        "spacetrim": "0.11.59"
+      }
+    },
+    "node_modules/@puppeteer/browsers": {
+      "version": "2.13.0",
+      "resolved": "https://registry.npmjs.org/@puppeteer/browsers/-/browsers-2.13.0.tgz",
+      "integrity": "sha512-46BZJYJjc/WwmKjsvDFykHtXrtomsCIrwYQPOP7VfMJoZY2bsDF9oROBABR3paDjDcmkUye1Pb1BqdcdiipaWA==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "debug": "^4.4.3",
+        "extract-zip": "^2.0.1",
+        "progress": "^2.0.3",
+        "proxy-agent": "^6.5.0",
+        "semver": "^7.7.4",
+        "tar-fs": "^3.1.1",
+        "yargs": "^17.7.2"
+      },
+      "bin": {
+        "browsers": "lib/cjs/main-cli.js"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@rollup/rollup-android-arm-eabi": {
+      "version": "4.59.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.59.0.tgz",
+      "integrity": "sha512-upnNBkA6ZH2VKGcBj9Fyl9IGNPULcjXRlg0LLeaioQWueH30p6IXtJEbKAgvyv+mJaMxSm1l6xwDXYjpEMiLMg==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ]
+    },
+    "node_modules/@rollup/rollup-android-arm64": {
+      "version": "4.59.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm64/-/rollup-android-arm64-4.59.0.tgz",
+      "integrity": "sha512-hZ+Zxj3SySm4A/DylsDKZAeVg0mvi++0PYVceVyX7hemkw7OreKdCvW2oQ3T1FMZvCaQXqOTHb8qmBShoqk69Q==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ]
+    },
+    "node_modules/@rollup/rollup-darwin-arm64": {
+      "version": "4.59.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.59.0.tgz",
+      "integrity": "sha512-W2Psnbh1J8ZJw0xKAd8zdNgF9HRLkdWwwdWqubSVk0pUuQkoHnv7rx4GiF9rT4t5DIZGAsConRE3AxCdJ4m8rg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ]
+    },
+    "node_modules/@rollup/rollup-darwin-x64": {
+      "version": "4.59.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-x64/-/rollup-darwin-x64-4.59.0.tgz",
+      "integrity": "sha512-ZW2KkwlS4lwTv7ZVsYDiARfFCnSGhzYPdiOU4IM2fDbL+QGlyAbjgSFuqNRbSthybLbIJ915UtZBtmuLrQAT/w==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ]
+    },
+    "node_modules/@rollup/rollup-freebsd-arm64": {
+      "version": "4.59.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-arm64/-/rollup-freebsd-arm64-4.59.0.tgz",
+      "integrity": "sha512-EsKaJ5ytAu9jI3lonzn3BgG8iRBjV4LxZexygcQbpiU0wU0ATxhNVEpXKfUa0pS05gTcSDMKpn3Sx+QB9RlTTA==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ]
+    },
+    "node_modules/@rollup/rollup-freebsd-x64": {
+      "version": "4.59.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-x64/-/rollup-freebsd-x64-4.59.0.tgz",
+      "integrity": "sha512-d3DuZi2KzTMjImrxoHIAODUZYoUUMsuUiY4SRRcJy6NJoZ6iIqWnJu9IScV9jXysyGMVuW+KNzZvBLOcpdl3Vg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm-gnueabihf": {
+      "version": "4.59.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-gnueabihf/-/rollup-linux-arm-gnueabihf-4.59.0.tgz",
+      "integrity": "sha512-t4ONHboXi/3E0rT6OZl1pKbl2Vgxf9vJfWgmUoCEVQVxhW6Cw/c8I6hbbu7DAvgp82RKiH7TpLwxnJeKv2pbsw==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm-musleabihf": {
+      "version": "4.59.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-musleabihf/-/rollup-linux-arm-musleabihf-4.59.0.tgz",
+      "integrity": "sha512-CikFT7aYPA2ufMD086cVORBYGHffBo4K8MQ4uPS/ZnY54GKj36i196u8U+aDVT2LX4eSMbyHtyOh7D7Zvk2VvA==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm64-gnu": {
+      "version": "4.59.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-gnu/-/rollup-linux-arm64-gnu-4.59.0.tgz",
+      "integrity": "sha512-jYgUGk5aLd1nUb1CtQ8E+t5JhLc9x5WdBKew9ZgAXg7DBk0ZHErLHdXM24rfX+bKrFe+Xp5YuJo54I5HFjGDAA==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm64-musl": {
+      "version": "4.59.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-musl/-/rollup-linux-arm64-musl-4.59.0.tgz",
+      "integrity": "sha512-peZRVEdnFWZ5Bh2KeumKG9ty7aCXzzEsHShOZEFiCQlDEepP1dpUl/SrUNXNg13UmZl+gzVDPsiCwnV1uI0RUA==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-loong64-gnu": {
+      "version": "4.59.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loong64-gnu/-/rollup-linux-loong64-gnu-4.59.0.tgz",
+      "integrity": "sha512-gbUSW/97f7+r4gHy3Jlup8zDG190AuodsWnNiXErp9mT90iCy9NKKU0Xwx5k8VlRAIV2uU9CsMnEFg/xXaOfXg==",
+      "cpu": [
+        "loong64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-loong64-musl": {
+      "version": "4.59.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loong64-musl/-/rollup-linux-loong64-musl-4.59.0.tgz",
+      "integrity": "sha512-yTRONe79E+o0FWFijasoTjtzG9EBedFXJMl888NBEDCDV9I2wGbFFfJQQe63OijbFCUZqxpHz1GzpbtSFikJ4Q==",
+      "cpu": [
+        "loong64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-ppc64-gnu": {
+      "version": "4.59.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-ppc64-gnu/-/rollup-linux-ppc64-gnu-4.59.0.tgz",
+      "integrity": "sha512-sw1o3tfyk12k3OEpRddF68a1unZ5VCN7zoTNtSn2KndUE+ea3m3ROOKRCZxEpmT9nsGnogpFP9x6mnLTCaoLkA==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-ppc64-musl": {
+      "version": "4.59.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-ppc64-musl/-/rollup-linux-ppc64-musl-4.59.0.tgz",
+      "integrity": "sha512-+2kLtQ4xT3AiIxkzFVFXfsmlZiG5FXYW7ZyIIvGA7Bdeuh9Z0aN4hVyXS/G1E9bTP/vqszNIN/pUKCk/BTHsKA==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-riscv64-gnu": {
+      "version": "4.59.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-gnu/-/rollup-linux-riscv64-gnu-4.59.0.tgz",
+      "integrity": "sha512-NDYMpsXYJJaj+I7UdwIuHHNxXZ/b/N2hR15NyH3m2qAtb/hHPA4g4SuuvrdxetTdndfj9b1WOmy73kcPRoERUg==",
+      "cpu": [
+        "riscv64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-riscv64-musl": {
+      "version": "4.59.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-musl/-/rollup-linux-riscv64-musl-4.59.0.tgz",
+      "integrity": "sha512-nLckB8WOqHIf1bhymk+oHxvM9D3tyPndZH8i8+35p/1YiVoVswPid2yLzgX7ZJP0KQvnkhM4H6QZ5m0LzbyIAg==",
+      "cpu": [
+        "riscv64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-s390x-gnu": {
+      "version": "4.59.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-s390x-gnu/-/rollup-linux-s390x-gnu-4.59.0.tgz",
+      "integrity": "sha512-oF87Ie3uAIvORFBpwnCvUzdeYUqi2wY6jRFWJAy1qus/udHFYIkplYRW+wo+GRUP4sKzYdmE1Y3+rY5Gc4ZO+w==",
+      "cpu": [
+        "s390x"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-x64-gnu": {
+      "version": "4.59.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.59.0.tgz",
+      "integrity": "sha512-3AHmtQq/ppNuUspKAlvA8HtLybkDflkMuLK4DPo77DfthRb71V84/c4MlWJXixZz4uruIH4uaa07IqoAkG64fg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-x64-musl": {
+      "version": "4.59.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.59.0.tgz",
+      "integrity": "sha512-2UdiwS/9cTAx7qIUZB/fWtToJwvt0Vbo0zmnYt7ED35KPg13Q0ym1g442THLC7VyI6JfYTP4PiSOWyoMdV2/xg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-openbsd-x64": {
+      "version": "4.59.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-openbsd-x64/-/rollup-openbsd-x64-4.59.0.tgz",
+      "integrity": "sha512-M3bLRAVk6GOwFlPTIxVBSYKUaqfLrn8l0psKinkCFxl4lQvOSz8ZrKDz2gxcBwHFpci0B6rttydI4IpS4IS/jQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openbsd"
+      ]
+    },
+    "node_modules/@rollup/rollup-openharmony-arm64": {
+      "version": "4.59.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-openharmony-arm64/-/rollup-openharmony-arm64-4.59.0.tgz",
+      "integrity": "sha512-tt9KBJqaqp5i5HUZzoafHZX8b5Q2Fe7UjYERADll83O4fGqJ49O1FsL6LpdzVFQcpwvnyd0i+K/VSwu/o/nWlA==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openharmony"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-arm64-msvc": {
+      "version": "4.59.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-arm64-msvc/-/rollup-win32-arm64-msvc-4.59.0.tgz",
+      "integrity": "sha512-V5B6mG7OrGTwnxaNUzZTDTjDS7F75PO1ae6MJYdiMu60sq0CqN5CVeVsbhPxalupvTX8gXVSU9gq+Rx1/hvu6A==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-ia32-msvc": {
+      "version": "4.59.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-ia32-msvc/-/rollup-win32-ia32-msvc-4.59.0.tgz",
+      "integrity": "sha512-UKFMHPuM9R0iBegwzKF4y0C4J9u8C6MEJgFuXTBerMk7EJ92GFVFYBfOZaSGLu6COf7FxpQNqhNS4c4icUPqxA==",
+      "cpu": [
+        "ia32"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-x64-gnu": {
+      "version": "4.59.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-gnu/-/rollup-win32-x64-gnu-4.59.0.tgz",
+      "integrity": "sha512-laBkYlSS1n2L8fSo1thDNGrCTQMmxjYY5G0WFWjFFYZkKPjsMBsgJfGf4TLxXrF6RyhI60L8TMOjBMvXiTcxeA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-x64-msvc": {
+      "version": "4.59.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-msvc/-/rollup-win32-x64-msvc-4.59.0.tgz",
+      "integrity": "sha512-2HRCml6OztYXyJXAvdDXPKcawukWY2GpR5/nxKp4iBgiO3wcoEGkAaqctIbZcNB6KlUQBIqt8VYkNSj2397EfA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@sec-ant/readable-stream": {
+      "version": "0.4.1",
+      "resolved": "https://registry.npmjs.org/@sec-ant/readable-stream/-/readable-stream-0.4.1.tgz",
+      "integrity": "sha512-831qok9r2t8AlxLko40y2ebgSDhenenCatLVeW/uBtnHPyhHOvG0C7TvfgecV+wHzIm5KUICgzmVpWS+IMEAeg==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@shikijs/core": {
+      "version": "4.0.1",
+      "resolved": "https://registry.npmjs.org/@shikijs/core/-/core-4.0.1.tgz",
+      "integrity": "sha512-vWvqi9JNgz1dRL9Nvog5wtx7RuNkf7MEPl2mU/cyUUxJeH1CAr3t+81h8zO8zs7DK6cKLMoU9TvukWIDjP4Lzg==",
+      "license": "MIT",
+      "dependencies": {
+        "@shikijs/primitive": "4.0.1",
+        "@shikijs/types": "4.0.1",
+        "@shikijs/vscode-textmate": "^10.0.2",
+        "@types/hast": "^3.0.4",
+        "hast-util-to-html": "^9.0.5"
+      },
+      "engines": {
+        "node": ">=20"
+      }
+    },
+    "node_modules/@shikijs/engine-javascript": {
+      "version": "4.0.1",
+      "resolved": "https://registry.npmjs.org/@shikijs/engine-javascript/-/engine-javascript-4.0.1.tgz",
+      "integrity": "sha512-DJK9NiwtGYqMuKCRO4Ip0FKNDQpmaiS+K5bFjJ7DWFn4zHueDWgaUG8kAofkrnXF6zPPYYQY7J5FYVW9MbZyBg==",
+      "license": "MIT",
+      "dependencies": {
+        "@shikijs/types": "4.0.1",
+        "@shikijs/vscode-textmate": "^10.0.2",
+        "oniguruma-to-es": "^4.3.4"
+      },
+      "engines": {
+        "node": ">=20"
+      }
+    },
+    "node_modules/@shikijs/engine-oniguruma": {
+      "version": "4.0.1",
+      "resolved": "https://registry.npmjs.org/@shikijs/engine-oniguruma/-/engine-oniguruma-4.0.1.tgz",
+      "integrity": "sha512-oCWdCTDch3J8Kc0OZJ98KuUPC02O1VqIE3W/e2uvrHqTxYRR21RGEJMtchrgrxhsoJJCzmIciKsqG+q/yD+Cxg==",
+      "license": "MIT",
+      "dependencies": {
+        "@shikijs/types": "4.0.1",
+        "@shikijs/vscode-textmate": "^10.0.2"
+      },
+      "engines": {
+        "node": ">=20"
+      }
+    },
+    "node_modules/@shikijs/langs": {
+      "version": "4.0.1",
+      "resolved": "https://registry.npmjs.org/@shikijs/langs/-/langs-4.0.1.tgz",
+      "integrity": "sha512-v/mluaybWdnGJR4GqAR6zh8qAZohW9k+cGYT28Y7M8+jLbC0l4yG085O1A+WkseHTn+awd+P3UBymb2+MXFc8w==",
+      "license": "MIT",
+      "dependencies": {
+        "@shikijs/types": "4.0.1"
+      },
+      "engines": {
+        "node": ">=20"
+      }
+    },
+    "node_modules/@shikijs/primitive": {
+      "version": "4.0.1",
+      "resolved": "https://registry.npmjs.org/@shikijs/primitive/-/primitive-4.0.1.tgz",
+      "integrity": "sha512-ns0hHZc5eWZuvuIEJz2pTx3Qecz0aRVYumVQJ8JgWY2tq/dH8WxdcVM49Fc2NsHEILNIT6vfdW9MF26RANWiTA==",
+      "license": "MIT",
+      "dependencies": {
+        "@shikijs/types": "4.0.1",
+        "@shikijs/vscode-textmate": "^10.0.2",
+        "@types/hast": "^3.0.4"
+      },
+      "engines": {
+        "node": ">=20"
+      }
+    },
+    "node_modules/@shikijs/themes": {
+      "version": "4.0.1",
+      "resolved": "https://registry.npmjs.org/@shikijs/themes/-/themes-4.0.1.tgz",
+      "integrity": "sha512-FW41C/D6j/yKQkzVdjrRPiJCtgeDaYRJFEyCKFCINuRJRj9WcmubhP4KQHPZ4+9eT87jruSrYPyoblNRyDFzvA==",
+      "license": "MIT",
+      "dependencies": {
+        "@shikijs/types": "4.0.1"
+      },
+      "engines": {
+        "node": ">=20"
+      }
+    },
+    "node_modules/@shikijs/types": {
+      "version": "4.0.1",
+      "resolved": "https://registry.npmjs.org/@shikijs/types/-/types-4.0.1.tgz",
+      "integrity": "sha512-EaygPEn57+jJ76mw+nTLvIpJMAcMPokFbrF8lufsZP7Ukk+ToJYEcswN1G0e49nUZAq7aCQtoeW219A8HK1ZOw==",
+      "license": "MIT",
+      "dependencies": {
+        "@shikijs/vscode-textmate": "^10.0.2",
+        "@types/hast": "^3.0.4"
+      },
+      "engines": {
+        "node": ">=20"
+      }
+    },
+    "node_modules/@shikijs/vscode-textmate": {
+      "version": "10.0.2",
+      "resolved": "https://registry.npmjs.org/@shikijs/vscode-textmate/-/vscode-textmate-10.0.2.tgz",
+      "integrity": "sha512-83yeghZ2xxin3Nj8z1NMd/NCuca+gsYXswywDy5bHvwlWL8tpTQmzGeUuHd9FC3E/SBEMvzJRwWEOz5gGes9Qg==",
+      "license": "MIT"
+    },
+    "node_modules/@sinclair/typebox": {
+      "version": "0.34.48",
+      "resolved": "https://registry.npmjs.org/@sinclair/typebox/-/typebox-0.34.48.tgz",
+      "integrity": "sha512-kKJTNuK3AQOrgjjotVxMrCn1sUJwM76wMszfq1kdU4uYVJjvEWuFQ6HgvLt4Xz3fSmZlTOxJ/Ie13KnIcWQXFA==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@sindresorhus/merge-streams": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/@sindresorhus/merge-streams/-/merge-streams-4.0.0.tgz",
+      "integrity": "sha512-tlqY9xq5ukxTUZBmoOp+m61cqwQD5pHJtFY3Mn8CA8ps6yghLH/Hw8UPdqg4OLmFW3IFlcXnQNmo/dh8HzXYIQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/@standard-schema/spec": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/@standard-schema/spec/-/spec-1.1.0.tgz",
+      "integrity": "sha512-l2aFy5jALhniG5HgqrD6jXLi/rUWrKvqN/qJx6yoJsgKhblVd+iqqU4RCXavm/jPityDo5TCvKMnpjKnOriy0w==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@sveltejs/acorn-typescript": {
+      "version": "1.0.9",
+      "resolved": "https://registry.npmjs.org/@sveltejs/acorn-typescript/-/acorn-typescript-1.0.9.tgz",
+      "integrity": "sha512-lVJX6qEgs/4DOcRTpo56tmKzVPtoWAaVbL4hfO7t7NVwl9AAXzQR6cihesW1BmNMPl+bK6dreu2sOKBP2Q9CIA==",
+      "dev": true,
+      "license": "MIT",
+      "peerDependencies": {
+        "acorn": "^8.9.0"
+      }
+    },
+    "node_modules/@sveltejs/vite-plugin-svelte": {
+      "version": "6.2.4",
+      "resolved": "https://registry.npmjs.org/@sveltejs/vite-plugin-svelte/-/vite-plugin-svelte-6.2.4.tgz",
+      "integrity": "sha512-ou/d51QSdTyN26D7h6dSpusAKaZkAiGM55/AKYi+9AGZw7q85hElbjK3kEyzXHhLSnRISHOYzVge6x0jRZ7DXA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@sveltejs/vite-plugin-svelte-inspector": "^5.0.0",
+        "deepmerge": "^4.3.1",
+        "magic-string": "^0.30.21",
+        "obug": "^2.1.0",
+        "vitefu": "^1.1.1"
+      },
+      "engines": {
+        "node": "^20.19 || ^22.12 || >=24"
+      },
+      "peerDependencies": {
+        "svelte": "^5.0.0",
+        "vite": "^6.3.0 || ^7.0.0"
+      }
+    },
+    "node_modules/@sveltejs/vite-plugin-svelte-inspector": {
+      "version": "5.0.2",
+      "resolved": "https://registry.npmjs.org/@sveltejs/vite-plugin-svelte-inspector/-/vite-plugin-svelte-inspector-5.0.2.tgz",
+      "integrity": "sha512-TZzRTcEtZffICSAoZGkPSl6Etsj2torOVrx6Uw0KpXxrec9Gg6jFWQ60Q3+LmNGfZSxHRCZL7vXVZIWmuV50Ig==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "obug": "^2.1.0"
+      },
+      "engines": {
+        "node": "^20.19 || ^22.12 || >=24"
+      },
+      "peerDependencies": {
+        "@sveltejs/vite-plugin-svelte": "^6.0.0-next.0",
+        "svelte": "^5.0.0",
+        "vite": "^6.3.0 || ^7.0.0"
+      }
+    },
+    "node_modules/@tauri-apps/api": {
+      "version": "2.10.1",
+      "resolved": "https://registry.npmjs.org/@tauri-apps/api/-/api-2.10.1.tgz",
+      "integrity": "sha512-hKL/jWf293UDSUN09rR69hrToyIXBb8CjGaWC7gfinvnQrBVvnLr08FeFi38gxtugAVyVcTa5/FD/Xnkb1siBw==",
+      "license": "Apache-2.0 OR MIT",
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/tauri"
+      }
+    },
+    "node_modules/@tauri-apps/plugin-dialog": {
+      "version": "2.6.0",
+      "resolved": "https://registry.npmjs.org/@tauri-apps/plugin-dialog/-/plugin-dialog-2.6.0.tgz",
+      "integrity": "sha512-q4Uq3eY87TdcYzXACiYSPhmpBA76shgmQswGkSVio4C82Sz2W4iehe9TnKYwbq7weHiL88Yw19XZm7v28+Micg==",
+      "license": "MIT OR Apache-2.0",
+      "dependencies": {
+        "@tauri-apps/api": "^2.8.0"
+      }
+    },
+    "node_modules/@tauri-apps/plugin-updater": {
+      "version": "2.10.0",
+      "resolved": "https://registry.npmjs.org/@tauri-apps/plugin-updater/-/plugin-updater-2.10.0.tgz",
+      "integrity": "sha512-ljN8jPlnT0aSn8ecYhuBib84alxfMx6Hc8vJSKMJyzGbTPFZAC44T2I1QNFZssgWKrAlofvJqCC6Rr472JWfkQ==",
+      "license": "MIT OR Apache-2.0",
+      "dependencies": {
+        "@tauri-apps/api": "^2.10.1"
+      }
+    },
+    "node_modules/@tootallnate/quickjs-emscripten": {
+      "version": "0.23.0",
+      "resolved": "https://registry.npmjs.org/@tootallnate/quickjs-emscripten/-/quickjs-emscripten-0.23.0.tgz",
+      "integrity": "sha512-C5Mc6rdnsaJDjO3UpGW/CQTHtCKaYlScZTly4JIu97Jxo/odCiH0ITnDXSJPTOrEKk/ycSZ0AOgTmkDtkOsvIA==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@tsconfig/svelte": {
+      "version": "5.0.8",
+      "resolved": "https://registry.npmjs.org/@tsconfig/svelte/-/svelte-5.0.8.tgz",
+      "integrity": "sha512-UkNnw1/oFEfecR8ypyHIQuWYdkPvHiwcQ78sh+ymIiYoF+uc5H1UBetbjyqT+vgGJ3qQN6nhucJviX6HesWtKQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@types/chai": {
+      "version": "5.2.3",
+      "resolved": "https://registry.npmjs.org/@types/chai/-/chai-5.2.3.tgz",
+      "integrity": "sha512-Mw558oeA9fFbv65/y4mHtXDs9bPnFMZAL/jxdPFUpOHHIXX91mcgEHbS5Lahr+pwZFR8A7GQleRWeI6cGFC2UA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/deep-eql": "*",
+        "assertion-error": "^2.0.1"
+      }
+    },
+    "node_modules/@types/deep-eql": {
+      "version": "4.0.2",
+      "resolved": "https://registry.npmjs.org/@types/deep-eql/-/deep-eql-4.0.2.tgz",
+      "integrity": "sha512-c9h9dVVMigMPc4bwTvC5dxqtqJZwQPePsWjPlpSOnojbor6pGqdk541lfA7AqFQr5pB1BRdq0juY9db81BwyFw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@types/estree": {
+      "version": "1.0.8",
+      "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.8.tgz",
+      "integrity": "sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@types/hast": {
+      "version": "3.0.4",
+      "resolved": "https://registry.npmjs.org/@types/hast/-/hast-3.0.4.tgz",
+      "integrity": "sha512-WPs+bbQw5aCj+x6laNGWLH3wviHtoCv/P3+otBhbOhJgG8qtpdAMlTCxLtsTWA7LH1Oh/bFCHsBn0TPS5m30EQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/unist": "*"
+      }
+    },
+    "node_modules/@types/istanbul-lib-coverage": {
+      "version": "2.0.6",
+      "resolved": "https://registry.npmjs.org/@types/istanbul-lib-coverage/-/istanbul-lib-coverage-2.0.6.tgz",
+      "integrity": "sha512-2QF/t/auWm0lsy8XtKVPG19v3sSOQlJe/YHZgfjb/KBBHOGSV+J2q/S671rcq9uTBrLAXmZpqJiaQbMT+zNU1w==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@types/istanbul-lib-report": {
+      "version": "3.0.3",
+      "resolved": "https://registry.npmjs.org/@types/istanbul-lib-report/-/istanbul-lib-report-3.0.3.tgz",
+      "integrity": "sha512-NQn7AHQnk/RSLOxrBbGyJM/aVQ+pjj5HCgasFxc0K/KhoATfQ/47AyUl15I2yBUpihjmas+a+VJBOqecrFH+uA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/istanbul-lib-coverage": "*"
+      }
+    },
+    "node_modules/@types/istanbul-reports": {
+      "version": "3.0.4",
+      "resolved": "https://registry.npmjs.org/@types/istanbul-reports/-/istanbul-reports-3.0.4.tgz",
+      "integrity": "sha512-pk2B1NWalF9toCRu6gjBzR69syFjP4Od8WRAX+0mmf9lAjCRicLOWc+ZrxZHx/0XRjotgkF9t6iaMJ+aXcOdZQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/istanbul-lib-report": "*"
+      }
+    },
+    "node_modules/@types/mdast": {
+      "version": "4.0.4",
+      "resolved": "https://registry.npmjs.org/@types/mdast/-/mdast-4.0.4.tgz",
+      "integrity": "sha512-kGaNbPh1k7AFzgpud/gMdvIm5xuECykRR+JnWKQno9TAXVa6WIVCGTPvYGekIDL4uwCZQSYbUxNBSb1aUo79oA==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/unist": "*"
+      }
+    },
+    "node_modules/@types/mocha": {
+      "version": "10.0.10",
+      "resolved": "https://registry.npmjs.org/@types/mocha/-/mocha-10.0.10.tgz",
+      "integrity": "sha512-xPyYSz1cMPnJQhl0CLMH68j3gprKZaTjG3s5Vi+fDgx+uhG9NOXwbVt52eFS8ECyXhyKcjDLCBEqBExKuiZb7Q==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@types/node": {
+      "version": "24.11.0",
+      "resolved": "https://registry.npmjs.org/@types/node/-/node-24.11.0.tgz",
+      "integrity": "sha512-fPxQqz4VTgPI/IQ+lj9r0h+fDR66bzoeMGHp8ASee+32OSGIkeASsoZuJixsQoVef1QJbeubcPBxKk22QVoWdw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "undici-types": "~7.16.0"
+      }
+    },
+    "node_modules/@types/normalize-package-data": {
+      "version": "2.4.4",
+      "resolved": "https://registry.npmjs.org/@types/normalize-package-data/-/normalize-package-data-2.4.4.tgz",
+      "integrity": "sha512-37i+OaWTh9qeK4LSHPsyRC7NahnGotNuZvjLSgcPzblpHB3rrCJxAOgI5gCdKm7coonsaX1Of0ILiTcnZjbfxA==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@types/sinonjs__fake-timers": {
+      "version": "8.1.5",
+      "resolved": "https://registry.npmjs.org/@types/sinonjs__fake-timers/-/sinonjs__fake-timers-8.1.5.tgz",
+      "integrity": "sha512-mQkU2jY8jJEF7YHjHvsQO8+3ughTL1mcnn96igfhONmR+fUPSKIkefQYpSe8bsly2Ep7oQbn/6VG5/9/0qcArQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@types/stack-utils": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/@types/stack-utils/-/stack-utils-2.0.3.tgz",
+      "integrity": "sha512-9aEbYZ3TbYMznPdcdr3SmIrLXwC/AKZXQeCf9Pgao5CKb8CyHuEX5jzWPTkvregvhRJHcpRO6BFoGW9ycaOkYw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@types/trusted-types": {
+      "version": "2.0.7",
+      "resolved": "https://registry.npmjs.org/@types/trusted-types/-/trusted-types-2.0.7.tgz",
+      "integrity": "sha512-ScaPdn1dQczgbl0QFTeTOmVHFULt394XJgOQNoyVhZ6r2vLnMLJfBPd53SB52T/3G36VI1/g2MZaX0cwDuXsfw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@types/unist": {
+      "version": "3.0.3",
+      "resolved": "https://registry.npmjs.org/@types/unist/-/unist-3.0.3.tgz",
+      "integrity": "sha512-ko/gIFJRv177XgZsZcBwnqJN5x/Gien8qNOn0D5bQU/zAzVf9Zt3BlcUiLqhV9y4ARk0GbT3tnUiPNgnTXzc/Q==",
+      "license": "MIT"
+    },
+    "node_modules/@types/which": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/@types/which/-/which-2.0.2.tgz",
+      "integrity": "sha512-113D3mDkZDjo+EeUEHCFy0qniNc1ZpecGiAU7WSo7YDoSzolZIQKpYFHrPpjkB2nuyahcKfrmLXeQlh7gqJYdw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@types/ws": {
+      "version": "8.18.1",
+      "resolved": "https://registry.npmjs.org/@types/ws/-/ws-8.18.1.tgz",
+      "integrity": "sha512-ThVF6DCVhA8kUGy+aazFQ4kXQ7E1Ty7A3ypFOe0IcJV8O/M511G99AW24irKrW56Wt44yG9+ij8FaqoBGkuBXg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/node": "*"
+      }
+    },
+    "node_modules/@types/yargs": {
+      "version": "17.0.35",
+      "resolved": "https://registry.npmjs.org/@types/yargs/-/yargs-17.0.35.tgz",
+      "integrity": "sha512-qUHkeCyQFxMXg79wQfTtfndEC+N9ZZg76HJftDJp+qH2tV7Gj4OJi7l+PiWwJ+pWtW8GwSmqsDj/oymhrTWXjg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/yargs-parser": "*"
+      }
+    },
+    "node_modules/@types/yargs-parser": {
+      "version": "21.0.3",
+      "resolved": "https://registry.npmjs.org/@types/yargs-parser/-/yargs-parser-21.0.3.tgz",
+      "integrity": "sha512-I4q9QU9MQv4oEOz4tAHJtNz1cwuLxn2F3xcc2iV5WdqLPpUnj30aUuxt1mAxYTG+oe8CZMV/+6rU4S4gRDzqtQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@types/yauzl": {
+      "version": "2.10.3",
+      "resolved": "https://registry.npmjs.org/@types/yauzl/-/yauzl-2.10.3.tgz",
+      "integrity": "sha512-oJoftv0LSuaDZE3Le4DbKX+KS9G36NzOeSap90UIK0yMA/NhKJhqlSGtNDORNRaIbQfzjXDrQa0ytJ6mNRGz/Q==",
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "@types/node": "*"
+      }
+    },
+    "node_modules/@ungap/structured-clone": {
+      "version": "1.3.0",
+      "resolved": "https://registry.npmjs.org/@ungap/structured-clone/-/structured-clone-1.3.0.tgz",
+      "integrity": "sha512-WmoN8qaIAo7WTYWbAZuG8PYEhn5fkz7dZrqTBZ7dtt//lL2Gwms1IcnQ5yHqjDfX8Ft5j4YzDM23f87zBfDe9g==",
+      "license": "ISC"
+    },
+    "node_modules/@vitest/expect": {
+      "version": "4.0.18",
+      "resolved": "https://registry.npmjs.org/@vitest/expect/-/expect-4.0.18.tgz",
+      "integrity": "sha512-8sCWUyckXXYvx4opfzVY03EOiYVxyNrHS5QxX3DAIi5dpJAAkyJezHCP77VMX4HKA2LDT/Jpfo8i2r5BE3GnQQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@standard-schema/spec": "^1.0.0",
+        "@types/chai": "^5.2.2",
+        "@vitest/spy": "4.0.18",
+        "@vitest/utils": "4.0.18",
+        "chai": "^6.2.1",
+        "tinyrainbow": "^3.0.3"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      }
+    },
+    "node_modules/@vitest/mocker": {
+      "version": "4.0.18",
+      "resolved": "https://registry.npmjs.org/@vitest/mocker/-/mocker-4.0.18.tgz",
+      "integrity": "sha512-HhVd0MDnzzsgevnOWCBj5Otnzobjy5wLBe4EdeeFGv8luMsGcYqDuFRMcttKWZA5vVO8RFjexVovXvAM4JoJDQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@vitest/spy": "4.0.18",
+        "estree-walker": "^3.0.3",
+        "magic-string": "^0.30.21"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      },
+      "peerDependencies": {
+        "msw": "^2.4.9",
+        "vite": "^6.0.0 || ^7.0.0-0"
+      },
+      "peerDependenciesMeta": {
+        "msw": {
+          "optional": true
+        },
+        "vite": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@vitest/pretty-format": {
+      "version": "4.0.18",
+      "resolved": "https://registry.npmjs.org/@vitest/pretty-format/-/pretty-format-4.0.18.tgz",
+      "integrity": "sha512-P24GK3GulZWC5tz87ux0m8OADrQIUVDPIjjj65vBXYG17ZeU3qD7r+MNZ1RNv4l8CGU2vtTRqixrOi9fYk/yKw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "tinyrainbow": "^3.0.3"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      }
+    },
+    "node_modules/@vitest/runner": {
+      "version": "4.0.18",
+      "resolved": "https://registry.npmjs.org/@vitest/runner/-/runner-4.0.18.tgz",
+      "integrity": "sha512-rpk9y12PGa22Jg6g5M3UVVnTS7+zycIGk9ZNGN+m6tZHKQb7jrP7/77WfZy13Y/EUDd52NDsLRQhYKtv7XfPQw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@vitest/utils": "4.0.18",
+        "pathe": "^2.0.3"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      }
+    },
+    "node_modules/@vitest/snapshot": {
+      "version": "4.0.18",
+      "resolved": "https://registry.npmjs.org/@vitest/snapshot/-/snapshot-4.0.18.tgz",
+      "integrity": "sha512-PCiV0rcl7jKQjbgYqjtakly6T1uwv/5BQ9SwBLekVg/EaYeQFPiXcgrC2Y7vDMA8dM1SUEAEV82kgSQIlXNMvA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@vitest/pretty-format": "4.0.18",
+        "magic-string": "^0.30.21",
+        "pathe": "^2.0.3"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      }
+    },
+    "node_modules/@vitest/spy": {
+      "version": "4.0.18",
+      "resolved": "https://registry.npmjs.org/@vitest/spy/-/spy-4.0.18.tgz",
+      "integrity": "sha512-cbQt3PTSD7P2OARdVW3qWER5EGq7PHlvE+QfzSC0lbwO+xnt7+XH06ZzFjFRgzUX//JmpxrCu92VdwvEPlWSNw==",
+      "dev": true,
+      "license": "MIT",
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      }
+    },
+    "node_modules/@vitest/utils": {
+      "version": "4.0.18",
+      "resolved": "https://registry.npmjs.org/@vitest/utils/-/utils-4.0.18.tgz",
+      "integrity": "sha512-msMRKLMVLWygpK3u2Hybgi4MNjcYJvwTb0Ru09+fOyCXIgT5raYP041DRRdiJiI3k/2U6SEbAETB3YtBrUkCFA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@vitest/pretty-format": "4.0.18",
+        "tinyrainbow": "^3.0.3"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      }
+    },
+    "node_modules/@wdio/cli": {
+      "version": "9.24.0",
+      "resolved": "https://registry.npmjs.org/@wdio/cli/-/cli-9.24.0.tgz",
+      "integrity": "sha512-dFs1HNmyXne0pDOYPOHhFcck0BC22z0lMdu6RtTX1C4gHdEYsjTtTH2zsZ5N5BzzsZVSUol2PisuqyLQO5dZIA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@vitest/snapshot": "^2.1.1",
+        "@wdio/config": "9.24.0",
+        "@wdio/globals": "9.23.0",
+        "@wdio/logger": "9.18.0",
+        "@wdio/protocols": "9.24.0",
+        "@wdio/types": "9.24.0",
+        "@wdio/utils": "9.24.0",
+        "async-exit-hook": "^2.0.1",
+        "chalk": "^5.4.1",
+        "chokidar": "^4.0.0",
+        "create-wdio": "9.21.0",
+        "dotenv": "^17.2.0",
+        "import-meta-resolve": "^4.0.0",
+        "lodash.flattendeep": "^4.4.0",
+        "lodash.pickby": "^4.6.0",
+        "lodash.union": "^4.6.0",
+        "read-pkg-up": "^10.0.0",
+        "tsx": "^4.7.2",
+        "webdriverio": "9.24.0",
+        "yargs": "^17.7.2"
+      },
+      "bin": {
+        "wdio": "bin/wdio.js"
+      },
+      "engines": {
+        "node": ">=18.20.0"
+      }
+    },
+    "node_modules/@wdio/cli/node_modules/@vitest/pretty-format": {
+      "version": "2.1.9",
+      "resolved": "https://registry.npmjs.org/@vitest/pretty-format/-/pretty-format-2.1.9.tgz",
+      "integrity": "sha512-KhRIdGV2U9HOUzxfiHmY8IFHTdqtOhIzCpd8WRdJiE7D/HUcZVD0EgQCVjm+Q9gkUXWgBvMmTtZgIG48wq7sOQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "tinyrainbow": "^1.2.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      }
+    },
+    "node_modules/@wdio/cli/node_modules/@vitest/snapshot": {
+      "version": "2.1.9",
+      "resolved": "https://registry.npmjs.org/@vitest/snapshot/-/snapshot-2.1.9.tgz",
+      "integrity": "sha512-oBO82rEjsxLNJincVhLhaxxZdEtV0EFHMK5Kmx5sJ6H9L183dHECjiefOAdnqpIgT5eZwT04PoggUnW88vOBNQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@vitest/pretty-format": "2.1.9",
+        "magic-string": "^0.30.12",
+        "pathe": "^1.1.2"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      }
+    },
+    "node_modules/@wdio/cli/node_modules/pathe": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/pathe/-/pathe-1.1.2.tgz",
+      "integrity": "sha512-whLdWMYL2TwI08hn8/ZqAbrVemu0LNaNNJZX73O6qaIdCTfXutsLhMkjdENX0qhsQ9uIimo4/aQOmXkoon2nDQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@wdio/cli/node_modules/tinyrainbow": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/tinyrainbow/-/tinyrainbow-1.2.0.tgz",
+      "integrity": "sha512-weEDEq7Z5eTHPDh4xjX789+fHfF+P8boiFB+0vbWzpbnbsEr/GRaohi/uMKxg8RZMXnl1ItAi/IUHWMsjDV7kQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=14.0.0"
+      }
+    },
+    "node_modules/@wdio/config": {
+      "version": "9.24.0",
+      "resolved": "https://registry.npmjs.org/@wdio/config/-/config-9.24.0.tgz",
+      "integrity": "sha512-rcHu0eG16rSEmHL0sEKDcr/vYFmGhQ5GOlmlx54r+1sgh6sf136q+kth4169s16XqviWGW3LjZbUfpTK29pGtw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@wdio/logger": "9.18.0",
+        "@wdio/types": "9.24.0",
+        "@wdio/utils": "9.24.0",
+        "deepmerge-ts": "^7.0.3",
+        "glob": "^10.2.2",
+        "import-meta-resolve": "^4.0.0",
+        "jiti": "^2.6.1"
+      },
+      "engines": {
+        "node": ">=18.20.0"
+      }
+    },
+    "node_modules/@wdio/dot-reporter": {
+      "version": "9.24.0",
+      "resolved": "https://registry.npmjs.org/@wdio/dot-reporter/-/dot-reporter-9.24.0.tgz",
+      "integrity": "sha512-hZNXnY4EVnDRTedGSlkWQL6sPkxe1zgRzTaam+S7GduF+IOTQXHIsuklfpHLs6mrj3oS+JuKbosodsyvLU7KQA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@wdio/reporter": "9.24.0",
+        "@wdio/types": "9.24.0",
+        "chalk": "^5.0.1"
+      },
+      "engines": {
+        "node": ">=18.20.0"
+      }
+    },
+    "node_modules/@wdio/globals": {
+      "version": "9.23.0",
+      "resolved": "https://registry.npmjs.org/@wdio/globals/-/globals-9.23.0.tgz",
+      "integrity": "sha512-OmwPKV8c5ecLqo+EkytN7oUeYfNmRI4uOXGIR1ybP7AK5Zz+l9R0dGfoadEuwi1aZXAL0vwuhtq3p0OL3dfqHQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=18.20.0"
+      },
+      "peerDependencies": {
+        "expect-webdriverio": "^5.3.4",
+        "webdriverio": "^9.0.0"
+      },
+      "peerDependenciesMeta": {
+        "expect-webdriverio": {
+          "optional": false
+        },
+        "webdriverio": {
+          "optional": false
+        }
+      }
+    },
+    "node_modules/@wdio/local-runner": {
+      "version": "9.24.0",
+      "resolved": "https://registry.npmjs.org/@wdio/local-runner/-/local-runner-9.24.0.tgz",
+      "integrity": "sha512-SUs5HEGHXEl/fVdkkhY1+of+Dv8AlceulRTpmYMmSR4Nu+tHUXSPkzjoYgVa+xVu0MpVrD+dhTm13hOtlDAlMg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/node": "^20.1.0",
+        "@wdio/logger": "9.18.0",
+        "@wdio/repl": "9.16.2",
+        "@wdio/runner": "9.24.0",
+        "@wdio/types": "9.24.0",
+        "@wdio/xvfb": "9.24.0",
+        "exit-hook": "^4.0.0",
+        "expect-webdriverio": "^5.3.4",
+        "split2": "^4.1.0",
+        "stream-buffers": "^3.0.2"
+      },
+      "engines": {
+        "node": ">=18.20.0"
+      }
+    },
+    "node_modules/@wdio/local-runner/node_modules/@types/node": {
+      "version": "20.19.37",
+      "resolved": "https://registry.npmjs.org/@types/node/-/node-20.19.37.tgz",
+      "integrity": "sha512-8kzdPJ3FsNsVIurqBs7oodNnCEVbni9yUEkaHbgptDACOPW04jimGagZ51E6+lXUwJjgnBw+hyko/lkFWCldqw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "undici-types": "~6.21.0"
+      }
+    },
+    "node_modules/@wdio/local-runner/node_modules/undici-types": {
+      "version": "6.21.0",
+      "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-6.21.0.tgz",
+      "integrity": "sha512-iwDZqg0QAGrg9Rav5H4n0M64c3mkR59cJ6wQp+7C4nI0gsmExaedaYLNO44eT4AtBBwjbTiGPMlt2Md0T9H9JQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@wdio/logger": {
+      "version": "9.18.0",
+      "resolved": "https://registry.npmjs.org/@wdio/logger/-/logger-9.18.0.tgz",
+      "integrity": "sha512-HdzDrRs+ywAqbXGKqe1i/bLtCv47plz4TvsHFH3j729OooT5VH38ctFn5aLXgECmiAKDkmH/A6kOq2Zh5DIxww==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "chalk": "^5.1.2",
+        "loglevel": "^1.6.0",
+        "loglevel-plugin-prefix": "^0.8.4",
+        "safe-regex2": "^5.0.0",
+        "strip-ansi": "^7.1.0"
+      },
+      "engines": {
+        "node": ">=18.20.0"
+      }
+    },
+    "node_modules/@wdio/mocha-framework": {
+      "version": "9.24.0",
+      "resolved": "https://registry.npmjs.org/@wdio/mocha-framework/-/mocha-framework-9.24.0.tgz",
+      "integrity": "sha512-zzTfFk79Zx3qZgfbgpJ7o0euzgXIQSCzbfFPjgtEx8u7fvrhB8tbgf+EGPOEGPBOH/X1GvpAfDkhkgZ6roDR2Q==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/mocha": "^10.0.6",
+        "@types/node": "^20.11.28",
+        "@wdio/logger": "9.18.0",
+        "@wdio/types": "9.24.0",
+        "@wdio/utils": "9.24.0",
+        "mocha": "^10.3.0"
+      },
+      "engines": {
+        "node": ">=18.20.0"
+      }
+    },
+    "node_modules/@wdio/mocha-framework/node_modules/@types/node": {
+      "version": "20.19.37",
+      "resolved": "https://registry.npmjs.org/@types/node/-/node-20.19.37.tgz",
+      "integrity": "sha512-8kzdPJ3FsNsVIurqBs7oodNnCEVbni9yUEkaHbgptDACOPW04jimGagZ51E6+lXUwJjgnBw+hyko/lkFWCldqw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "undici-types": "~6.21.0"
+      }
+    },
+    "node_modules/@wdio/mocha-framework/node_modules/undici-types": {
+      "version": "6.21.0",
+      "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-6.21.0.tgz",
+      "integrity": "sha512-iwDZqg0QAGrg9Rav5H4n0M64c3mkR59cJ6wQp+7C4nI0gsmExaedaYLNO44eT4AtBBwjbTiGPMlt2Md0T9H9JQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@wdio/protocols": {
+      "version": "9.24.0",
+      "resolved": "https://registry.npmjs.org/@wdio/protocols/-/protocols-9.24.0.tgz",
+      "integrity": "sha512-ozQKYddBLT4TRvU9J+fGrhVUtx3iDAe+KNCJcTDMFMxNSdDMR2xFQdNp8HLHypspk58oXTYCvz6ZYjySthhqsw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@wdio/repl": {
+      "version": "9.16.2",
+      "resolved": "https://registry.npmjs.org/@wdio/repl/-/repl-9.16.2.tgz",
+      "integrity": "sha512-FLTF0VL6+o5BSTCO7yLSXocm3kUnu31zYwzdsz4n9s5YWt83sCtzGZlZpt7TaTzb3jVUfxuHNQDTb8UMkCu0lQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/node": "^20.1.0"
+      },
+      "engines": {
+        "node": ">=18.20.0"
+      }
+    },
+    "node_modules/@wdio/repl/node_modules/@types/node": {
+      "version": "20.19.37",
+      "resolved": "https://registry.npmjs.org/@types/node/-/node-20.19.37.tgz",
+      "integrity": "sha512-8kzdPJ3FsNsVIurqBs7oodNnCEVbni9yUEkaHbgptDACOPW04jimGagZ51E6+lXUwJjgnBw+hyko/lkFWCldqw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "undici-types": "~6.21.0"
+      }
+    },
+    "node_modules/@wdio/repl/node_modules/undici-types": {
+      "version": "6.21.0",
+      "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-6.21.0.tgz",
+      "integrity": "sha512-iwDZqg0QAGrg9Rav5H4n0M64c3mkR59cJ6wQp+7C4nI0gsmExaedaYLNO44eT4AtBBwjbTiGPMlt2Md0T9H9JQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@wdio/reporter": {
+      "version": "9.24.0",
+      "resolved": "https://registry.npmjs.org/@wdio/reporter/-/reporter-9.24.0.tgz",
+      "integrity": "sha512-0VrEX2uzjrFCHb6fNQDrQe6X7xuQbXUJhy5CGhMZghnPegW0OnKguwUy/vVKJE0HEDMOrR8djteefxJVfOOZpw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/node": "^20.1.0",
+        "@wdio/logger": "9.18.0",
+        "@wdio/types": "9.24.0",
+        "diff": "^8.0.2",
+        "object-inspect": "^1.12.0"
+      },
+      "engines": {
+        "node": ">=18.20.0"
+      }
+    },
+    "node_modules/@wdio/reporter/node_modules/@types/node": {
+      "version": "20.19.37",
+      "resolved": "https://registry.npmjs.org/@types/node/-/node-20.19.37.tgz",
+      "integrity": "sha512-8kzdPJ3FsNsVIurqBs7oodNnCEVbni9yUEkaHbgptDACOPW04jimGagZ51E6+lXUwJjgnBw+hyko/lkFWCldqw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "undici-types": "~6.21.0"
+      }
+    },
+    "node_modules/@wdio/reporter/node_modules/undici-types": {
+      "version": "6.21.0",
+      "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-6.21.0.tgz",
+      "integrity": "sha512-iwDZqg0QAGrg9Rav5H4n0M64c3mkR59cJ6wQp+7C4nI0gsmExaedaYLNO44eT4AtBBwjbTiGPMlt2Md0T9H9JQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@wdio/runner": {
+      "version": "9.24.0",
+      "resolved": "https://registry.npmjs.org/@wdio/runner/-/runner-9.24.0.tgz",
+      "integrity": "sha512-B1ezRtvR/eJCKQSVyLbERpyyMG3bP7RKaQBHT7bNxGsuEuarkUU7cS/T/aB+woZb4UtWotlrBFY4icAS0HqOkA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/node": "^20.11.28",
+        "@wdio/config": "9.24.0",
+        "@wdio/dot-reporter": "9.24.0",
+        "@wdio/globals": "9.23.0",
+        "@wdio/logger": "9.18.0",
+        "@wdio/types": "9.24.0",
+        "@wdio/utils": "9.24.0",
+        "deepmerge-ts": "^7.0.3",
+        "webdriver": "9.24.0",
+        "webdriverio": "9.24.0"
+      },
+      "engines": {
+        "node": ">=18.20.0"
+      },
+      "peerDependencies": {
+        "expect-webdriverio": "^5.3.4",
+        "webdriverio": "^9.0.0"
+      },
+      "peerDependenciesMeta": {
+        "expect-webdriverio": {
+          "optional": false
+        },
+        "webdriverio": {
+          "optional": false
+        }
+      }
+    },
+    "node_modules/@wdio/runner/node_modules/@types/node": {
+      "version": "20.19.37",
+      "resolved": "https://registry.npmjs.org/@types/node/-/node-20.19.37.tgz",
+      "integrity": "sha512-8kzdPJ3FsNsVIurqBs7oodNnCEVbni9yUEkaHbgptDACOPW04jimGagZ51E6+lXUwJjgnBw+hyko/lkFWCldqw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "undici-types": "~6.21.0"
+      }
+    },
+    "node_modules/@wdio/runner/node_modules/undici-types": {
+      "version": "6.21.0",
+      "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-6.21.0.tgz",
+      "integrity": "sha512-iwDZqg0QAGrg9Rav5H4n0M64c3mkR59cJ6wQp+7C4nI0gsmExaedaYLNO44eT4AtBBwjbTiGPMlt2Md0T9H9JQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@wdio/spec-reporter": {
+      "version": "9.24.0",
+      "resolved": "https://registry.npmjs.org/@wdio/spec-reporter/-/spec-reporter-9.24.0.tgz",
+      "integrity": "sha512-I3HExQKvF5u+RUcwImk9JMiuBgo2MmuKDj3Y0oSRwSw0TxQX0nqVvt8udlVG6XJpOD+e4EqlCGWbFfMezi8iTA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@wdio/reporter": "9.24.0",
+        "@wdio/types": "9.24.0",
+        "chalk": "^5.1.2",
+        "easy-table": "^1.2.0",
+        "pretty-ms": "^9.0.0"
+      },
+      "engines": {
+        "node": ">=18.20.0"
+      }
+    },
+    "node_modules/@wdio/types": {
+      "version": "9.24.0",
+      "resolved": "https://registry.npmjs.org/@wdio/types/-/types-9.24.0.tgz",
+      "integrity": "sha512-PYYunNl8Uq1r8YMJAK6ReRy/V/XIrCSyj5cpCtR5EqCL6heETOORFj7gt4uPnzidfgbtMBcCru0LgjjlMiH1UQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/node": "^20.1.0"
+      },
+      "engines": {
+        "node": ">=18.20.0"
+      }
+    },
+    "node_modules/@wdio/types/node_modules/@types/node": {
+      "version": "20.19.37",
+      "resolved": "https://registry.npmjs.org/@types/node/-/node-20.19.37.tgz",
+      "integrity": "sha512-8kzdPJ3FsNsVIurqBs7oodNnCEVbni9yUEkaHbgptDACOPW04jimGagZ51E6+lXUwJjgnBw+hyko/lkFWCldqw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "undici-types": "~6.21.0"
+      }
+    },
+    "node_modules/@wdio/types/node_modules/undici-types": {
+      "version": "6.21.0",
+      "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-6.21.0.tgz",
+      "integrity": "sha512-iwDZqg0QAGrg9Rav5H4n0M64c3mkR59cJ6wQp+7C4nI0gsmExaedaYLNO44eT4AtBBwjbTiGPMlt2Md0T9H9JQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@wdio/utils": {
+      "version": "9.24.0",
+      "resolved": "https://registry.npmjs.org/@wdio/utils/-/utils-9.24.0.tgz",
+      "integrity": "sha512-6WhtzC5SNCGRBTkaObX6A07Ofnnyyf+TQH/d/fuhZRqvBknrP4AMMZF+PFxGl1fwdySWdBn+gV2QLE+52Byowg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@puppeteer/browsers": "^2.2.0",
+        "@wdio/logger": "9.18.0",
+        "@wdio/types": "9.24.0",
+        "decamelize": "^6.0.0",
+        "deepmerge-ts": "^7.0.3",
+        "edgedriver": "^6.1.2",
+        "geckodriver": "^6.1.0",
+        "get-port": "^7.0.0",
+        "import-meta-resolve": "^4.0.0",
+        "locate-app": "^2.2.24",
+        "mitt": "^3.0.1",
+        "safaridriver": "^1.0.0",
+        "split2": "^4.2.0",
+        "wait-port": "^1.1.0"
+      },
+      "engines": {
+        "node": ">=18.20.0"
+      }
+    },
+    "node_modules/@wdio/xvfb": {
+      "version": "9.24.0",
+      "resolved": "https://registry.npmjs.org/@wdio/xvfb/-/xvfb-9.24.0.tgz",
+      "integrity": "sha512-eK0rUZeR+wlFapm2cb7OQ1LwC/nHmdo7eX02B2Dme7uQGF3+/ILkDTm5B0RYpGUbM3ktw3d0fhcwqqeNNH9KIA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@wdio/logger": "9.18.0"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@xterm/addon-canvas": {
+      "version": "0.7.0",
+      "resolved": "https://registry.npmjs.org/@xterm/addon-canvas/-/addon-canvas-0.7.0.tgz",
+      "integrity": "sha512-LF5LYcfvefJuJ7QotNRdRSPc9YASAVDeoT5uyXS/nZshZXjYplGXRECBGiznwvhNL2I8bq1Lf5MzRwstsYQ2Iw==",
+      "license": "MIT",
+      "peerDependencies": {
+        "@xterm/xterm": "^5.0.0"
+      }
+    },
+    "node_modules/@xterm/addon-fit": {
+      "version": "0.11.0",
+      "resolved": "https://registry.npmjs.org/@xterm/addon-fit/-/addon-fit-0.11.0.tgz",
+      "integrity": "sha512-jYcgT6xtVYhnhgxh3QgYDnnNMYTcf8ElbxxFzX0IZo+vabQqSPAjC3c1wJrKB5E19VwQei89QCiZZP86DCPF7g==",
+      "license": "MIT"
+    },
+    "node_modules/@xterm/xterm": {
+      "version": "6.0.0",
+      "resolved": "https://registry.npmjs.org/@xterm/xterm/-/xterm-6.0.0.tgz",
+      "integrity": "sha512-TQwDdQGtwwDt+2cgKDLn0IRaSxYu1tSUjgKarSDkUM0ZNiSRXFpjxEsvc/Zgc5kq5omJ+V0a8/kIM2WD3sMOYg==",
+      "license": "MIT",
+      "workspaces": [
+        "addons/*"
+      ]
+    },
+    "node_modules/@zip.js/zip.js": {
+      "version": "2.8.23",
+      "resolved": "https://registry.npmjs.org/@zip.js/zip.js/-/zip.js-2.8.23.tgz",
+      "integrity": "sha512-RB+RLnxPJFPrGvQ9rgO+4JOcsob6lD32OcF0QE0yg24oeW9q8KnTTNlugcDaIveEcCbclobJcZP+fLQ++sH0bw==",
+      "dev": true,
+      "license": "BSD-3-Clause",
+      "engines": {
+        "bun": ">=0.7.0",
+        "deno": ">=1.0.0",
+        "node": ">=18.0.0"
+      }
+    },
+    "node_modules/abort-controller": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/abort-controller/-/abort-controller-3.0.0.tgz",
+      "integrity": "sha512-h8lQ8tacZYnR3vNQTgibj+tODHI5/+l06Au2Pcriv/Gmet0eaj4TwWH41sO9wnHDiQsEj19q0drzdWdeAHtweg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "event-target-shim": "^5.0.0"
+      },
+      "engines": {
+        "node": ">=6.5"
+      }
+    },
+    "node_modules/acorn": {
+      "version": "8.16.0",
+      "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.16.0.tgz",
+      "integrity": "sha512-UVJyE9MttOsBQIDKw1skb9nAwQuR5wuGD3+82K6JgJlm/Y+KI92oNsMNGZCYdDsVtRHSak0pcV5Dno5+4jh9sw==",
+      "dev": true,
+      "license": "MIT",
+      "bin": {
+        "acorn": "bin/acorn"
+      },
+      "engines": {
+        "node": ">=0.4.0"
+      }
+    },
+    "node_modules/agent-base": {
+      "version": "7.1.4",
+      "resolved": "https://registry.npmjs.org/agent-base/-/agent-base-7.1.4.tgz",
+      "integrity": "sha512-MnA+YT8fwfJPgBx3m60MNqakm30XOkyIoH1y6huTQvC0PwZG7ki8NacLBcrPbNoo8vEZy7Jpuk7+jMO+CUovTQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 14"
+      }
+    },
+    "node_modules/ansi-colors": {
+      "version": "4.1.3",
+      "resolved": "https://registry.npmjs.org/ansi-colors/-/ansi-colors-4.1.3.tgz",
+      "integrity": "sha512-/6w/C21Pm1A7aZitlI5Ni/2J6FFQN8i1Cvz3kHABAAbw93v/NlvKdVOqz7CCWz/3iv/JplRSEEZ83XION15ovw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/ansi-regex": {
+      "version": "5.0.1",
+      "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz",
+      "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/ansi-styles": {
+      "version": "5.2.0",
+      "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-5.2.0.tgz",
+      "integrity": "sha512-Cxwpt2SfTzTtXcfOlzGEee8O+c+MmUgGrNiBcXnuWxuFJHe6a5Hz7qwhwe5OgaSYI0IJvkLqWX1ASG+cJOkEiA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/ansi-styles?sponsor=1"
+      }
+    },
+    "node_modules/anymatch": {
+      "version": "3.1.3",
+      "resolved": "https://registry.npmjs.org/anymatch/-/anymatch-3.1.3.tgz",
+      "integrity": "sha512-KMReFUr0B4t+D+OBkjR3KYqvocp2XaSzO55UcB6mgQMd3KbcE+mWTyvVV7D/zsdEbNnV6acZUutkiHQXvTr1Rw==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "normalize-path": "^3.0.0",
+        "picomatch": "^2.0.4"
+      },
+      "engines": {
+        "node": ">= 8"
+      }
+    },
+    "node_modules/anymatch/node_modules/picomatch": {
+      "version": "2.3.1",
+      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.1.tgz",
+      "integrity": "sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8.6"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/jonschlinkert"
+      }
+    },
+    "node_modules/archiver": {
+      "version": "7.0.1",
+      "resolved": "https://registry.npmjs.org/archiver/-/archiver-7.0.1.tgz",
+      "integrity": "sha512-ZcbTaIqJOfCc03QwD468Unz/5Ir8ATtvAHsK+FdXbDIbGfihqh9mrvdcYunQzqn4HrvWWaFyaxJhGZagaJJpPQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "archiver-utils": "^5.0.2",
+        "async": "^3.2.4",
+        "buffer-crc32": "^1.0.0",
+        "readable-stream": "^4.0.0",
+        "readdir-glob": "^1.1.2",
+        "tar-stream": "^3.0.0",
+        "zip-stream": "^6.0.1"
+      },
+      "engines": {
+        "node": ">= 14"
+      }
+    },
+    "node_modules/archiver-utils": {
+      "version": "5.0.2",
+      "resolved": "https://registry.npmjs.org/archiver-utils/-/archiver-utils-5.0.2.tgz",
+      "integrity": "sha512-wuLJMmIBQYCsGZgYLTy5FIB2pF6Lfb6cXMSF8Qywwk3t20zWnAi7zLcQFdKQmIB8wyZpY5ER38x08GbwtR2cLA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "glob": "^10.0.0",
+        "graceful-fs": "^4.2.0",
+        "is-stream": "^2.0.1",
+        "lazystream": "^1.0.0",
+        "lodash": "^4.17.15",
+        "normalize-path": "^3.0.0",
+        "readable-stream": "^4.0.0"
+      },
+      "engines": {
+        "node": ">= 14"
+      }
+    },
+    "node_modules/archiver-utils/node_modules/is-stream": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/is-stream/-/is-stream-2.0.1.tgz",
+      "integrity": "sha512-hFoiJiTl63nn+kstHGBtewWSKnQLpyb155KHheA1l39uvtO9nWIop1p3udqPcUd/xbF1VLMO4n7OI6p7RbngDg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/argparse": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/argparse/-/argparse-2.0.1.tgz",
+      "integrity": "sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==",
+      "dev": true,
+      "license": "Python-2.0"
+    },
+    "node_modules/aria-query": {
+      "version": "5.3.1",
+      "resolved": "https://registry.npmjs.org/aria-query/-/aria-query-5.3.1.tgz",
+      "integrity": "sha512-Z/ZeOgVl7bcSYZ/u/rh0fOpvEpq//LZmdbkXyc7syVzjPAhfOa9ebsdTSjEBDU4vs5nC98Kfduj1uFo0qyET3g==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/assertion-error": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/assertion-error/-/assertion-error-2.0.1.tgz",
+      "integrity": "sha512-Izi8RQcffqCeNVgFigKli1ssklIbpHnCYc6AknXGYoB6grJqyeby7jv12JUQgmTAnIDnbck1uxksT4dzN3PWBA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/ast-types": {
+      "version": "0.13.4",
+      "resolved": "https://registry.npmjs.org/ast-types/-/ast-types-0.13.4.tgz",
+      "integrity": "sha512-x1FCFnFifvYDDzTaLII71vG5uvDwgtmDTEVWAxrgeiR8VjMONcCXJx7E+USjDtHlwFmt9MysbqgF9b9Vjr6w+w==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "tslib": "^2.0.1"
+      },
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/async": {
+      "version": "3.2.6",
+      "resolved": "https://registry.npmjs.org/async/-/async-3.2.6.tgz",
+      "integrity": "sha512-htCUDlxyyCLMgaM3xXg0C0LW2xqfuQ6p05pCEIsXuyQ+a1koYKTuBMzRNwmybfLgvJDMd0r1LTn4+E0Ti6C2AA==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/async-exit-hook": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/async-exit-hook/-/async-exit-hook-2.0.1.tgz",
+      "integrity": "sha512-NW2cX8m1Q7KPA7a5M2ULQeZ2wR5qI5PAbw5L0UOMxdioVk9PMZ0h1TmyZEkPYrCvYjDlFICusOu1dlEKAAeXBw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.12.0"
+      }
+    },
+    "node_modules/axobject-query": {
+      "version": "4.1.0",
+      "resolved": "https://registry.npmjs.org/axobject-query/-/axobject-query-4.1.0.tgz",
+      "integrity": "sha512-qIj0G9wZbMGNLjLmg1PT6v2mE9AH2zlnADJD/2tC6E00hgmhUOfEB6greHPAfLRSufHqROIUTkw6E+M3lH0PTQ==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/b4a": {
+      "version": "1.8.0",
+      "resolved": "https://registry.npmjs.org/b4a/-/b4a-1.8.0.tgz",
+      "integrity": "sha512-qRuSmNSkGQaHwNbM7J78Wwy+ghLEYF1zNrSeMxj4Kgw6y33O3mXcQ6Ie9fRvfU/YnxWkOchPXbaLb73TkIsfdg==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "peerDependencies": {
+        "react-native-b4a": "*"
+      },
+      "peerDependenciesMeta": {
+        "react-native-b4a": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/balanced-match": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz",
+      "integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/bare-events": {
+      "version": "2.8.2",
+      "resolved": "https://registry.npmjs.org/bare-events/-/bare-events-2.8.2.tgz",
+      "integrity": "sha512-riJjyv1/mHLIPX4RwiK+oW9/4c3TEUeORHKefKAKnZ5kyslbN+HXowtbaVEqt4IMUB7OXlfixcs6gsFeo/jhiQ==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "peerDependencies": {
+        "bare-abort-controller": "*"
+      },
+      "peerDependenciesMeta": {
+        "bare-abort-controller": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/bare-fs": {
+      "version": "4.5.5",
+      "resolved": "https://registry.npmjs.org/bare-fs/-/bare-fs-4.5.5.tgz",
+      "integrity": "sha512-XvwYM6VZqKoqDll8BmSww5luA5eflDzY0uEFfBJtFKe4PAAtxBjU3YIxzIBzhyaEQBy1VXEQBto4cpN5RZJw+w==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "bare-events": "^2.5.4",
+        "bare-path": "^3.0.0",
+        "bare-stream": "^2.6.4",
+        "bare-url": "^2.2.2",
+        "fast-fifo": "^1.3.2"
+      },
+      "engines": {
+        "bare": ">=1.16.0"
+      },
+      "peerDependencies": {
+        "bare-buffer": "*"
+      },
+      "peerDependenciesMeta": {
+        "bare-buffer": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/bare-os": {
+      "version": "3.7.1",
+      "resolved": "https://registry.npmjs.org/bare-os/-/bare-os-3.7.1.tgz",
+      "integrity": "sha512-ebvMaS5BgZKmJlvuWh14dg9rbUI84QeV3WlWn6Ph6lFI8jJoh7ADtVTyD2c93euwbe+zgi0DVrl4YmqXeM9aIA==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "engines": {
+        "bare": ">=1.14.0"
+      }
+    },
+    "node_modules/bare-path": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/bare-path/-/bare-path-3.0.0.tgz",
+      "integrity": "sha512-tyfW2cQcB5NN8Saijrhqn0Zh7AnFNsnczRcuWODH0eYAXBsJ5gVxAUuNr7tsHSC6IZ77cA0SitzT+s47kot8Mw==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "bare-os": "^3.0.1"
+      }
+    },
+    "node_modules/bare-stream": {
+      "version": "2.8.0",
+      "resolved": "https://registry.npmjs.org/bare-stream/-/bare-stream-2.8.0.tgz",
+      "integrity": "sha512-reUN0M2sHRqCdG4lUK3Fw8w98eeUIZHL5c3H7Mbhk2yVBL+oofgaIp0ieLfD5QXwPCypBpmEEKU2WZKzbAk8GA==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "streamx": "^2.21.0",
+        "teex": "^1.0.1"
+      },
+      "peerDependencies": {
+        "bare-buffer": "*",
+        "bare-events": "*"
+      },
+      "peerDependenciesMeta": {
+        "bare-buffer": {
+          "optional": true
+        },
+        "bare-events": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/bare-url": {
+      "version": "2.3.2",
+      "resolved": "https://registry.npmjs.org/bare-url/-/bare-url-2.3.2.tgz",
+      "integrity": "sha512-ZMq4gd9ngV5aTMa5p9+UfY0b3skwhHELaDkhEHetMdX0LRkW9kzaym4oo/Eh+Ghm0CCDuMTsRIGM/ytUc1ZYmw==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "bare-path": "^3.0.0"
+      }
+    },
+    "node_modules/base64-js": {
+      "version": "1.5.1",
+      "resolved": "https://registry.npmjs.org/base64-js/-/base64-js-1.5.1.tgz",
+      "integrity": "sha512-AKpaYlHn8t4SVbOHCy+b5+KKgvR4vrsD8vbvrbiQJps7fKDTkjkDry6ji0rUJjC0kzbNePLwzxq8iypo41qeWA==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/feross"
+        },
+        {
+          "type": "patreon",
+          "url": "https://www.patreon.com/feross"
+        },
+        {
+          "type": "consulting",
+          "url": "https://feross.org/support"
+        }
+      ],
+      "license": "MIT"
+    },
+    "node_modules/basic-ftp": {
+      "version": "5.2.0",
+      "resolved": "https://registry.npmjs.org/basic-ftp/-/basic-ftp-5.2.0.tgz",
+      "integrity": "sha512-VoMINM2rqJwJgfdHq6RiUudKt2BV+FY5ZFezP/ypmwayk68+NzzAQy4XXLlqsGD4MCzq3DrmNFD/uUmBJuGoXw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=10.0.0"
+      }
+    },
+    "node_modules/binary-extensions": {
+      "version": "2.3.0",
+      "resolved": "https://registry.npmjs.org/binary-extensions/-/binary-extensions-2.3.0.tgz",
+      "integrity": "sha512-Ceh+7ox5qe7LJuLHoY0feh3pHuUDHAcRUeyL2VYghZwfpkNIy/+8Ocg0a3UuSoYzavmylwuLWQOf3hl0jjMMIw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/boolbase": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/boolbase/-/boolbase-1.0.0.tgz",
+      "integrity": "sha512-JZOSA7Mo9sNGB8+UjSgzdLtokWAky1zbztM3WRLCbZ70/3cTANmQmOdR7y2g+J0e2WXywy1yS468tY+IruqEww==",
+      "dev": true,
+      "license": "ISC"
+    },
+    "node_modules/brace-expansion": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.0.2.tgz",
+      "integrity": "sha512-Jt0vHyM+jmUBqojB7E1NIYadt0vI0Qxjxd2TErW94wDz+E2LAm5vKMXXwg6ZZBTHPuUlDgQHKXvjGBdfcF1ZDQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "balanced-match": "^1.0.0"
+      }
+    },
+    "node_modules/braces": {
+      "version": "3.0.3",
+      "resolved": "https://registry.npmjs.org/braces/-/braces-3.0.3.tgz",
+      "integrity": "sha512-yQbXgO/OSZVD2IsiLlro+7Hf6Q18EJrKSEsdoMzKePKXct3gvD8oLcOQdIzGupr5Fj+EDe8gO/lxc1BzfMpxvA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "fill-range": "^7.1.1"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/browser-stdout": {
+      "version": "1.3.1",
+      "resolved": "https://registry.npmjs.org/browser-stdout/-/browser-stdout-1.3.1.tgz",
+      "integrity": "sha512-qhAVI1+Av2X7qelOfAIYwXONood6XlZE/fXaBSmW/T5SzLAmCgzi+eiWE7fUvbHaeNBQH13UftjpXxsfLkMpgw==",
+      "dev": true,
+      "license": "ISC"
+    },
+    "node_modules/buffer": {
+      "version": "6.0.3",
+      "resolved": "https://registry.npmjs.org/buffer/-/buffer-6.0.3.tgz",
+      "integrity": "sha512-FTiCpNxtwiZZHEZbcbTIcZjERVICn9yq/pDFkTl95/AxzD1naBctN7YO68riM/gLSDY7sdrMby8hofADYuuqOA==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/feross"
+        },
+        {
+          "type": "patreon",
+          "url": "https://www.patreon.com/feross"
+        },
+        {
+          "type": "consulting",
+          "url": "https://feross.org/support"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "base64-js": "^1.3.1",
+        "ieee754": "^1.2.1"
+      }
+    },
+    "node_modules/buffer-crc32": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/buffer-crc32/-/buffer-crc32-1.0.0.tgz",
+      "integrity": "sha512-Db1SbgBS/fg/392AblrMJk97KggmvYhr4pB5ZIMTWtaivCPMWLkmb7m21cJvpvgK+J3nsU2CmmixNBZx4vFj/w==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8.0.0"
+      }
+    },
+    "node_modules/camelcase": {
+      "version": "6.3.0",
+      "resolved": "https://registry.npmjs.org/camelcase/-/camelcase-6.3.0.tgz",
+      "integrity": "sha512-Gmy6FhYlCY7uOElZUSbxo2UCDH8owEk996gkbrpsgGtrJLM3J7jGxl9Ic7Qwwj4ivOE5AWZWRMecDdF7hqGjFA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/ccount": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/ccount/-/ccount-2.0.1.tgz",
+      "integrity": "sha512-eyrF0jiFpY+3drT6383f1qhkbGsLSifNAjA61IUjZjmLCWjItY6LB9ft9YhoDgwfmclB2zhu51Lc7+95b8NRAg==",
+      "license": "MIT",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
+    "node_modules/chai": {
+      "version": "6.2.2",
+      "resolved": "https://registry.npmjs.org/chai/-/chai-6.2.2.tgz",
+      "integrity": "sha512-NUPRluOfOiTKBKvWPtSD4PhFvWCqOi0BGStNWs57X9js7XGTprSmFoz5F0tWhR4WPjNeR9jXqdC7/UpSJTnlRg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/chalk": {
+      "version": "5.6.2",
+      "resolved": "https://registry.npmjs.org/chalk/-/chalk-5.6.2.tgz",
+      "integrity": "sha512-7NzBL0rN6fMUW+f7A6Io4h40qQlG+xGmtMxfbnH/K7TAtt8JQWVQK+6g0UXKMeVJoyV5EkkNsErQ8pVD3bLHbA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": "^12.17.0 || ^14.13 || >=16.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/chalk?sponsor=1"
+      }
+    },
+    "node_modules/character-entities-html4": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/character-entities-html4/-/character-entities-html4-2.1.0.tgz",
+      "integrity": "sha512-1v7fgQRj6hnSwFpq1Eu0ynr/CDEw0rXo2B61qXrLNdHZmPKgb7fqS1a2JwF0rISo9q77jDI8VMEHoApn8qDoZA==",
+      "license": "MIT",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
+    "node_modules/character-entities-legacy": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/character-entities-legacy/-/character-entities-legacy-3.0.0.tgz",
+      "integrity": "sha512-RpPp0asT/6ufRm//AJVwpViZbGM/MkjQFxJccQRHmISF/22NBtsHqAWmL+/pmkPWoIUJdWyeVleTl1wydHATVQ==",
+      "license": "MIT",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
+    "node_modules/chardet": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/chardet/-/chardet-2.1.1.tgz",
+      "integrity": "sha512-PsezH1rqdV9VvyNhxxOW32/d75r01NY7TQCmOqomRo15ZSOKbpTFVsfjghxo6JloQUCGnH4k1LGu0R4yCLlWQQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/cheerio": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/cheerio/-/cheerio-1.2.0.tgz",
+      "integrity": "sha512-WDrybc/gKFpTYQutKIK6UvfcuxijIZfMfXaYm8NMsPQxSYvf+13fXUJ4rztGGbJcBQ/GF55gvrZ0Bc0bj/mqvg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "cheerio-select": "^2.1.0",
+        "dom-serializer": "^2.0.0",
+        "domhandler": "^5.0.3",
+        "domutils": "^3.2.2",
+        "encoding-sniffer": "^0.2.1",
+        "htmlparser2": "^10.1.0",
+        "parse5": "^7.3.0",
+        "parse5-htmlparser2-tree-adapter": "^7.1.0",
+        "parse5-parser-stream": "^7.1.2",
+        "undici": "^7.19.0",
+        "whatwg-mimetype": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=20.18.1"
+      },
+      "funding": {
+        "url": "https://github.com/cheeriojs/cheerio?sponsor=1"
+      }
+    },
+    "node_modules/cheerio-select": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/cheerio-select/-/cheerio-select-2.1.0.tgz",
+      "integrity": "sha512-9v9kG0LvzrlcungtnJtpGNxY+fzECQKhK4EGJX2vByejiMX84MFNQw4UxPJl3bFbTMw+Dfs37XaIkCwTZfLh4g==",
+      "dev": true,
+      "license": "BSD-2-Clause",
+      "dependencies": {
+        "boolbase": "^1.0.0",
+        "css-select": "^5.1.0",
+        "css-what": "^6.1.0",
+        "domelementtype": "^2.3.0",
+        "domhandler": "^5.0.3",
+        "domutils": "^3.0.1"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/fb55"
+      }
+    },
+    "node_modules/cheerio/node_modules/undici": {
+      "version": "7.22.0",
+      "resolved": "https://registry.npmjs.org/undici/-/undici-7.22.0.tgz",
+      "integrity": "sha512-RqslV2Us5BrllB+JeiZnK4peryVTndy9Dnqq62S3yYRRTj0tFQCwEniUy2167skdGOy3vqRzEvl1Dm4sV2ReDg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=20.18.1"
+      }
+    },
+    "node_modules/chokidar": {
+      "version": "4.0.3",
+      "resolved": "https://registry.npmjs.org/chokidar/-/chokidar-4.0.3.tgz",
+      "integrity": "sha512-Qgzu8kfBvo+cA4962jnP1KkS6Dop5NS6g7R5LFYJr4b8Ub94PPQXUksCw9PvXoeXPRRddRNC5C1JQUR2SMGtnA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "readdirp": "^4.0.1"
+      },
+      "engines": {
+        "node": ">= 14.16.0"
+      },
+      "funding": {
+        "url": "https://paulmillr.com/funding/"
+      }
+    },
+    "node_modules/ci-info": {
+      "version": "4.4.0",
+      "resolved": "https://registry.npmjs.org/ci-info/-/ci-info-4.4.0.tgz",
+      "integrity": "sha512-77PSwercCZU2Fc4sX94eF8k8Pxte6JAwL4/ICZLFjJLqegs7kCuAsqqj/70NQF6TvDpgFjkubQB2FW2ZZddvQg==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/sibiraj-s"
+        }
+      ],
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/cli-width": {
+      "version": "4.1.0",
+      "resolved": "https://registry.npmjs.org/cli-width/-/cli-width-4.1.0.tgz",
+      "integrity": "sha512-ouuZd4/dm2Sw5Gmqy6bGyNNNe1qt9RpmxveLSO7KcgsTnU7RXfsw+/bukWGo1abgBiMAic068rclZsO4IWmmxQ==",
+      "dev": true,
+      "license": "ISC",
+      "engines": {
+        "node": ">= 12"
+      }
+    },
+    "node_modules/cliui": {
+      "version": "8.0.1",
+      "resolved": "https://registry.npmjs.org/cliui/-/cliui-8.0.1.tgz",
+      "integrity": "sha512-BSeNnyus75C4//NQ9gQt1/csTXyo/8Sb+afLAkzAptFuMsod9HFokGNudZpi/oQV73hnVK+sR+5PVRMd+Dr7YQ==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "string-width": "^4.2.0",
+        "strip-ansi": "^6.0.1",
+        "wrap-ansi": "^7.0.0"
+      },
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/cliui/node_modules/ansi-styles": {
+      "version": "4.3.0",
+      "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz",
+      "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "color-convert": "^2.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/ansi-styles?sponsor=1"
+      }
+    },
+    "node_modules/cliui/node_modules/emoji-regex": {
+      "version": "8.0.0",
+      "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz",
+      "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/cliui/node_modules/string-width": {
+      "version": "4.2.3",
+      "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz",
+      "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "emoji-regex": "^8.0.0",
+        "is-fullwidth-code-point": "^3.0.0",
+        "strip-ansi": "^6.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/cliui/node_modules/strip-ansi": {
+      "version": "6.0.1",
+      "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz",
+      "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "ansi-regex": "^5.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/cliui/node_modules/wrap-ansi": {
+      "version": "7.0.0",
+      "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-7.0.0.tgz",
+      "integrity": "sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "ansi-styles": "^4.0.0",
+        "string-width": "^4.1.0",
+        "strip-ansi": "^6.0.0"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/wrap-ansi?sponsor=1"
+      }
+    },
+    "node_modules/clone": {
+      "version": "1.0.4",
+      "resolved": "https://registry.npmjs.org/clone/-/clone-1.0.4.tgz",
+      "integrity": "sha512-JQHZ2QMW6l3aH/j6xCqQThY/9OH4D/9ls34cgkUBiEeocRTU04tHfKPBsUK1PqZCUQM7GiA0IIXJSuXHI64Kbg==",
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "engines": {
+        "node": ">=0.8"
+      }
+    },
+    "node_modules/clsx": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/clsx/-/clsx-2.1.1.tgz",
+      "integrity": "sha512-eYm0QWBtUrBWZWG0d386OGAw16Z995PiOVo2B7bjWSbHedGl5e0ZWaq65kOGgUSNesEIDkB9ISbTg/JK9dhCZA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/codemirror": {
+      "version": "6.0.2",
+      "resolved": "https://registry.npmjs.org/codemirror/-/codemirror-6.0.2.tgz",
+      "integrity": "sha512-VhydHotNW5w1UGK0Qj96BwSk/Zqbp9WbnyK2W/eVMv4QyF41INRGpjUhFJY7/uDNuudSc33a/PKr4iDqRduvHw==",
+      "license": "MIT",
+      "dependencies": {
+        "@codemirror/autocomplete": "^6.0.0",
+        "@codemirror/commands": "^6.0.0",
+        "@codemirror/language": "^6.0.0",
+        "@codemirror/lint": "^6.0.0",
+        "@codemirror/search": "^6.0.0",
+        "@codemirror/state": "^6.0.0",
+        "@codemirror/view": "^6.0.0"
+      }
+    },
+    "node_modules/color-convert": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz",
+      "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "color-name": "~1.1.4"
+      },
+      "engines": {
+        "node": ">=7.0.0"
+      }
+    },
+    "node_modules/color-name": {
+      "version": "1.1.4",
+      "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz",
+      "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/comma-separated-tokens": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/comma-separated-tokens/-/comma-separated-tokens-2.0.3.tgz",
+      "integrity": "sha512-Fu4hJdvzeylCfQPp9SGWidpzrMs7tTrlu6Vb8XGaRGck8QSNZJJp538Wrb60Lax4fPwR64ViY468OIUTbRlGZg==",
+      "license": "MIT",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
+    "node_modules/commander": {
+      "version": "14.0.3",
+      "resolved": "https://registry.npmjs.org/commander/-/commander-14.0.3.tgz",
+      "integrity": "sha512-H+y0Jo/T1RZ9qPP4Eh1pkcQcLRglraJaSLoyOtHxu6AapkjWVCy2Sit1QQ4x3Dng8qDlSsZEet7g5Pq06MvTgw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=20"
+      }
+    },
+    "node_modules/compress-commons": {
+      "version": "6.0.2",
+      "resolved": "https://registry.npmjs.org/compress-commons/-/compress-commons-6.0.2.tgz",
+      "integrity": "sha512-6FqVXeETqWPoGcfzrXb37E50NP0LXT8kAMu5ooZayhWWdgEY4lBEEcbQNXtkuKQsGduxiIcI4gOTsxTmuq/bSg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "crc-32": "^1.2.0",
+        "crc32-stream": "^6.0.0",
+        "is-stream": "^2.0.1",
+        "normalize-path": "^3.0.0",
+        "readable-stream": "^4.0.0"
+      },
+      "engines": {
+        "node": ">= 14"
+      }
+    },
+    "node_modules/compress-commons/node_modules/is-stream": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/is-stream/-/is-stream-2.0.1.tgz",
+      "integrity": "sha512-hFoiJiTl63nn+kstHGBtewWSKnQLpyb155KHheA1l39uvtO9nWIop1p3udqPcUd/xbF1VLMO4n7OI6p7RbngDg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/concat-map": {
+      "version": "0.0.1",
+      "resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz",
+      "integrity": "sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/core-util-is": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/core-util-is/-/core-util-is-1.0.3.tgz",
+      "integrity": "sha512-ZQBvi1DcpJ4GDqanjucZ2Hj3wEO5pZDS89BWbkcrvdxksJorwUDDZamX9ldFkp9aw2lmBDLgkObEA4DWNJ9FYQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/crc-32": {
+      "version": "1.2.2",
+      "resolved": "https://registry.npmjs.org/crc-32/-/crc-32-1.2.2.tgz",
+      "integrity": "sha512-ROmzCKrTnOwybPcJApAA6WBWij23HVfGVNKqqrZpuyZOHqK2CwHSvpGuyt/UNNvaIjEd8X5IFGp4Mh+Ie1IHJQ==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "bin": {
+        "crc32": "bin/crc32.njs"
+      },
+      "engines": {
+        "node": ">=0.8"
+      }
+    },
+    "node_modules/crc32-stream": {
+      "version": "6.0.0",
+      "resolved": "https://registry.npmjs.org/crc32-stream/-/crc32-stream-6.0.0.tgz",
+      "integrity": "sha512-piICUB6ei4IlTv1+653yq5+KoqfBYmj9bw6LqXoOneTMDXk5nM1qt12mFW1caG3LlJXEKW1Bp0WggEmIfQB34g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "crc-32": "^1.2.0",
+        "readable-stream": "^4.0.0"
+      },
+      "engines": {
+        "node": ">= 14"
+      }
+    },
+    "node_modules/create-wdio": {
+      "version": "9.21.0",
+      "resolved": "https://registry.npmjs.org/create-wdio/-/create-wdio-9.21.0.tgz",
+      "integrity": "sha512-L6gsQLArY3AH5uTGpf3VfUezIsmZKufkF3ixSWqCuA/m458YVKeGghu1bBOWBdDIzqa6GX4e29dv0uVam0CTpw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "chalk": "^5.3.0",
+        "commander": "^14.0.0",
+        "cross-spawn": "^7.0.3",
+        "ejs": "^3.1.10",
+        "execa": "^9.6.0",
+        "import-meta-resolve": "^4.1.0",
+        "inquirer": "^12.7.0",
+        "normalize-package-data": "^7.0.0",
+        "read-pkg-up": "^10.1.0",
+        "recursive-readdir": "^2.2.3",
+        "semver": "^7.6.3",
+        "type-fest": "^4.41.0",
+        "yargs": "^17.7.2"
+      },
+      "bin": {
+        "create-wdio": "bin/wdio.js"
+      },
+      "engines": {
+        "node": ">=12.0.0"
+      }
+    },
+    "node_modules/crelt": {
+      "version": "1.0.6",
+      "resolved": "https://registry.npmjs.org/crelt/-/crelt-1.0.6.tgz",
+      "integrity": "sha512-VQ2MBenTq1fWZUH9DJNGti7kKv6EeAuYr3cLwxUWhIu1baTaXh4Ib5W2CqHVqib4/MqbYGJqiL3Zb8GJZr3l4g==",
+      "license": "MIT"
+    },
+    "node_modules/cross-spawn": {
+      "version": "7.0.6",
+      "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.6.tgz",
+      "integrity": "sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "path-key": "^3.1.0",
+        "shebang-command": "^2.0.0",
+        "which": "^2.0.1"
+      },
+      "engines": {
+        "node": ">= 8"
+      }
+    },
+    "node_modules/css-select": {
+      "version": "5.2.2",
+      "resolved": "https://registry.npmjs.org/css-select/-/css-select-5.2.2.tgz",
+      "integrity": "sha512-TizTzUddG/xYLA3NXodFM0fSbNizXjOKhqiQQwvhlspadZokn1KDy0NZFS0wuEubIYAV5/c1/lAr0TaaFXEXzw==",
+      "dev": true,
+      "license": "BSD-2-Clause",
+      "dependencies": {
+        "boolbase": "^1.0.0",
+        "css-what": "^6.1.0",
+        "domhandler": "^5.0.2",
+        "domutils": "^3.0.1",
+        "nth-check": "^2.0.1"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/fb55"
+      }
+    },
+    "node_modules/css-shorthand-properties": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/css-shorthand-properties/-/css-shorthand-properties-1.1.2.tgz",
+      "integrity": "sha512-C2AugXIpRGQTxaCW0N7n5jD/p5irUmCrwl03TrnMFBHDbdq44CFWR2zO7rK9xPN4Eo3pUxC4vQzQgbIpzrD1PQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/css-value": {
+      "version": "0.0.1",
+      "resolved": "https://registry.npmjs.org/css-value/-/css-value-0.0.1.tgz",
+      "integrity": "sha512-FUV3xaJ63buRLgHrLQVlVgQnQdR4yqdLGaDu7g8CQcWjInDfM9plBTPI9FRfpahju1UBSaMckeb2/46ApS/V1Q==",
+      "dev": true
+    },
+    "node_modules/css-what": {
+      "version": "6.2.2",
+      "resolved": "https://registry.npmjs.org/css-what/-/css-what-6.2.2.tgz",
+      "integrity": "sha512-u/O3vwbptzhMs3L1fQE82ZSLHQQfto5gyZzwteVIEyeaY5Fc7R4dapF/BvRoSYFeqfBk4m0V1Vafq5Pjv25wvA==",
+      "dev": true,
+      "license": "BSD-2-Clause",
+      "engines": {
+        "node": ">= 6"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/fb55"
+      }
+    },
+    "node_modules/data-uri-to-buffer": {
+      "version": "6.0.2",
+      "resolved": "https://registry.npmjs.org/data-uri-to-buffer/-/data-uri-to-buffer-6.0.2.tgz",
+      "integrity": "sha512-7hvf7/GW8e86rW0ptuwS3OcBGDjIi6SZva7hCyWC0yYry2cOPmLIjXAUHI6DK2HsnwJd9ifmt57i8eV2n4YNpw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 14"
+      }
+    },
+    "node_modules/debug": {
+      "version": "4.4.3",
+      "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz",
+      "integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "ms": "^2.1.3"
+      },
+      "engines": {
+        "node": ">=6.0"
+      },
+      "peerDependenciesMeta": {
+        "supports-color": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/decamelize": {
+      "version": "6.0.1",
+      "resolved": "https://registry.npmjs.org/decamelize/-/decamelize-6.0.1.tgz",
+      "integrity": "sha512-G7Cqgaelq68XHJNGlZ7lrNQyhZGsFqpwtGFexqUv4IQdjKoSYF7ipZ9UuTJZUSQXFj/XaoBLuEVIVqr8EJngEQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": "^12.20.0 || ^14.13.1 || >=16.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/deep-eql": {
+      "version": "5.0.2",
+      "resolved": "https://registry.npmjs.org/deep-eql/-/deep-eql-5.0.2.tgz",
+      "integrity": "sha512-h5k/5U50IJJFpzfL6nO9jaaumfjO/f2NjK/oYB2Djzm4p9L+3T9qWpZqZ2hAbLPuuYq9wrU08WQyBTL5GbPk5Q==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/deepmerge": {
+      "version": "4.3.1",
+      "resolved": "https://registry.npmjs.org/deepmerge/-/deepmerge-4.3.1.tgz",
+      "integrity": "sha512-3sUqbMEc77XqpdNO7FRyRog+eW3ph+GYCbj+rK+uYyRMuwsVy0rMiVtPn+QJlKFvWP/1PYpapqYn0Me2knFn+A==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/deepmerge-ts": {
+      "version": "7.1.5",
+      "resolved": "https://registry.npmjs.org/deepmerge-ts/-/deepmerge-ts-7.1.5.tgz",
+      "integrity": "sha512-HOJkrhaYsweh+W+e74Yn7YStZOilkoPb6fycpwNLKzSPtruFs48nYis0zy5yJz1+ktUhHxoRDJ27RQAWLIJVJw==",
+      "dev": true,
+      "license": "BSD-3-Clause",
+      "engines": {
+        "node": ">=16.0.0"
+      }
+    },
+    "node_modules/defaults": {
+      "version": "1.0.4",
+      "resolved": "https://registry.npmjs.org/defaults/-/defaults-1.0.4.tgz",
+      "integrity": "sha512-eFuaLoy/Rxalv2kr+lqMlUnrDWV+3j4pljOIJgLIhI058IQfWJ7vXhyEIHu+HtC738klGALYxOKDO0bQP3tg8A==",
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "clone": "^1.0.2"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/degenerator": {
+      "version": "5.0.1",
+      "resolved": "https://registry.npmjs.org/degenerator/-/degenerator-5.0.1.tgz",
+      "integrity": "sha512-TllpMR/t0M5sqCXfj85i4XaAzxmS5tVA16dqvdkMwGmzI+dXLXnw3J+3Vdv7VKw+ThlTMboK6i9rnZ6Nntj5CQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "ast-types": "^0.13.4",
+        "escodegen": "^2.1.0",
+        "esprima": "^4.0.1"
+      },
+      "engines": {
+        "node": ">= 14"
+      }
+    },
+    "node_modules/dequal": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/dequal/-/dequal-2.0.3.tgz",
+      "integrity": "sha512-0je+qPKHEMohvfRTCEo3CrPG6cAzAYgmzKyxRiYSSDkS6eGJdyVJm7WaYA5ECaAD9wLB2T4EEeymA5aFVcYXCA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/devalue": {
+      "version": "5.6.3",
+      "resolved": "https://registry.npmjs.org/devalue/-/devalue-5.6.3.tgz",
+      "integrity": "sha512-nc7XjUU/2Lb+SvEFVGcWLiKkzfw8+qHI7zn8WYXKkLMgfGSHbgCEaR6bJpev8Cm6Rmrb19Gfd/tZvGqx9is3wg==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/devlop": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/devlop/-/devlop-1.1.0.tgz",
+      "integrity": "sha512-RWmIqhcFf1lRYBvNmr7qTNuyCt/7/ns2jbpp1+PalgE/rDQcBT0fioSMUpJ93irlUhC5hrg4cYqe6U+0ImW0rA==",
+      "license": "MIT",
+      "dependencies": {
+        "dequal": "^2.0.0"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
+    "node_modules/diff": {
+      "version": "8.0.3",
+      "resolved": "https://registry.npmjs.org/diff/-/diff-8.0.3.tgz",
+      "integrity": "sha512-qejHi7bcSD4hQAZE0tNAawRK1ZtafHDmMTMkrrIGgSLl7hTnQHmKCeB45xAcbfTqK2zowkM3j3bHt/4b/ARbYQ==",
+      "dev": true,
+      "license": "BSD-3-Clause",
+      "engines": {
+        "node": ">=0.3.1"
+      }
+    },
+    "node_modules/dom-serializer": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/dom-serializer/-/dom-serializer-2.0.0.tgz",
+      "integrity": "sha512-wIkAryiqt/nV5EQKqQpo3SToSOV9J0DnbJqwK7Wv/Trc92zIAYZ4FlMu+JPFW1DfGFt81ZTCGgDEabffXeLyJg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "domelementtype": "^2.3.0",
+        "domhandler": "^5.0.2",
+        "entities": "^4.2.0"
+      },
+      "funding": {
+        "url": "https://github.com/cheeriojs/dom-serializer?sponsor=1"
+      }
+    },
+    "node_modules/domelementtype": {
+      "version": "2.3.0",
+      "resolved": "https://registry.npmjs.org/domelementtype/-/domelementtype-2.3.0.tgz",
+      "integrity": "sha512-OLETBj6w0OsagBwdXnPdN0cnMfF9opN69co+7ZrbfPGrdpPVNBUj02spi6B1N7wChLQiPn4CSH/zJvXw56gmHw==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/fb55"
+        }
+      ],
+      "license": "BSD-2-Clause"
+    },
+    "node_modules/domhandler": {
+      "version": "5.0.3",
+      "resolved": "https://registry.npmjs.org/domhandler/-/domhandler-5.0.3.tgz",
+      "integrity": "sha512-cgwlv/1iFQiFnU96XXgROh8xTeetsnJiDsTc7TYCLFd9+/WNkIqPTxiM/8pSd8VIrhXGTf1Ny1q1hquVqDJB5w==",
+      "dev": true,
+      "license": "BSD-2-Clause",
+      "dependencies": {
+        "domelementtype": "^2.3.0"
+      },
+      "engines": {
+        "node": ">= 4"
+      },
+      "funding": {
+        "url": "https://github.com/fb55/domhandler?sponsor=1"
+      }
+    },
+    "node_modules/domutils": {
+      "version": "3.2.2",
+      "resolved": "https://registry.npmjs.org/domutils/-/domutils-3.2.2.tgz",
+      "integrity": "sha512-6kZKyUajlDuqlHKVX1w7gyslj9MPIXzIFiz/rGu35uC1wMi+kMhQwGhl4lt9unC9Vb9INnY9Z3/ZA3+FhASLaw==",
+      "dev": true,
+      "license": "BSD-2-Clause",
+      "dependencies": {
+        "dom-serializer": "^2.0.0",
+        "domelementtype": "^2.3.0",
+        "domhandler": "^5.0.3"
+      },
+      "funding": {
+        "url": "https://github.com/fb55/domutils?sponsor=1"
+      }
+    },
+    "node_modules/dotenv": {
+      "version": "17.3.1",
+      "resolved": "https://registry.npmjs.org/dotenv/-/dotenv-17.3.1.tgz",
+      "integrity": "sha512-IO8C/dzEb6O3F9/twg6ZLXz164a2fhTnEWb95H23Dm4OuN+92NmEAlTrupP9VW6Jm3sO26tQlqyvyi4CsnY9GA==",
+      "dev": true,
+      "license": "BSD-2-Clause",
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://dotenvx.com"
+      }
+    },
+    "node_modules/eastasianwidth": {
+      "version": "0.2.0",
+      "resolved": "https://registry.npmjs.org/eastasianwidth/-/eastasianwidth-0.2.0.tgz",
+      "integrity": "sha512-I88TYZWc9XiYHRQ4/3c5rjjfgkjhLyW2luGIheGERbNQ6OY7yTybanSpDXZa8y7VUP9YmDcYa+eyq4ca7iLqWA==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/easy-table": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/easy-table/-/easy-table-1.2.0.tgz",
+      "integrity": "sha512-OFzVOv03YpvtcWGe5AayU5G2hgybsg3iqA6drU8UaoZyB9jLGMTrz9+asnLp/E+6qPh88yEI1gvyZFZ41dmgww==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "ansi-regex": "^5.0.1"
+      },
+      "optionalDependencies": {
+        "wcwidth": "^1.0.1"
+      }
+    },
+    "node_modules/edge-paths": {
+      "version": "3.0.5",
+      "resolved": "https://registry.npmjs.org/edge-paths/-/edge-paths-3.0.5.tgz",
+      "integrity": "sha512-sB7vSrDnFa4ezWQk9nZ/n0FdpdUuC6R1EOrlU3DL+bovcNFK28rqu2emmAUjujYEJTWIgQGqgVVWUZXMnc8iWg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/which": "^2.0.1",
+        "which": "^2.0.2"
+      },
+      "engines": {
+        "node": ">=14.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/shirshak55"
+      }
+    },
+    "node_modules/edgedriver": {
+      "version": "6.3.0",
+      "resolved": "https://registry.npmjs.org/edgedriver/-/edgedriver-6.3.0.tgz",
+      "integrity": "sha512-ggEQL+oEyIcM4nP2QC3AtCQ04o4kDNefRM3hja0odvlPSnsaxiruMxEZ93v3gDCKWYW6BXUr51PPradb+3nffw==",
+      "dev": true,
+      "hasInstallScript": true,
+      "license": "MIT",
+      "dependencies": {
+        "@wdio/logger": "^9.18.0",
+        "@zip.js/zip.js": "^2.8.11",
+        "decamelize": "^6.0.1",
+        "edge-paths": "^3.0.5",
+        "fast-xml-parser": "^5.3.3",
+        "http-proxy-agent": "^7.0.2",
+        "https-proxy-agent": "^7.0.6",
+        "which": "^6.0.0"
+      },
+      "bin": {
+        "edgedriver": "bin/edgedriver.js"
+      },
+      "engines": {
+        "node": ">=20.0.0"
+      }
+    },
+    "node_modules/edgedriver/node_modules/isexe": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/isexe/-/isexe-4.0.0.tgz",
+      "integrity": "sha512-FFUtZMpoZ8RqHS3XeXEmHWLA4thH+ZxCv2lOiPIn1Xc7CxrqhWzNSDzD+/chS/zbYezmiwWLdQC09JdQKmthOw==",
+      "dev": true,
+      "license": "BlueOak-1.0.0",
+      "engines": {
+        "node": ">=20"
+      }
+    },
+    "node_modules/edgedriver/node_modules/which": {
+      "version": "6.0.1",
+      "resolved": "https://registry.npmjs.org/which/-/which-6.0.1.tgz",
+      "integrity": "sha512-oGLe46MIrCRqX7ytPUf66EAYvdeMIZYn3WaocqqKZAxrBpkqHfL/qvTyJ/bTk5+AqHCjXmrv3CEWgy368zhRUg==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "isexe": "^4.0.0"
+      },
+      "bin": {
+        "node-which": "bin/which.js"
+      },
+      "engines": {
+        "node": "^20.17.0 || >=22.9.0"
+      }
+    },
+    "node_modules/ejs": {
+      "version": "3.1.10",
+      "resolved": "https://registry.npmjs.org/ejs/-/ejs-3.1.10.tgz",
+      "integrity": "sha512-UeJmFfOrAQS8OJWPZ4qtgHyWExa088/MtK5UEyoJGFH67cDEXkZSviOiKRCZ4Xij0zxI3JECgYs3oKx+AizQBA==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "jake": "^10.8.5"
+      },
+      "bin": {
+        "ejs": "bin/cli.js"
+      },
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/emoji-regex": {
+      "version": "9.2.2",
+      "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-9.2.2.tgz",
+      "integrity": "sha512-L18DaJsXSUk2+42pv8mLs5jJT2hqFkFE4j21wOmgbUqsZ2hL72NsUU785g9RXgo3s0ZNgVl42TiHp3ZtOv/Vyg==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/encoding-sniffer": {
+      "version": "0.2.1",
+      "resolved": "https://registry.npmjs.org/encoding-sniffer/-/encoding-sniffer-0.2.1.tgz",
+      "integrity": "sha512-5gvq20T6vfpekVtqrYQsSCFZ1wEg5+wW0/QaZMWkFr6BqD3NfKs0rLCx4rrVlSWJeZb5NBJgVLswK/w2MWU+Gw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "iconv-lite": "^0.6.3",
+        "whatwg-encoding": "^3.1.1"
+      },
+      "funding": {
+        "url": "https://github.com/fb55/encoding-sniffer?sponsor=1"
+      }
+    },
+    "node_modules/encoding-sniffer/node_modules/iconv-lite": {
+      "version": "0.6.3",
+      "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.6.3.tgz",
+      "integrity": "sha512-4fCk79wshMdzMp2rH06qWrJE4iolqLhCUH+OiuIgU++RB0+94NlDL81atO7GX55uUKueo0txHNtvEyI6D7WdMw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "safer-buffer": ">= 2.1.2 < 3.0.0"
+      },
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/end-of-stream": {
+      "version": "1.4.5",
+      "resolved": "https://registry.npmjs.org/end-of-stream/-/end-of-stream-1.4.5.tgz",
+      "integrity": "sha512-ooEGc6HP26xXq/N+GCGOT0JKCLDGrq2bQUZrQ7gyrJiZANJ/8YDTxTpQBXGMn+WbIQXNVpyWymm7KYVICQnyOg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "once": "^1.4.0"
+      }
+    },
+    "node_modules/entities": {
+      "version": "4.5.0",
+      "resolved": "https://registry.npmjs.org/entities/-/entities-4.5.0.tgz",
+      "integrity": "sha512-V0hjH4dGPh9Ao5p0MoRY6BVqtwCjhz6vI5LT8AJ55H+4g9/4vbHx1I54fS0XuclLhDHArPQCiMjDxjaL8fPxhw==",
+      "dev": true,
+      "license": "BSD-2-Clause",
+      "engines": {
+        "node": ">=0.12"
+      },
+      "funding": {
+        "url": "https://github.com/fb55/entities?sponsor=1"
+      }
+    },
+    "node_modules/error-ex": {
+      "version": "1.3.4",
+      "resolved": "https://registry.npmjs.org/error-ex/-/error-ex-1.3.4.tgz",
+      "integrity": "sha512-sqQamAnR14VgCr1A618A3sGrygcpK+HEbenA/HiEAkkUwcZIIB/tgWqHFxWgOyDh4nB4JCRimh79dR5Ywc9MDQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "is-arrayish": "^0.2.1"
+      }
+    },
+    "node_modules/es-module-lexer": {
+      "version": "1.7.0",
+      "resolved": "https://registry.npmjs.org/es-module-lexer/-/es-module-lexer-1.7.0.tgz",
+      "integrity": "sha512-jEQoCwk8hyb2AZziIOLhDqpm5+2ww5uIE6lkO/6jcOCusfk6LhMHpXXfBLXTZ7Ydyt0j4VoUQv6uGNYbdW+kBA==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/esbuild": {
+      "version": "0.27.3",
+      "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.27.3.tgz",
+      "integrity": "sha512-8VwMnyGCONIs6cWue2IdpHxHnAjzxnw2Zr7MkVxB2vjmQ2ivqGFb4LEG3SMnv0Gb2F/G/2yA8zUaiL1gywDCCg==",
+      "dev": true,
+      "hasInstallScript": true,
+      "license": "MIT",
+      "bin": {
+        "esbuild": "bin/esbuild"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "optionalDependencies": {
+        "@esbuild/aix-ppc64": "0.27.3",
+        "@esbuild/android-arm": "0.27.3",
+        "@esbuild/android-arm64": "0.27.3",
+        "@esbuild/android-x64": "0.27.3",
+        "@esbuild/darwin-arm64": "0.27.3",
+        "@esbuild/darwin-x64": "0.27.3",
+        "@esbuild/freebsd-arm64": "0.27.3",
+        "@esbuild/freebsd-x64": "0.27.3",
+        "@esbuild/linux-arm": "0.27.3",
+        "@esbuild/linux-arm64": "0.27.3",
+        "@esbuild/linux-ia32": "0.27.3",
+        "@esbuild/linux-loong64": "0.27.3",
+        "@esbuild/linux-mips64el": "0.27.3",
+        "@esbuild/linux-ppc64": "0.27.3",
+        "@esbuild/linux-riscv64": "0.27.3",
+        "@esbuild/linux-s390x": "0.27.3",
+        "@esbuild/linux-x64": "0.27.3",
+        "@esbuild/netbsd-arm64": "0.27.3",
+        "@esbuild/netbsd-x64": "0.27.3",
+        "@esbuild/openbsd-arm64": "0.27.3",
+        "@esbuild/openbsd-x64": "0.27.3",
+        "@esbuild/openharmony-arm64": "0.27.3",
+        "@esbuild/sunos-x64": "0.27.3",
+        "@esbuild/win32-arm64": "0.27.3",
+        "@esbuild/win32-ia32": "0.27.3",
+        "@esbuild/win32-x64": "0.27.3"
+      }
+    },
+    "node_modules/escalade": {
+      "version": "3.2.0",
+      "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.2.0.tgz",
+      "integrity": "sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/escape-string-regexp": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-4.0.0.tgz",
+      "integrity": "sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/escodegen": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/escodegen/-/escodegen-2.1.0.tgz",
+      "integrity": "sha512-2NlIDTwUWJN0mRPQOdtQBzbUHvdGY2P1VXSyU83Q3xKxM7WHX2Ql8dKq782Q9TgQUNOLEzEYu9bzLNj1q88I5w==",
+      "dev": true,
+      "license": "BSD-2-Clause",
+      "dependencies": {
+        "esprima": "^4.0.1",
+        "estraverse": "^5.2.0",
+        "esutils": "^2.0.2"
+      },
+      "bin": {
+        "escodegen": "bin/escodegen.js",
+        "esgenerate": "bin/esgenerate.js"
+      },
+      "engines": {
+        "node": ">=6.0"
+      },
+      "optionalDependencies": {
+        "source-map": "~0.6.1"
+      }
+    },
+    "node_modules/esm-env": {
+      "version": "1.2.2",
+      "resolved": "https://registry.npmjs.org/esm-env/-/esm-env-1.2.2.tgz",
+      "integrity": "sha512-Epxrv+Nr/CaL4ZcFGPJIYLWFom+YeV1DqMLHJoEd9SYRxNbaFruBwfEX/kkHUJf55j2+TUbmDcmuilbP1TmXHA==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/esprima": {
+      "version": "4.0.1",
+      "resolved": "https://registry.npmjs.org/esprima/-/esprima-4.0.1.tgz",
+      "integrity": "sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A==",
+      "dev": true,
+      "license": "BSD-2-Clause",
+      "bin": {
+        "esparse": "bin/esparse.js",
+        "esvalidate": "bin/esvalidate.js"
+      },
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/esrap": {
+      "version": "2.2.3",
+      "resolved": "https://registry.npmjs.org/esrap/-/esrap-2.2.3.tgz",
+      "integrity": "sha512-8fOS+GIGCQZl/ZIlhl59htOlms6U8NvX6ZYgYHpRU/b6tVSh3uHkOHZikl3D4cMbYM0JlpBe+p/BkZEi8J9XIQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jridgewell/sourcemap-codec": "^1.4.15"
+      }
+    },
+    "node_modules/estraverse": {
+      "version": "5.3.0",
+      "resolved": "https://registry.npmjs.org/estraverse/-/estraverse-5.3.0.tgz",
+      "integrity": "sha512-MMdARuVEQziNTeJD8DgMqmhwR11BRQ/cBP+pLtYdSTnf3MIO8fFeiINEbX36ZdNlfU/7A9f3gUw49B3oQsvwBA==",
+      "dev": true,
+      "license": "BSD-2-Clause",
+      "engines": {
+        "node": ">=4.0"
+      }
+    },
+    "node_modules/estree-walker": {
+      "version": "3.0.3",
+      "resolved": "https://registry.npmjs.org/estree-walker/-/estree-walker-3.0.3.tgz",
+      "integrity": "sha512-7RUKfXgSMMkzt6ZuXmqapOurLGPPfgj6l9uRZ7lRGolvk0y2yocc35LdcxKC5PQZdn2DMqioAQ2NoWcrTKmm6g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/estree": "^1.0.0"
+      }
+    },
+    "node_modules/esutils": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/esutils/-/esutils-2.0.3.tgz",
+      "integrity": "sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g==",
+      "dev": true,
+      "license": "BSD-2-Clause",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/event-target-shim": {
+      "version": "5.0.1",
+      "resolved": "https://registry.npmjs.org/event-target-shim/-/event-target-shim-5.0.1.tgz",
+      "integrity": "sha512-i/2XbnSz/uxRCU6+NdVJgKWDTM427+MqYbkQzD321DuCQJUqOuJKIA0IM2+W2xtYHdKOmZ4dR6fExsd4SXL+WQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/events": {
+      "version": "3.3.0",
+      "resolved": "https://registry.npmjs.org/events/-/events-3.3.0.tgz",
+      "integrity": "sha512-mQw+2fkQbALzQ7V0MY0IqdnXNOeTtP4r0lN9z7AAawCXgqea7bDii20AYrIBrFd/Hx0M2Ocz6S111CaFkUcb0Q==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.8.x"
+      }
+    },
+    "node_modules/events-universal": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/events-universal/-/events-universal-1.0.1.tgz",
+      "integrity": "sha512-LUd5euvbMLpwOF8m6ivPCbhQeSiYVNb8Vs0fQ8QjXo0JTkEHpz8pxdQf0gStltaPpw0Cca8b39KxvK9cfKRiAw==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "bare-events": "^2.7.0"
+      }
+    },
+    "node_modules/execa": {
+      "version": "9.6.1",
+      "resolved": "https://registry.npmjs.org/execa/-/execa-9.6.1.tgz",
+      "integrity": "sha512-9Be3ZoN4LmYR90tUoVu2te2BsbzHfhJyfEiAVfz7N5/zv+jduIfLrV2xdQXOHbaD6KgpGdO9PRPM1Y4Q9QkPkA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@sindresorhus/merge-streams": "^4.0.0",
+        "cross-spawn": "^7.0.6",
+        "figures": "^6.1.0",
+        "get-stream": "^9.0.0",
+        "human-signals": "^8.0.1",
+        "is-plain-obj": "^4.1.0",
+        "is-stream": "^4.0.1",
+        "npm-run-path": "^6.0.0",
+        "pretty-ms": "^9.2.0",
+        "signal-exit": "^4.1.0",
+        "strip-final-newline": "^4.0.0",
+        "yoctocolors": "^2.1.1"
+      },
+      "engines": {
+        "node": "^18.19.0 || >=20.5.0"
+      },
+      "funding": {
+        "url": "https://github.com/sindresorhus/execa?sponsor=1"
+      }
+    },
+    "node_modules/exit-hook": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/exit-hook/-/exit-hook-4.0.0.tgz",
+      "integrity": "sha512-Fqs7ChZm72y40wKjOFXBKg7nJZvQJmewP5/7LtePDdnah/+FH9Hp5sgMujSCMPXlxOAW2//1jrW9pnsY7o20vQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/expect": {
+      "version": "30.2.0",
+      "resolved": "https://registry.npmjs.org/expect/-/expect-30.2.0.tgz",
+      "integrity": "sha512-u/feCi0GPsI+988gU2FLcsHyAHTU0MX1Wg68NhAnN7z/+C5wqG+CY8J53N9ioe8RXgaoz0nBR/TYMf3AycUuPw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jest/expect-utils": "30.2.0",
+        "@jest/get-type": "30.1.0",
+        "jest-matcher-utils": "30.2.0",
+        "jest-message-util": "30.2.0",
+        "jest-mock": "30.2.0",
+        "jest-util": "30.2.0"
+      },
+      "engines": {
+        "node": "^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0"
+      }
+    },
+    "node_modules/expect-type": {
+      "version": "1.3.0",
+      "resolved": "https://registry.npmjs.org/expect-type/-/expect-type-1.3.0.tgz",
+      "integrity": "sha512-knvyeauYhqjOYvQ66MznSMs83wmHrCycNEN6Ao+2AeYEfxUIkuiVxdEa1qlGEPK+We3n0THiDciYSsCcgW/DoA==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "engines": {
+        "node": ">=12.0.0"
+      }
+    },
+    "node_modules/expect-webdriverio": {
+      "version": "5.6.4",
+      "resolved": "https://registry.npmjs.org/expect-webdriverio/-/expect-webdriverio-5.6.4.tgz",
+      "integrity": "sha512-Bkoqs+39fHwjos51qab7ZWmvZrYNBbzgSAIykH2CrgLOLhHJXzC30DP9lZq2MsmaUsbBnN5c5m8VqAhOHTrCRw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@vitest/snapshot": "^4.0.16",
+        "deep-eql": "^5.0.2",
+        "expect": "^30.2.0",
+        "jest-matcher-utils": "^30.2.0"
+      },
+      "engines": {
+        "node": ">=20"
+      },
+      "peerDependencies": {
+        "@wdio/globals": "^9.0.0",
+        "@wdio/logger": "^9.0.0",
+        "webdriverio": "^9.0.0"
+      },
+      "peerDependenciesMeta": {
+        "@wdio/globals": {
+          "optional": false
+        },
+        "@wdio/logger": {
+          "optional": false
+        },
+        "webdriverio": {
+          "optional": false
+        }
+      }
+    },
+    "node_modules/extract-zip": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/extract-zip/-/extract-zip-2.0.1.tgz",
+      "integrity": "sha512-GDhU9ntwuKyGXdZBUgTIe+vXnWj0fppUEtMDL0+idd5Sta8TGpHssn/eusA9mrPr9qNDym6SxAYZjNvCn/9RBg==",
+      "dev": true,
+      "license": "BSD-2-Clause",
+      "dependencies": {
+        "debug": "^4.1.1",
+        "get-stream": "^5.1.0",
+        "yauzl": "^2.10.0"
+      },
+      "bin": {
+        "extract-zip": "cli.js"
+      },
+      "engines": {
+        "node": ">= 10.17.0"
+      },
+      "optionalDependencies": {
+        "@types/yauzl": "^2.9.1"
+      }
+    },
+    "node_modules/extract-zip/node_modules/get-stream": {
+      "version": "5.2.0",
+      "resolved": "https://registry.npmjs.org/get-stream/-/get-stream-5.2.0.tgz",
+      "integrity": "sha512-nBF+F1rAZVCu/p7rjzgA+Yb4lfYXrpl7a6VmJrU8wF9I1CKvP/QwPNZHnOlwbTkY6dvtFIzFMSyQXbLoTQPRpA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "pump": "^3.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/fast-deep-equal": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-2.0.1.tgz",
+      "integrity": "sha512-bCK/2Z4zLidyB4ReuIsvALH6w31YfAQDmXMqMx6FyfHqvBxtjC0eRumeSu4Bs3XtXwpyIywtSTrVT99BxY1f9w==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/fast-fifo": {
+      "version": "1.3.2",
+      "resolved": "https://registry.npmjs.org/fast-fifo/-/fast-fifo-1.3.2.tgz",
+      "integrity": "sha512-/d9sfos4yxzpwkDkuN7k2SqFKtYNmCTzgfEpz82x34IM9/zc8KGxQoXg1liNC/izpRM/MBdt44Nmx41ZWqk+FQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/fast-xml-builder": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/fast-xml-builder/-/fast-xml-builder-1.0.0.tgz",
+      "integrity": "sha512-fpZuDogrAgnyt9oDDz+5DBz0zgPdPZz6D4IR7iESxRXElrlGTRkHJ9eEt+SACRJwT0FNFrt71DFQIUFBJfX/uQ==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/NaturalIntelligence"
+        }
+      ],
+      "license": "MIT"
+    },
+    "node_modules/fast-xml-parser": {
+      "version": "5.4.2",
+      "resolved": "https://registry.npmjs.org/fast-xml-parser/-/fast-xml-parser-5.4.2.tgz",
+      "integrity": "sha512-pw/6pIl4k0CSpElPEJhDppLzaixDEuWui2CUQQBH/ECDf7+y6YwA4Gf7Tyb0Rfe4DIMuZipYj4AEL0nACKglvQ==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/NaturalIntelligence"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "fast-xml-builder": "^1.0.0",
+        "strnum": "^2.1.2"
+      },
+      "bin": {
+        "fxparser": "src/cli/cli.js"
+      }
+    },
+    "node_modules/fd-slicer": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/fd-slicer/-/fd-slicer-1.1.0.tgz",
+      "integrity": "sha512-cE1qsB/VwyQozZ+q1dGxR8LBYNZeofhEdUNGSMbQD3Gw2lAzX9Zb3uIU6Ebc/Fmyjo9AWWfnn0AUCHqtevs/8g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "pend": "~1.2.0"
+      }
+    },
+    "node_modules/fdir": {
+      "version": "6.5.0",
+      "resolved": "https://registry.npmjs.org/fdir/-/fdir-6.5.0.tgz",
+      "integrity": "sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=12.0.0"
+      },
+      "peerDependencies": {
+        "picomatch": "^3 || ^4"
+      },
+      "peerDependenciesMeta": {
+        "picomatch": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/figures": {
+      "version": "6.1.0",
+      "resolved": "https://registry.npmjs.org/figures/-/figures-6.1.0.tgz",
+      "integrity": "sha512-d+l3qxjSesT4V7v2fh+QnmFnUWv9lSpjarhShNTgBOfA0ttejbQUAlHLitbjkoRiDulW0OPoQPYIGhIC8ohejg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "is-unicode-supported": "^2.0.0"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/filelist": {
+      "version": "1.0.6",
+      "resolved": "https://registry.npmjs.org/filelist/-/filelist-1.0.6.tgz",
+      "integrity": "sha512-5giy2PkLYY1cP39p17Ech+2xlpTRL9HLspOfEgm0L6CwBXBTgsK5ou0JtzYuepxkaQ/tvhCFIJ5uXo0OrM2DxA==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "minimatch": "^5.0.1"
+      }
+    },
+    "node_modules/filelist/node_modules/minimatch": {
+      "version": "5.1.9",
+      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-5.1.9.tgz",
+      "integrity": "sha512-7o1wEA2RyMP7Iu7GNba9vc0RWWGACJOCZBJX2GJWip0ikV+wcOsgVuY9uE8CPiyQhkGFSlhuSkZPavN7u1c2Fw==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "brace-expansion": "^2.0.1"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/fill-range": {
+      "version": "7.1.1",
+      "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-7.1.1.tgz",
+      "integrity": "sha512-YsGpe3WHLK8ZYi4tWDg2Jy3ebRz2rXowDxnld4bkQB00cc/1Zw9AWnC0i9ztDJitivtQvaI9KaLyKrc+hBW0yg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "to-regex-range": "^5.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/find-up": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/find-up/-/find-up-5.0.0.tgz",
+      "integrity": "sha512-78/PXT1wlLLDgTzDs7sjq9hzz0vXD+zn+7wypEe4fXQxCmdmqfGsEPQxmiCSQI3ajFV91bVSsvNtrJRiW6nGng==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "locate-path": "^6.0.0",
+        "path-exists": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/flat": {
+      "version": "5.0.2",
+      "resolved": "https://registry.npmjs.org/flat/-/flat-5.0.2.tgz",
+      "integrity": "sha512-b6suED+5/3rTpUBdG1gupIl8MPFCAMA0QXwmljLhvCUKcUvdE4gWky9zpuGCcXHOsz4J9wPGNWq6OKpmIzz3hQ==",
+      "dev": true,
+      "license": "BSD-3-Clause",
+      "bin": {
+        "flat": "cli.js"
+      }
+    },
+    "node_modules/foreground-child": {
+      "version": "3.3.1",
+      "resolved": "https://registry.npmjs.org/foreground-child/-/foreground-child-3.3.1.tgz",
+      "integrity": "sha512-gIXjKqtFuWEgzFRJA9WCQeSJLZDjgJUOMCMzxtvFq/37KojM1BFGufqsCy0r4qSQmYLsZYMeyRqzIWOMup03sw==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "cross-spawn": "^7.0.6",
+        "signal-exit": "^4.0.1"
+      },
+      "engines": {
+        "node": ">=14"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      }
+    },
+    "node_modules/fs.realpath": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/fs.realpath/-/fs.realpath-1.0.0.tgz",
+      "integrity": "sha512-OO0pH2lK6a0hZnAdau5ItzHPI6pUlvI7jMVnxUQRtw4owF2wk8lOSabtGDCTP4Ggrg2MbGnWO9X8K1t4+fGMDw==",
+      "dev": true,
+      "license": "ISC"
+    },
+    "node_modules/fsevents": {
+      "version": "2.3.3",
+      "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz",
+      "integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==",
+      "dev": true,
+      "hasInstallScript": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": "^8.16.0 || ^10.6.0 || >=11.0.0"
+      }
+    },
+    "node_modules/geckodriver": {
+      "version": "6.1.0",
+      "resolved": "https://registry.npmjs.org/geckodriver/-/geckodriver-6.1.0.tgz",
+      "integrity": "sha512-ZRXLa4ZaYTTgUO4Eefw+RsQCleugU2QLb1ME7qTYxxuRj51yAhfnXaItXNs5/vUzfIaDHuZ+YnSF005hfp07nQ==",
+      "dev": true,
+      "hasInstallScript": true,
+      "license": "MIT",
+      "dependencies": {
+        "@wdio/logger": "^9.18.0",
+        "@zip.js/zip.js": "^2.8.11",
+        "decamelize": "^6.0.1",
+        "http-proxy-agent": "^7.0.2",
+        "https-proxy-agent": "^7.0.6",
+        "modern-tar": "^0.7.2"
+      },
+      "bin": {
+        "geckodriver": "bin/geckodriver.js"
+      },
+      "engines": {
+        "node": ">=20.0.0"
+      }
+    },
+    "node_modules/get-caller-file": {
+      "version": "2.0.5",
+      "resolved": "https://registry.npmjs.org/get-caller-file/-/get-caller-file-2.0.5.tgz",
+      "integrity": "sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg==",
+      "dev": true,
+      "license": "ISC",
+      "engines": {
+        "node": "6.* || 8.* || >= 10.*"
+      }
+    },
+    "node_modules/get-port": {
+      "version": "7.1.0",
+      "resolved": "https://registry.npmjs.org/get-port/-/get-port-7.1.0.tgz",
+      "integrity": "sha512-QB9NKEeDg3xxVwCCwJQ9+xycaz6pBB6iQ76wiWMl1927n0Kir6alPiP+yuiICLLU4jpMe08dXfpebuQppFA2zw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=16"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/get-stream": {
+      "version": "9.0.1",
+      "resolved": "https://registry.npmjs.org/get-stream/-/get-stream-9.0.1.tgz",
+      "integrity": "sha512-kVCxPF3vQM/N0B1PmoqVUqgHP+EeVjmZSQn+1oCRPxd2P21P2F19lIgbR3HBosbB1PUhOAoctJnfEn2GbN2eZA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@sec-ant/readable-stream": "^0.4.1",
+        "is-stream": "^4.0.1"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/get-tsconfig": {
+      "version": "4.13.6",
+      "resolved": "https://registry.npmjs.org/get-tsconfig/-/get-tsconfig-4.13.6.tgz",
+      "integrity": "sha512-shZT/QMiSHc/YBLxxOkMtgSid5HFoauqCE3/exfsEcwg1WkeqjG+V40yBbBrsD+jW2HDXcs28xOfcbm2jI8Ddw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "resolve-pkg-maps": "^1.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/privatenumber/get-tsconfig?sponsor=1"
+      }
+    },
+    "node_modules/get-uri": {
+      "version": "6.0.5",
+      "resolved": "https://registry.npmjs.org/get-uri/-/get-uri-6.0.5.tgz",
+      "integrity": "sha512-b1O07XYq8eRuVzBNgJLstU6FYc1tS6wnMtF1I1D9lE8LxZSOGZ7LhxN54yPP6mGw5f2CkXY2BQUL9Fx41qvcIg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "basic-ftp": "^5.0.2",
+        "data-uri-to-buffer": "^6.0.2",
+        "debug": "^4.3.4"
+      },
+      "engines": {
+        "node": ">= 14"
+      }
+    },
+    "node_modules/glob": {
+      "version": "10.5.0",
+      "resolved": "https://registry.npmjs.org/glob/-/glob-10.5.0.tgz",
+      "integrity": "sha512-DfXN8DfhJ7NH3Oe7cFmu3NCu1wKbkReJ8TorzSAFbSKrlNaQSKfIzqYqVY8zlbs2NLBbWpRiU52GX2PbaBVNkg==",
+      "deprecated": "Old versions of glob are not supported, and contain widely publicized security vulnerabilities, which have been fixed in the current version. Please update. Support for old versions may be purchased (at exorbitant rates) by contacting i@izs.me",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "foreground-child": "^3.1.0",
+        "jackspeak": "^3.1.2",
+        "minimatch": "^9.0.4",
+        "minipass": "^7.1.2",
+        "package-json-from-dist": "^1.0.0",
+        "path-scurry": "^1.11.1"
+      },
+      "bin": {
+        "glob": "dist/esm/bin.mjs"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      }
+    },
+    "node_modules/glob-parent": {
+      "version": "5.1.2",
+      "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-5.1.2.tgz",
+      "integrity": "sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "is-glob": "^4.0.1"
+      },
+      "engines": {
+        "node": ">= 6"
+      }
+    },
+    "node_modules/graceful-fs": {
+      "version": "4.2.11",
+      "resolved": "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.2.11.tgz",
+      "integrity": "sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ==",
+      "dev": true,
+      "license": "ISC"
+    },
+    "node_modules/grapheme-splitter": {
+      "version": "1.0.4",
+      "resolved": "https://registry.npmjs.org/grapheme-splitter/-/grapheme-splitter-1.0.4.tgz",
+      "integrity": "sha512-bzh50DW9kTPM00T8y4o8vQg89Di9oLJVLW/KaOGIXJWP/iqCN6WKYkbNOF04vFLJhwcpYUh9ydh/+5vpOqV4YQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/has-flag": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz",
+      "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/hast-util-to-html": {
+      "version": "9.0.5",
+      "resolved": "https://registry.npmjs.org/hast-util-to-html/-/hast-util-to-html-9.0.5.tgz",
+      "integrity": "sha512-OguPdidb+fbHQSU4Q4ZiLKnzWo8Wwsf5bZfbvu7//a9oTYoqD/fWpe96NuHkoS9h0ccGOTe0C4NGXdtS0iObOw==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/hast": "^3.0.0",
+        "@types/unist": "^3.0.0",
+        "ccount": "^2.0.0",
+        "comma-separated-tokens": "^2.0.0",
+        "hast-util-whitespace": "^3.0.0",
+        "html-void-elements": "^3.0.0",
+        "mdast-util-to-hast": "^13.0.0",
+        "property-information": "^7.0.0",
+        "space-separated-tokens": "^2.0.0",
+        "stringify-entities": "^4.0.0",
+        "zwitch": "^2.0.4"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/hast-util-whitespace": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/hast-util-whitespace/-/hast-util-whitespace-3.0.0.tgz",
+      "integrity": "sha512-88JUN06ipLwsnv+dVn+OIYOvAuvBMy/Qoi6O7mQHxdPXpjy+Cd6xRkWwux7DKO+4sYILtLBRIKgsdpS2gQc7qw==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/hast": "^3.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/he": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/he/-/he-1.2.0.tgz",
+      "integrity": "sha512-F/1DnUGPopORZi0ni+CvrCgHQ5FyEAHRLSApuYWMmrbSwoN2Mn/7k+Gl38gJnR7yyDZk6WLXwiGod1JOWNDKGw==",
+      "dev": true,
+      "license": "MIT",
+      "bin": {
+        "he": "bin/he"
+      }
+    },
+    "node_modules/hosted-git-info": {
+      "version": "8.1.0",
+      "resolved": "https://registry.npmjs.org/hosted-git-info/-/hosted-git-info-8.1.0.tgz",
+      "integrity": "sha512-Rw/B2DNQaPBICNXEm8balFz9a6WpZrkCGpcWFpy7nCj+NyhSdqXipmfvtmWt9xGfp0wZnBxB+iVpLmQMYt47Tw==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "lru-cache": "^10.0.1"
+      },
+      "engines": {
+        "node": "^18.17.0 || >=20.5.0"
+      }
+    },
+    "node_modules/html-void-elements": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/html-void-elements/-/html-void-elements-3.0.0.tgz",
+      "integrity": "sha512-bEqo66MRXsUGxWHV5IP0PUiAWwoEjba4VCzg0LjFJBpchPaTfyfCKTG6bc5F8ucKec3q5y6qOdGyYTSBEvhCrg==",
+      "license": "MIT",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
+    "node_modules/htmlfy": {
+      "version": "0.8.1",
+      "resolved": "https://registry.npmjs.org/htmlfy/-/htmlfy-0.8.1.tgz",
+      "integrity": "sha512-xWROBw9+MEGwxpotll0h672KCaLrKKiCYzsyN8ZgL9cQbVumFnyvsk2JqiB9ELAV1GLj1GG/jxZUjV9OZZi/yQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/htmlparser2": {
+      "version": "10.1.0",
+      "resolved": "https://registry.npmjs.org/htmlparser2/-/htmlparser2-10.1.0.tgz",
+      "integrity": "sha512-VTZkM9GWRAtEpveh7MSF6SjjrpNVNNVJfFup7xTY3UpFtm67foy9HDVXneLtFVt4pMz5kZtgNcvCniNFb1hlEQ==",
+      "dev": true,
+      "funding": [
+        "https://github.com/fb55/htmlparser2?sponsor=1",
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/fb55"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "domelementtype": "^2.3.0",
+        "domhandler": "^5.0.3",
+        "domutils": "^3.2.2",
+        "entities": "^7.0.1"
+      }
+    },
+    "node_modules/htmlparser2/node_modules/entities": {
+      "version": "7.0.1",
+      "resolved": "https://registry.npmjs.org/entities/-/entities-7.0.1.tgz",
+      "integrity": "sha512-TWrgLOFUQTH994YUyl1yT4uyavY5nNB5muff+RtWaqNVCAK408b5ZnnbNAUEWLTCpum9w6arT70i1XdQ4UeOPA==",
+      "dev": true,
+      "license": "BSD-2-Clause",
+      "engines": {
+        "node": ">=0.12"
+      },
+      "funding": {
+        "url": "https://github.com/fb55/entities?sponsor=1"
+      }
+    },
+    "node_modules/http-proxy-agent": {
+      "version": "7.0.2",
+      "resolved": "https://registry.npmjs.org/http-proxy-agent/-/http-proxy-agent-7.0.2.tgz",
+      "integrity": "sha512-T1gkAiYYDWYx3V5Bmyu7HcfcvL7mUrTWiM6yOfa3PIphViJ/gFPbvidQ+veqSOHci/PxBcDabeUNCzpOODJZig==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "agent-base": "^7.1.0",
+        "debug": "^4.3.4"
+      },
+      "engines": {
+        "node": ">= 14"
+      }
+    },
+    "node_modules/https-proxy-agent": {
+      "version": "7.0.6",
+      "resolved": "https://registry.npmjs.org/https-proxy-agent/-/https-proxy-agent-7.0.6.tgz",
+      "integrity": "sha512-vK9P5/iUfdl95AI+JVyUuIcVtd4ofvtrOr3HNtM2yxC9bnMbEdp3x01OhQNnjb8IJYi38VlTE3mBXwcfvywuSw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "agent-base": "^7.1.2",
+        "debug": "4"
+      },
+      "engines": {
+        "node": ">= 14"
+      }
+    },
+    "node_modules/human-signals": {
+      "version": "8.0.1",
+      "resolved": "https://registry.npmjs.org/human-signals/-/human-signals-8.0.1.tgz",
+      "integrity": "sha512-eKCa6bwnJhvxj14kZk5NCPc6Hb6BdsU9DZcOnmQKSnO1VKrfV0zCvtttPZUsBvjmNDn8rpcJfpwSYnHBjc95MQ==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "engines": {
+        "node": ">=18.18.0"
+      }
+    },
+    "node_modules/iconv-lite": {
+      "version": "0.7.2",
+      "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.7.2.tgz",
+      "integrity": "sha512-im9DjEDQ55s9fL4EYzOAv0yMqmMBSZp6G0VvFyTMPKWxiSBHUj9NW/qqLmXUwXrrM7AvqSlTCfvqRb0cM8yYqw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "safer-buffer": ">= 2.1.2 < 3.0.0"
+      },
+      "engines": {
+        "node": ">=0.10.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/express"
+      }
+    },
+    "node_modules/ieee754": {
+      "version": "1.2.1",
+      "resolved": "https://registry.npmjs.org/ieee754/-/ieee754-1.2.1.tgz",
+      "integrity": "sha512-dcyqhDvX1C46lXZcVqCpK+FtMRQVdIMN6/Df5js2zouUsqG7I6sFxitIC+7KYK29KdXOLHdu9zL4sFnoVQnqaA==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/feross"
+        },
+        {
+          "type": "patreon",
+          "url": "https://www.patreon.com/feross"
+        },
+        {
+          "type": "consulting",
+          "url": "https://feross.org/support"
+        }
+      ],
+      "license": "BSD-3-Clause"
+    },
+    "node_modules/immediate": {
+      "version": "3.0.6",
+      "resolved": "https://registry.npmjs.org/immediate/-/immediate-3.0.6.tgz",
+      "integrity": "sha512-XXOFtyqDjNDAQxVfYxuF7g9Il/IbWmmlQg2MYKOH8ExIT1qg6xc4zyS3HaEEATgs1btfzxq15ciUiY7gjSXRGQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/import-meta-resolve": {
+      "version": "4.2.0",
+      "resolved": "https://registry.npmjs.org/import-meta-resolve/-/import-meta-resolve-4.2.0.tgz",
+      "integrity": "sha512-Iqv2fzaTQN28s/FwZAoFq0ZSs/7hMAHJVX+w8PZl3cY19Pxk6jFFalxQoIfW2826i/fDLXv8IiEZRIT0lDuWcg==",
+      "dev": true,
+      "license": "MIT",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
+    "node_modules/inflight": {
+      "version": "1.0.6",
+      "resolved": "https://registry.npmjs.org/inflight/-/inflight-1.0.6.tgz",
+      "integrity": "sha512-k92I/b08q4wvFscXCLvqfsHCrjrF7yiXsQuIVvVE7N82W3+aqpzuUdBbfhWcy/FZR3/4IgflMgKLOsvPDrGCJA==",
+      "deprecated": "This module is not supported, and leaks memory. Do not use it. Check out lru-cache if you want a good and tested way to coalesce async requests by a key value, which is much more comprehensive and powerful.",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "once": "^1.3.0",
+        "wrappy": "1"
+      }
+    },
+    "node_modules/inherits": {
+      "version": "2.0.4",
+      "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz",
+      "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==",
+      "dev": true,
+      "license": "ISC"
+    },
+    "node_modules/inquirer": {
+      "version": "12.11.1",
+      "resolved": "https://registry.npmjs.org/inquirer/-/inquirer-12.11.1.tgz",
+      "integrity": "sha512-9VF7mrY+3OmsAfjH3yKz/pLbJ5z22E23hENKw3/LNSaA/sAt3v49bDRY+Ygct1xwuKT+U+cBfTzjCPySna69Qw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@inquirer/ansi": "^1.0.2",
+        "@inquirer/core": "^10.3.2",
+        "@inquirer/prompts": "^7.10.1",
+        "@inquirer/type": "^3.0.10",
+        "mute-stream": "^2.0.0",
+        "run-async": "^4.0.6",
+        "rxjs": "^7.8.2"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "peerDependencies": {
+        "@types/node": ">=18"
+      },
+      "peerDependenciesMeta": {
+        "@types/node": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/ip-address": {
+      "version": "10.1.0",
+      "resolved": "https://registry.npmjs.org/ip-address/-/ip-address-10.1.0.tgz",
+      "integrity": "sha512-XXADHxXmvT9+CRxhXg56LJovE+bmWnEWB78LB83VZTprKTmaC5QfruXocxzTZ2Kl0DNwKuBdlIhjL8LeY8Sf8Q==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 12"
+      }
+    },
+    "node_modules/is-arrayish": {
+      "version": "0.2.1",
+      "resolved": "https://registry.npmjs.org/is-arrayish/-/is-arrayish-0.2.1.tgz",
+      "integrity": "sha512-zz06S8t0ozoDXMG+ube26zeCTNXcKIPJZJi8hBrF4idCLms4CG9QtK7qBl1boi5ODzFpjswb5JPmHCbMpjaYzg==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/is-binary-path": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/is-binary-path/-/is-binary-path-2.1.0.tgz",
+      "integrity": "sha512-ZMERYes6pDydyuGidse7OsHxtbI7WVeUEozgR/g7rd0xUimYNlvZRE/K2MgZTjWy725IfelLeVcEM97mmtRGXw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "binary-extensions": "^2.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/is-extglob": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/is-extglob/-/is-extglob-2.1.1.tgz",
+      "integrity": "sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/is-fullwidth-code-point": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz",
+      "integrity": "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/is-glob": {
+      "version": "4.0.3",
+      "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-4.0.3.tgz",
+      "integrity": "sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "is-extglob": "^2.1.1"
+      },
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/is-number": {
+      "version": "7.0.0",
+      "resolved": "https://registry.npmjs.org/is-number/-/is-number-7.0.0.tgz",
+      "integrity": "sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.12.0"
+      }
+    },
+    "node_modules/is-plain-obj": {
+      "version": "4.1.0",
+      "resolved": "https://registry.npmjs.org/is-plain-obj/-/is-plain-obj-4.1.0.tgz",
+      "integrity": "sha512-+Pgi+vMuUNkJyExiMBt5IlFoMyKnr5zhJ4Uspz58WOhBF5QoIZkFyNHIbBAtHwzVAgk5RtndVNsDRN61/mmDqg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/is-reference": {
+      "version": "3.0.3",
+      "resolved": "https://registry.npmjs.org/is-reference/-/is-reference-3.0.3.tgz",
+      "integrity": "sha512-ixkJoqQvAP88E6wLydLGGqCJsrFUnqoH6HnaczB8XmDH1oaWU+xxdptvikTgaEhtZ53Ky6YXiBuUI2WXLMCwjw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/estree": "^1.0.6"
+      }
+    },
+    "node_modules/is-stream": {
+      "version": "4.0.1",
+      "resolved": "https://registry.npmjs.org/is-stream/-/is-stream-4.0.1.tgz",
+      "integrity": "sha512-Dnz92NInDqYckGEUJv689RbRiTSEHCQ7wOVeALbkOz999YpqT46yMRIGtSNl2iCL1waAZSx40+h59NV/EwzV/A==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/is-unicode-supported": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/is-unicode-supported/-/is-unicode-supported-2.1.0.tgz",
+      "integrity": "sha512-mE00Gnza5EEB3Ds0HfMyllZzbBrmLOX3vfWoj9A9PEnTfratQ/BcaJOuMhnkhjXvb2+FkY3VuHqtAGpTPmglFQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/isarray": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/isarray/-/isarray-1.0.0.tgz",
+      "integrity": "sha512-VLghIWNM6ELQzo7zwmcg0NmTVyWKYjvIeM83yjp0wRDTmUnrM678fQbcKBo6n2CJEF0szoG//ytg+TKla89ALQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/isexe": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz",
+      "integrity": "sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==",
+      "dev": true,
+      "license": "ISC"
+    },
+    "node_modules/jackspeak": {
+      "version": "3.4.3",
+      "resolved": "https://registry.npmjs.org/jackspeak/-/jackspeak-3.4.3.tgz",
+      "integrity": "sha512-OGlZQpz2yfahA/Rd1Y8Cd9SIEsqvXkLVoSw/cgwhnhFMDbsQFeZYoJJ7bIZBS9BcamUW96asq/npPWugM+RQBw==",
+      "dev": true,
+      "license": "BlueOak-1.0.0",
+      "dependencies": {
+        "@isaacs/cliui": "^8.0.2"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      },
+      "optionalDependencies": {
+        "@pkgjs/parseargs": "^0.11.0"
+      }
+    },
+    "node_modules/jake": {
+      "version": "10.9.4",
+      "resolved": "https://registry.npmjs.org/jake/-/jake-10.9.4.tgz",
+      "integrity": "sha512-wpHYzhxiVQL+IV05BLE2Xn34zW1S223hvjtqk0+gsPrwd/8JNLXJgZZM/iPFsYc1xyphF+6M6EvdE5E9MBGkDA==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "async": "^3.2.6",
+        "filelist": "^1.0.4",
+        "picocolors": "^1.1.1"
+      },
+      "bin": {
+        "jake": "bin/cli.js"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/jest-diff": {
+      "version": "30.2.0",
+      "resolved": "https://registry.npmjs.org/jest-diff/-/jest-diff-30.2.0.tgz",
+      "integrity": "sha512-dQHFo3Pt4/NLlG5z4PxZ/3yZTZ1C7s9hveiOj+GCN+uT109NC2QgsoVZsVOAvbJ3RgKkvyLGXZV9+piDpWbm6A==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jest/diff-sequences": "30.0.1",
+        "@jest/get-type": "30.1.0",
+        "chalk": "^4.1.2",
+        "pretty-format": "30.2.0"
+      },
+      "engines": {
+        "node": "^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0"
+      }
+    },
+    "node_modules/jest-diff/node_modules/ansi-styles": {
+      "version": "4.3.0",
+      "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz",
+      "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "color-convert": "^2.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/ansi-styles?sponsor=1"
+      }
+    },
+    "node_modules/jest-diff/node_modules/chalk": {
+      "version": "4.1.2",
+      "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz",
+      "integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "ansi-styles": "^4.1.0",
+        "supports-color": "^7.1.0"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/chalk?sponsor=1"
+      }
+    },
+    "node_modules/jest-diff/node_modules/supports-color": {
+      "version": "7.2.0",
+      "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz",
+      "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "has-flag": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/jest-matcher-utils": {
+      "version": "30.2.0",
+      "resolved": "https://registry.npmjs.org/jest-matcher-utils/-/jest-matcher-utils-30.2.0.tgz",
+      "integrity": "sha512-dQ94Nq4dbzmUWkQ0ANAWS9tBRfqCrn0bV9AMYdOi/MHW726xn7eQmMeRTpX2ViC00bpNaWXq+7o4lIQ3AX13Hg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jest/get-type": "30.1.0",
+        "chalk": "^4.1.2",
+        "jest-diff": "30.2.0",
+        "pretty-format": "30.2.0"
+      },
+      "engines": {
+        "node": "^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0"
+      }
+    },
+    "node_modules/jest-matcher-utils/node_modules/ansi-styles": {
+      "version": "4.3.0",
+      "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz",
+      "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "color-convert": "^2.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/ansi-styles?sponsor=1"
+      }
+    },
+    "node_modules/jest-matcher-utils/node_modules/chalk": {
+      "version": "4.1.2",
+      "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz",
+      "integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "ansi-styles": "^4.1.0",
+        "supports-color": "^7.1.0"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/chalk?sponsor=1"
+      }
+    },
+    "node_modules/jest-matcher-utils/node_modules/supports-color": {
+      "version": "7.2.0",
+      "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz",
+      "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "has-flag": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/jest-message-util": {
+      "version": "30.2.0",
+      "resolved": "https://registry.npmjs.org/jest-message-util/-/jest-message-util-30.2.0.tgz",
+      "integrity": "sha512-y4DKFLZ2y6DxTWD4cDe07RglV88ZiNEdlRfGtqahfbIjfsw1nMCPx49Uev4IA/hWn3sDKyAnSPwoYSsAEdcimw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/code-frame": "^7.27.1",
+        "@jest/types": "30.2.0",
+        "@types/stack-utils": "^2.0.3",
+        "chalk": "^4.1.2",
+        "graceful-fs": "^4.2.11",
+        "micromatch": "^4.0.8",
+        "pretty-format": "30.2.0",
+        "slash": "^3.0.0",
+        "stack-utils": "^2.0.6"
+      },
+      "engines": {
+        "node": "^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0"
+      }
+    },
+    "node_modules/jest-message-util/node_modules/ansi-styles": {
+      "version": "4.3.0",
+      "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz",
+      "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "color-convert": "^2.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/ansi-styles?sponsor=1"
+      }
+    },
+    "node_modules/jest-message-util/node_modules/chalk": {
+      "version": "4.1.2",
+      "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz",
+      "integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "ansi-styles": "^4.1.0",
+        "supports-color": "^7.1.0"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/chalk?sponsor=1"
+      }
+    },
+    "node_modules/jest-message-util/node_modules/supports-color": {
+      "version": "7.2.0",
+      "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz",
+      "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "has-flag": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/jest-mock": {
+      "version": "30.2.0",
+      "resolved": "https://registry.npmjs.org/jest-mock/-/jest-mock-30.2.0.tgz",
+      "integrity": "sha512-JNNNl2rj4b5ICpmAcq+WbLH83XswjPbjH4T7yvGzfAGCPh1rw+xVNbtk+FnRslvt9lkCcdn9i1oAoKUuFsOxRw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jest/types": "30.2.0",
+        "@types/node": "*",
+        "jest-util": "30.2.0"
+      },
+      "engines": {
+        "node": "^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0"
+      }
+    },
+    "node_modules/jest-regex-util": {
+      "version": "30.0.1",
+      "resolved": "https://registry.npmjs.org/jest-regex-util/-/jest-regex-util-30.0.1.tgz",
+      "integrity": "sha512-jHEQgBXAgc+Gh4g0p3bCevgRCVRkB4VB70zhoAE48gxeSr1hfUOsM/C2WoJgVL7Eyg//hudYENbm3Ne+/dRVVA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": "^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0"
+      }
+    },
+    "node_modules/jest-util": {
+      "version": "30.2.0",
+      "resolved": "https://registry.npmjs.org/jest-util/-/jest-util-30.2.0.tgz",
+      "integrity": "sha512-QKNsM0o3Xe6ISQU869e+DhG+4CK/48aHYdJZGlFQVTjnbvgpcKyxpzk29fGiO7i/J8VENZ+d2iGnSsvmuHywlA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jest/types": "30.2.0",
+        "@types/node": "*",
+        "chalk": "^4.1.2",
+        "ci-info": "^4.2.0",
+        "graceful-fs": "^4.2.11",
+        "picomatch": "^4.0.2"
+      },
+      "engines": {
+        "node": "^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0"
+      }
+    },
+    "node_modules/jest-util/node_modules/ansi-styles": {
+      "version": "4.3.0",
+      "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz",
+      "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "color-convert": "^2.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/ansi-styles?sponsor=1"
+      }
+    },
+    "node_modules/jest-util/node_modules/chalk": {
+      "version": "4.1.2",
+      "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz",
+      "integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "ansi-styles": "^4.1.0",
+        "supports-color": "^7.1.0"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/chalk?sponsor=1"
+      }
+    },
+    "node_modules/jest-util/node_modules/supports-color": {
+      "version": "7.2.0",
+      "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz",
+      "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "has-flag": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/jiti": {
+      "version": "2.6.1",
+      "resolved": "https://registry.npmjs.org/jiti/-/jiti-2.6.1.tgz",
+      "integrity": "sha512-ekilCSN1jwRvIbgeg/57YFh8qQDNbwDb9xT/qu2DAHbFFZUicIl4ygVaAvzveMhMVr3LnpSKTNnwt8PoOfmKhQ==",
+      "dev": true,
+      "license": "MIT",
+      "bin": {
+        "jiti": "lib/jiti-cli.mjs"
+      }
+    },
+    "node_modules/js-tokens": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-4.0.0.tgz",
+      "integrity": "sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/js-yaml": {
+      "version": "4.1.1",
+      "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.1.tgz",
+      "integrity": "sha512-qQKT4zQxXl8lLwBtHMWwaTcGfFOZviOJet3Oy/xmGk2gZH677CJM9EvtfdSkgWcATZhj/55JZ0rmy3myCT5lsA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "argparse": "^2.0.1"
+      },
+      "bin": {
+        "js-yaml": "bin/js-yaml.js"
+      }
+    },
+    "node_modules/json-parse-even-better-errors": {
+      "version": "3.0.2",
+      "resolved": "https://registry.npmjs.org/json-parse-even-better-errors/-/json-parse-even-better-errors-3.0.2.tgz",
+      "integrity": "sha512-fi0NG4bPjCHunUJffmLd0gxssIgkNmArMvis4iNah6Owg1MCJjWhEcDLmsK6iGkJq3tHwbDkTlce70/tmXN4cQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": "^14.17.0 || ^16.13.0 || >=18.0.0"
+      }
+    },
+    "node_modules/jszip": {
+      "version": "3.10.1",
+      "resolved": "https://registry.npmjs.org/jszip/-/jszip-3.10.1.tgz",
+      "integrity": "sha512-xXDvecyTpGLrqFrvkrUSoxxfJI5AH7U8zxxtVclpsUtMCq4JQ290LY8AW5c7Ggnr/Y/oK+bQMbqK2qmtk3pN4g==",
+      "dev": true,
+      "license": "(MIT OR GPL-3.0-or-later)",
+      "dependencies": {
+        "lie": "~3.3.0",
+        "pako": "~1.0.2",
+        "readable-stream": "~2.3.6",
+        "setimmediate": "^1.0.5"
+      }
+    },
+    "node_modules/jszip/node_modules/readable-stream": {
+      "version": "2.3.8",
+      "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-2.3.8.tgz",
+      "integrity": "sha512-8p0AUk4XODgIewSi0l8Epjs+EVnWiK7NoDIEGU0HhE7+ZyY8D1IMY7odu5lRrFXGg71L15KG8QrPmum45RTtdA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "core-util-is": "~1.0.0",
+        "inherits": "~2.0.3",
+        "isarray": "~1.0.0",
+        "process-nextick-args": "~2.0.0",
+        "safe-buffer": "~5.1.1",
+        "string_decoder": "~1.1.1",
+        "util-deprecate": "~1.0.1"
+      }
+    },
+    "node_modules/jszip/node_modules/safe-buffer": {
+      "version": "5.1.2",
+      "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.1.2.tgz",
+      "integrity": "sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/jszip/node_modules/string_decoder": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.1.1.tgz",
+      "integrity": "sha512-n/ShnvDi6FHbbVfviro+WojiFzv+s8MPMHBczVePfUpDJLwoLT0ht1l4YwBCbi8pJAveEEdnkHyPyTP/mzRfwg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "safe-buffer": "~5.1.0"
+      }
+    },
+    "node_modules/lazystream": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/lazystream/-/lazystream-1.0.1.tgz",
+      "integrity": "sha512-b94GiNHQNy6JNTrt5w6zNyffMrNkXZb3KTkCZJb2V1xaEGCk093vkZ2jk3tpaeP33/OiXC+WvK9AxUebnf5nbw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "readable-stream": "^2.0.5"
+      },
+      "engines": {
+        "node": ">= 0.6.3"
+      }
+    },
+    "node_modules/lazystream/node_modules/readable-stream": {
+      "version": "2.3.8",
+      "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-2.3.8.tgz",
+      "integrity": "sha512-8p0AUk4XODgIewSi0l8Epjs+EVnWiK7NoDIEGU0HhE7+ZyY8D1IMY7odu5lRrFXGg71L15KG8QrPmum45RTtdA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "core-util-is": "~1.0.0",
+        "inherits": "~2.0.3",
+        "isarray": "~1.0.0",
+        "process-nextick-args": "~2.0.0",
+        "safe-buffer": "~5.1.1",
+        "string_decoder": "~1.1.1",
+        "util-deprecate": "~1.0.1"
+      }
+    },
+    "node_modules/lazystream/node_modules/safe-buffer": {
+      "version": "5.1.2",
+      "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.1.2.tgz",
+      "integrity": "sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/lazystream/node_modules/string_decoder": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.1.1.tgz",
+      "integrity": "sha512-n/ShnvDi6FHbbVfviro+WojiFzv+s8MPMHBczVePfUpDJLwoLT0ht1l4YwBCbi8pJAveEEdnkHyPyTP/mzRfwg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "safe-buffer": "~5.1.0"
+      }
+    },
+    "node_modules/lie": {
+      "version": "3.3.0",
+      "resolved": "https://registry.npmjs.org/lie/-/lie-3.3.0.tgz",
+      "integrity": "sha512-UaiMJzeWRlEujzAuw5LokY1L5ecNQYZKfmyZ9L7wDHb/p5etKaxXhohBcrw0EYby+G/NA52vRSN4N39dxHAIwQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "immediate": "~3.0.5"
+      }
+    },
+    "node_modules/lines-and-columns": {
+      "version": "2.0.4",
+      "resolved": "https://registry.npmjs.org/lines-and-columns/-/lines-and-columns-2.0.4.tgz",
+      "integrity": "sha512-wM1+Z03eypVAVUCE7QdSqpVIvelbOakn1M0bPDoA4SGWPx3sNDVUiMo3L6To6WWGClB7VyXnhQ4Sn7gxiJbE6A==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": "^12.20.0 || ^14.13.1 || >=16.0.0"
+      }
+    },
+    "node_modules/locate-app": {
+      "version": "2.5.0",
+      "resolved": "https://registry.npmjs.org/locate-app/-/locate-app-2.5.0.tgz",
+      "integrity": "sha512-xIqbzPMBYArJRmPGUZD9CzV9wOqmVtQnaAn3wrj3s6WYW0bQvPI7x+sPYUGmDTYMHefVK//zc6HEYZ1qnxIK+Q==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "individual",
+          "url": "https://buymeacoffee.com/hejny"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/hejny/locate-app/blob/main/README.md#%EF%B8%8F-contributing"
+        }
+      ],
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@promptbook/utils": "0.69.5",
+        "type-fest": "4.26.0",
+        "userhome": "1.0.1"
+      }
+    },
+    "node_modules/locate-app/node_modules/type-fest": {
+      "version": "4.26.0",
+      "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-4.26.0.tgz",
+      "integrity": "sha512-OduNjVJsFbifKb57UqZ2EMP1i4u64Xwow3NYXUtBbD4vIwJdQd4+xl8YDou1dlm4DVrtwT/7Ky8z8WyCULVfxw==",
+      "dev": true,
+      "license": "(MIT OR CC0-1.0)",
+      "engines": {
+        "node": ">=16"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/locate-character": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/locate-character/-/locate-character-3.0.0.tgz",
+      "integrity": "sha512-SW13ws7BjaeJ6p7Q6CO2nchbYEc3X3J6WrmTTDto7yMPqVSZTUyY5Tjbid+Ab8gLnATtygYtiDIJGQRRn2ZOiA==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/locate-path": {
+      "version": "6.0.0",
+      "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-6.0.0.tgz",
+      "integrity": "sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "p-locate": "^5.0.0"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/lodash": {
+      "version": "4.17.23",
+      "resolved": "https://registry.npmjs.org/lodash/-/lodash-4.17.23.tgz",
+      "integrity": "sha512-LgVTMpQtIopCi79SJeDiP0TfWi5CNEc/L/aRdTh3yIvmZXTnheWpKjSZhnvMl8iXbC1tFg9gdHHDMLoV7CnG+w==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/lodash.clonedeep": {
+      "version": "4.5.0",
+      "resolved": "https://registry.npmjs.org/lodash.clonedeep/-/lodash.clonedeep-4.5.0.tgz",
+      "integrity": "sha512-H5ZhCF25riFd9uB5UCkVKo61m3S/xZk1x4wA6yp/L3RFP6Z/eHH1ymQcGLo7J3GMPfm0V/7m1tryHuGVxpqEBQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/lodash.flattendeep": {
+      "version": "4.4.0",
+      "resolved": "https://registry.npmjs.org/lodash.flattendeep/-/lodash.flattendeep-4.4.0.tgz",
+      "integrity": "sha512-uHaJFihxmJcEX3kT4I23ABqKKalJ/zDrDg0lsFtc1h+3uw49SIJ5beyhx5ExVRti3AvKoOJngIj7xz3oylPdWQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/lodash.pickby": {
+      "version": "4.6.0",
+      "resolved": "https://registry.npmjs.org/lodash.pickby/-/lodash.pickby-4.6.0.tgz",
+      "integrity": "sha512-AZV+GsS/6ckvPOVQPXSiFFacKvKB4kOQu6ynt9wz0F3LO4R9Ij4K1ddYsIytDpSgLz88JHd9P+oaLeej5/Sl7Q==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/lodash.union": {
+      "version": "4.6.0",
+      "resolved": "https://registry.npmjs.org/lodash.union/-/lodash.union-4.6.0.tgz",
+      "integrity": "sha512-c4pB2CdGrGdjMKYLA+XiRDO7Y0PRQbm/Gzg8qMj+QH+pFVAoTp5sBpO0odL3FjoPCGjK96p6qsP+yQoiLoOBcw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/lodash.zip": {
+      "version": "4.2.0",
+      "resolved": "https://registry.npmjs.org/lodash.zip/-/lodash.zip-4.2.0.tgz",
+      "integrity": "sha512-C7IOaBBK/0gMORRBd8OETNx3kmOkgIWIPvyDpZSCTwUrpYmgZwJkjZeOD8ww4xbOUOs4/attY+pciKvadNfFbg==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/log-symbols": {
+      "version": "4.1.0",
+      "resolved": "https://registry.npmjs.org/log-symbols/-/log-symbols-4.1.0.tgz",
+      "integrity": "sha512-8XPvpAA8uyhfteu8pIvQxpJZ7SYYdpUivZpGy6sFsBuKRY/7rQGavedeB8aK+Zkyq6upMFVL/9AW6vOYzfRyLg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "chalk": "^4.1.0",
+        "is-unicode-supported": "^0.1.0"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/log-symbols/node_modules/ansi-styles": {
+      "version": "4.3.0",
+      "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz",
+      "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "color-convert": "^2.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/ansi-styles?sponsor=1"
+      }
+    },
+    "node_modules/log-symbols/node_modules/chalk": {
+      "version": "4.1.2",
+      "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz",
+      "integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "ansi-styles": "^4.1.0",
+        "supports-color": "^7.1.0"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/chalk?sponsor=1"
+      }
+    },
+    "node_modules/log-symbols/node_modules/is-unicode-supported": {
+      "version": "0.1.0",
+      "resolved": "https://registry.npmjs.org/is-unicode-supported/-/is-unicode-supported-0.1.0.tgz",
+      "integrity": "sha512-knxG2q4UC3u8stRGyAVJCOdxFmv5DZiRcdlIaAQXAbSfJya+OhopNotLQrstBhququ4ZpuKbDc/8S6mgXgPFPw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/log-symbols/node_modules/supports-color": {
+      "version": "7.2.0",
+      "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz",
+      "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "has-flag": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/loglevel": {
+      "version": "1.9.2",
+      "resolved": "https://registry.npmjs.org/loglevel/-/loglevel-1.9.2.tgz",
+      "integrity": "sha512-HgMmCqIJSAKqo68l0rS2AanEWfkxaZ5wNiEFb5ggm08lDs9Xl2KxBlX3PTcaD2chBM1gXAYf491/M2Rv8Jwayg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6.0"
+      },
+      "funding": {
+        "type": "tidelift",
+        "url": "https://tidelift.com/funding/github/npm/loglevel"
+      }
+    },
+    "node_modules/loglevel-plugin-prefix": {
+      "version": "0.8.4",
+      "resolved": "https://registry.npmjs.org/loglevel-plugin-prefix/-/loglevel-plugin-prefix-0.8.4.tgz",
+      "integrity": "sha512-WpG9CcFAOjz/FtNht+QJeGpvVl/cdR6P0z6OcXSkr8wFJOsV2GRj2j10JLfjuA4aYkcKCNIEqRGCyTife9R8/g==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/lru-cache": {
+      "version": "10.4.3",
+      "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-10.4.3.tgz",
+      "integrity": "sha512-JNAzZcXrCt42VGLuYz0zfAzDfAvJWW6AfYlDBQyDV5DClI2m5sAmK+OIO7s59XfsRsWHp02jAJrRadPRGTt6SQ==",
+      "dev": true,
+      "license": "ISC"
+    },
+    "node_modules/magic-string": {
+      "version": "0.30.21",
+      "resolved": "https://registry.npmjs.org/magic-string/-/magic-string-0.30.21.tgz",
+      "integrity": "sha512-vd2F4YUyEXKGcLHoq+TEyCjxueSeHnFxyyjNp80yg0XV4vUhnDer/lvvlqM/arB5bXQN5K2/3oinyCRyx8T2CQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jridgewell/sourcemap-codec": "^1.5.5"
+      }
+    },
+    "node_modules/marked": {
+      "version": "17.0.4",
+      "resolved": "https://registry.npmjs.org/marked/-/marked-17.0.4.tgz",
+      "integrity": "sha512-NOmVMM+KAokHMvjWmC5N/ZOvgmSWuqJB8FoYI019j4ogb/PeRMKoKIjReZ2w3376kkA8dSJIP8uD993Kxc0iRQ==",
+      "license": "MIT",
+      "bin": {
+        "marked": "bin/marked.js"
+      },
+      "engines": {
+        "node": ">= 20"
+      }
+    },
+    "node_modules/mdast-util-to-hast": {
+      "version": "13.2.1",
+      "resolved": "https://registry.npmjs.org/mdast-util-to-hast/-/mdast-util-to-hast-13.2.1.tgz",
+      "integrity": "sha512-cctsq2wp5vTsLIcaymblUriiTcZd0CwWtCbLvrOzYCDZoWyMNV8sZ7krj09FSnsiJi3WVsHLM4k6Dq/yaPyCXA==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/hast": "^3.0.0",
+        "@types/mdast": "^4.0.0",
+        "@ungap/structured-clone": "^1.0.0",
+        "devlop": "^1.0.0",
+        "micromark-util-sanitize-uri": "^2.0.0",
+        "trim-lines": "^3.0.0",
+        "unist-util-position": "^5.0.0",
+        "unist-util-visit": "^5.0.0",
+        "vfile": "^6.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/micromark-util-character": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/micromark-util-character/-/micromark-util-character-2.1.1.tgz",
+      "integrity": "sha512-wv8tdUTJ3thSFFFJKtpYKOYiGP2+v96Hvk4Tu8KpCAsTMs6yi+nVmGh1syvSCsaxz45J6Jbw+9DD6g97+NV67Q==",
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "micromark-util-symbol": "^2.0.0",
+        "micromark-util-types": "^2.0.0"
+      }
+    },
+    "node_modules/micromark-util-encode": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/micromark-util-encode/-/micromark-util-encode-2.0.1.tgz",
+      "integrity": "sha512-c3cVx2y4KqUnwopcO9b/SCdo2O67LwJJ/UyqGfbigahfegL9myoEFoDYZgkT7f36T0bLrM9hZTAaAyH+PCAXjw==",
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ],
+      "license": "MIT"
+    },
+    "node_modules/micromark-util-sanitize-uri": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/micromark-util-sanitize-uri/-/micromark-util-sanitize-uri-2.0.1.tgz",
+      "integrity": "sha512-9N9IomZ/YuGGZZmQec1MbgxtlgougxTodVwDzzEouPKo3qFWvymFHWcnDi2vzV1ff6kas9ucW+o3yzJK9YB1AQ==",
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "micromark-util-character": "^2.0.0",
+        "micromark-util-encode": "^2.0.0",
+        "micromark-util-symbol": "^2.0.0"
+      }
+    },
+    "node_modules/micromark-util-symbol": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/micromark-util-symbol/-/micromark-util-symbol-2.0.1.tgz",
+      "integrity": "sha512-vs5t8Apaud9N28kgCrRUdEed4UJ+wWNvicHLPxCa9ENlYuAY31M0ETy5y1vA33YoNPDFTghEbnh6efaE8h4x0Q==",
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ],
+      "license": "MIT"
+    },
+    "node_modules/micromark-util-types": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/micromark-util-types/-/micromark-util-types-2.0.2.tgz",
+      "integrity": "sha512-Yw0ECSpJoViF1qTU4DC6NwtC4aWGt1EkzaQB8KPPyCRR8z9TWeV0HbEFGTO+ZY1wB22zmxnJqhPyTpOVCpeHTA==",
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ],
+      "license": "MIT"
+    },
+    "node_modules/micromatch": {
+      "version": "4.0.8",
+      "resolved": "https://registry.npmjs.org/micromatch/-/micromatch-4.0.8.tgz",
+      "integrity": "sha512-PXwfBhYu0hBCPw8Dn0E+WDYb7af3dSLVWKi3HGv84IdF4TyFoC0ysxFd0Goxw7nSv4T/PzEJQxsYsEiFCKo2BA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "braces": "^3.0.3",
+        "picomatch": "^2.3.1"
+      },
+      "engines": {
+        "node": ">=8.6"
+      }
+    },
+    "node_modules/micromatch/node_modules/picomatch": {
+      "version": "2.3.1",
+      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.1.tgz",
+      "integrity": "sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8.6"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/jonschlinkert"
+      }
+    },
+    "node_modules/minimatch": {
+      "version": "9.0.9",
+      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-9.0.9.tgz",
+      "integrity": "sha512-OBwBN9AL4dqmETlpS2zasx+vTeWclWzkblfZk7KTA5j3jeOONz/tRCnZomUyvNg83wL5Zv9Ss6HMJXAgL8R2Yg==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "brace-expansion": "^2.0.2"
+      },
+      "engines": {
+        "node": ">=16 || 14 >=14.17"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      }
+    },
+    "node_modules/minipass": {
+      "version": "7.1.3",
+      "resolved": "https://registry.npmjs.org/minipass/-/minipass-7.1.3.tgz",
+      "integrity": "sha512-tEBHqDnIoM/1rXME1zgka9g6Q2lcoCkxHLuc7ODJ5BxbP5d4c2Z5cGgtXAku59200Cx7diuHTOYfSBD8n6mm8A==",
+      "dev": true,
+      "license": "BlueOak-1.0.0",
+      "engines": {
+        "node": ">=16 || 14 >=14.17"
+      }
+    },
+    "node_modules/mitt": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/mitt/-/mitt-3.0.1.tgz",
+      "integrity": "sha512-vKivATfr97l2/QBCYAkXYDbrIWPM2IIKEl7YPhjCvKlG3kE2gm+uBo6nEXK3M5/Ffh/FLpKExzOQ3JJoJGFKBw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/mocha": {
+      "version": "10.8.2",
+      "resolved": "https://registry.npmjs.org/mocha/-/mocha-10.8.2.tgz",
+      "integrity": "sha512-VZlYo/WE8t1tstuRmqgeyBgCbJc/lEdopaa+axcKzTBJ+UIdlAB9XnmvTCAH4pwR4ElNInaedhEBmZD8iCSVEg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "ansi-colors": "^4.1.3",
+        "browser-stdout": "^1.3.1",
+        "chokidar": "^3.5.3",
+        "debug": "^4.3.5",
+        "diff": "^5.2.0",
+        "escape-string-regexp": "^4.0.0",
+        "find-up": "^5.0.0",
+        "glob": "^8.1.0",
+        "he": "^1.2.0",
+        "js-yaml": "^4.1.0",
+        "log-symbols": "^4.1.0",
+        "minimatch": "^5.1.6",
+        "ms": "^2.1.3",
+        "serialize-javascript": "^6.0.2",
+        "strip-json-comments": "^3.1.1",
+        "supports-color": "^8.1.1",
+        "workerpool": "^6.5.1",
+        "yargs": "^16.2.0",
+        "yargs-parser": "^20.2.9",
+        "yargs-unparser": "^2.0.0"
+      },
+      "bin": {
+        "_mocha": "bin/_mocha",
+        "mocha": "bin/mocha.js"
+      },
+      "engines": {
+        "node": ">= 14.0.0"
+      }
+    },
+    "node_modules/mocha/node_modules/ansi-styles": {
+      "version": "4.3.0",
+      "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz",
+      "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "color-convert": "^2.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/ansi-styles?sponsor=1"
+      }
+    },
+    "node_modules/mocha/node_modules/chokidar": {
+      "version": "3.6.0",
+      "resolved": "https://registry.npmjs.org/chokidar/-/chokidar-3.6.0.tgz",
+      "integrity": "sha512-7VT13fmjotKpGipCW9JEQAusEPE+Ei8nl6/g4FBAmIm0GOOLMua9NDDo/DWp0ZAxCr3cPq5ZpBqmPAQgDda2Pw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "anymatch": "~3.1.2",
+        "braces": "~3.0.2",
+        "glob-parent": "~5.1.2",
+        "is-binary-path": "~2.1.0",
+        "is-glob": "~4.0.1",
+        "normalize-path": "~3.0.0",
+        "readdirp": "~3.6.0"
+      },
+      "engines": {
+        "node": ">= 8.10.0"
+      },
+      "funding": {
+        "url": "https://paulmillr.com/funding/"
+      },
+      "optionalDependencies": {
+        "fsevents": "~2.3.2"
+      }
+    },
+    "node_modules/mocha/node_modules/cliui": {
+      "version": "7.0.4",
+      "resolved": "https://registry.npmjs.org/cliui/-/cliui-7.0.4.tgz",
+      "integrity": "sha512-OcRE68cOsVMXp1Yvonl/fzkQOyjLSu/8bhPDfQt0e0/Eb283TKP20Fs2MqoPsr9SwA595rRCA+QMzYc9nBP+JQ==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "string-width": "^4.2.0",
+        "strip-ansi": "^6.0.0",
+        "wrap-ansi": "^7.0.0"
+      }
+    },
+    "node_modules/mocha/node_modules/diff": {
+      "version": "5.2.2",
+      "resolved": "https://registry.npmjs.org/diff/-/diff-5.2.2.tgz",
+      "integrity": "sha512-vtcDfH3TOjP8UekytvnHH1o1P4FcUdt4eQ1Y+Abap1tk/OB2MWQvcwS2ClCd1zuIhc3JKOx6p3kod8Vfys3E+A==",
+      "dev": true,
+      "license": "BSD-3-Clause",
+      "engines": {
+        "node": ">=0.3.1"
+      }
+    },
+    "node_modules/mocha/node_modules/emoji-regex": {
+      "version": "8.0.0",
+      "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz",
+      "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/mocha/node_modules/glob": {
+      "version": "8.1.0",
+      "resolved": "https://registry.npmjs.org/glob/-/glob-8.1.0.tgz",
+      "integrity": "sha512-r8hpEjiQEYlF2QU0df3dS+nxxSIreXQS1qRhMJM0Q5NDdR386C7jb7Hwwod8Fgiuex+k0GFjgft18yvxm5XoCQ==",
+      "deprecated": "Old versions of glob are not supported, and contain widely publicized security vulnerabilities, which have been fixed in the current version. Please update. Support for old versions may be purchased (at exorbitant rates) by contacting i@izs.me",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "fs.realpath": "^1.0.0",
+        "inflight": "^1.0.4",
+        "inherits": "2",
+        "minimatch": "^5.0.1",
+        "once": "^1.3.0"
+      },
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      }
+    },
+    "node_modules/mocha/node_modules/minimatch": {
+      "version": "5.1.9",
+      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-5.1.9.tgz",
+      "integrity": "sha512-7o1wEA2RyMP7Iu7GNba9vc0RWWGACJOCZBJX2GJWip0ikV+wcOsgVuY9uE8CPiyQhkGFSlhuSkZPavN7u1c2Fw==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "brace-expansion": "^2.0.1"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/mocha/node_modules/picomatch": {
+      "version": "2.3.1",
+      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.1.tgz",
+      "integrity": "sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8.6"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/jonschlinkert"
+      }
+    },
+    "node_modules/mocha/node_modules/readdirp": {
+      "version": "3.6.0",
+      "resolved": "https://registry.npmjs.org/readdirp/-/readdirp-3.6.0.tgz",
+      "integrity": "sha512-hOS089on8RduqdbhvQ5Z37A0ESjsqz6qnRcffsMU3495FuTdqSm+7bhJ29JvIOsBDEEnan5DPu9t3To9VRlMzA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "picomatch": "^2.2.1"
+      },
+      "engines": {
+        "node": ">=8.10.0"
+      }
+    },
+    "node_modules/mocha/node_modules/string-width": {
+      "version": "4.2.3",
+      "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz",
+      "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "emoji-regex": "^8.0.0",
+        "is-fullwidth-code-point": "^3.0.0",
+        "strip-ansi": "^6.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/mocha/node_modules/strip-ansi": {
+      "version": "6.0.1",
+      "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz",
+      "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "ansi-regex": "^5.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/mocha/node_modules/wrap-ansi": {
+      "version": "7.0.0",
+      "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-7.0.0.tgz",
+      "integrity": "sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "ansi-styles": "^4.0.0",
+        "string-width": "^4.1.0",
+        "strip-ansi": "^6.0.0"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/wrap-ansi?sponsor=1"
+      }
+    },
+    "node_modules/mocha/node_modules/yargs": {
+      "version": "16.2.0",
+      "resolved": "https://registry.npmjs.org/yargs/-/yargs-16.2.0.tgz",
+      "integrity": "sha512-D1mvvtDG0L5ft/jGWkLpG1+m0eQxOfaBvTNELraWj22wSVUMWxZUvYgJYcKh6jGGIkJFhH4IZPQhR4TKpc8mBw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "cliui": "^7.0.2",
+        "escalade": "^3.1.1",
+        "get-caller-file": "^2.0.5",
+        "require-directory": "^2.1.1",
+        "string-width": "^4.2.0",
+        "y18n": "^5.0.5",
+        "yargs-parser": "^20.2.2"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/modern-tar": {
+      "version": "0.7.5",
+      "resolved": "https://registry.npmjs.org/modern-tar/-/modern-tar-0.7.5.tgz",
+      "integrity": "sha512-YTefgdpKKFgoTDbEUqXqgUJct2OG6/4hs4XWLsxcHkDLj/x/V8WmKIRppPnXP5feQ7d1vuYWSp3qKkxfwaFaxA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=18.0.0"
+      }
+    },
+    "node_modules/mri": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/mri/-/mri-1.2.0.tgz",
+      "integrity": "sha512-tzzskb3bG8LvYGFF/mDTpq3jpI6Q9wc3LEmBaghu+DdCssd1FakN7Bc0hVNmEyGq1bq3RgfkCb3cmQLpNPOroA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/ms": {
+      "version": "2.1.3",
+      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
+      "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/mute-stream": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/mute-stream/-/mute-stream-2.0.0.tgz",
+      "integrity": "sha512-WWdIxpyjEn+FhQJQQv9aQAYlHoNVdzIzUySNV1gHUPDSdZJ3yZn7pAAbQcV7B56Mvu881q9FZV+0Vx2xC44VWA==",
+      "dev": true,
+      "license": "ISC",
+      "engines": {
+        "node": "^18.17.0 || >=20.5.0"
+      }
+    },
+    "node_modules/nanoid": {
+      "version": "3.3.11",
+      "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.11.tgz",
+      "integrity": "sha512-N8SpfPUnUp1bK+PMYW8qSWdl9U+wwNWI4QKxOYDy9JAro3WMX7p2OeVRF9v+347pnakNevPmiHhNmZ2HbFA76w==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "MIT",
+      "bin": {
+        "nanoid": "bin/nanoid.cjs"
+      },
+      "engines": {
+        "node": "^10 || ^12 || ^13.7 || ^14 || >=15.0.1"
+      }
+    },
+    "node_modules/netmask": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/netmask/-/netmask-2.0.2.tgz",
+      "integrity": "sha512-dBpDMdxv9Irdq66304OLfEmQ9tbNRFnFTuZiLo+bD+r332bBmMJ8GBLXklIXXgxd3+v9+KUnZaUR5PJMa75Gsg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4.0"
+      }
+    },
+    "node_modules/node-readable-to-web-readable-stream": {
+      "version": "0.4.2",
+      "resolved": "https://registry.npmjs.org/node-readable-to-web-readable-stream/-/node-readable-to-web-readable-stream-0.4.2.tgz",
+      "integrity": "sha512-/cMZNI34v//jUTrI+UIo4ieHAB5EZRY/+7OmXZgBxaWBMcW2tGdceIw06RFxWxrKZ5Jp3sI2i5TsRo+CBhtVLQ==",
+      "license": "MIT",
+      "optional": true
+    },
+    "node_modules/normalize-package-data": {
+      "version": "7.0.1",
+      "resolved": "https://registry.npmjs.org/normalize-package-data/-/normalize-package-data-7.0.1.tgz",
+      "integrity": "sha512-linxNAT6M0ebEYZOx2tO6vBEFsVgnPpv+AVjk0wJHfaUIbq31Jm3T6vvZaarnOeWDh8ShnwXuaAyM7WT3RzErA==",
+      "dev": true,
+      "license": "BSD-2-Clause",
+      "dependencies": {
+        "hosted-git-info": "^8.0.0",
+        "semver": "^7.3.5",
+        "validate-npm-package-license": "^3.0.4"
+      },
+      "engines": {
+        "node": "^18.17.0 || >=20.5.0"
+      }
+    },
+    "node_modules/normalize-path": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/normalize-path/-/normalize-path-3.0.0.tgz",
+      "integrity": "sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/npm-run-path": {
+      "version": "6.0.0",
+      "resolved": "https://registry.npmjs.org/npm-run-path/-/npm-run-path-6.0.0.tgz",
+      "integrity": "sha512-9qny7Z9DsQU8Ou39ERsPU4OZQlSTP47ShQzuKZ6PRXpYLtIFgl/DEBYEXKlvcEa+9tHVcK8CF81Y2V72qaZhWA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "path-key": "^4.0.0",
+        "unicorn-magic": "^0.3.0"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/npm-run-path/node_modules/path-key": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/path-key/-/path-key-4.0.0.tgz",
+      "integrity": "sha512-haREypq7xkM7ErfgIyA0z+Bj4AGKlMSdlQE2jvJo6huWD1EdkKYV+G/T4nq0YEF2vgTT8kqMFKo1uHn950r4SQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/nth-check": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/nth-check/-/nth-check-2.1.1.tgz",
+      "integrity": "sha512-lqjrjmaOoAnWfMmBPL+XNnynZh2+swxiX3WUE0s4yEHI6m+AwrK2UZOimIRl3X/4QctVqS8AiZjFqyOGrMXb/w==",
+      "dev": true,
+      "license": "BSD-2-Clause",
+      "dependencies": {
+        "boolbase": "^1.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/fb55/nth-check?sponsor=1"
+      }
+    },
+    "node_modules/object-inspect": {
+      "version": "1.13.4",
+      "resolved": "https://registry.npmjs.org/object-inspect/-/object-inspect-1.13.4.tgz",
+      "integrity": "sha512-W67iLl4J2EXEGTbfeHCffrjDfitvLANg0UlX3wFUUSTx92KXRFegMHUVgSqE+wvhAbi4WqjGg9czysTV2Epbew==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/obug": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/obug/-/obug-2.1.1.tgz",
+      "integrity": "sha512-uTqF9MuPraAQ+IsnPf366RG4cP9RtUi7MLO1N3KEc+wb0a6yKpeL0lmk2IB1jY5KHPAlTc6T/JRdC/YqxHNwkQ==",
+      "dev": true,
+      "funding": [
+        "https://github.com/sponsors/sxzz",
+        "https://opencollective.com/debug"
+      ],
+      "license": "MIT"
+    },
+    "node_modules/once": {
+      "version": "1.4.0",
+      "resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz",
+      "integrity": "sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "wrappy": "1"
+      }
+    },
+    "node_modules/oniguruma-parser": {
+      "version": "0.12.1",
+      "resolved": "https://registry.npmjs.org/oniguruma-parser/-/oniguruma-parser-0.12.1.tgz",
+      "integrity": "sha512-8Unqkvk1RYc6yq2WBYRj4hdnsAxVze8i7iPfQr8e4uSP3tRv0rpZcbGUDvxfQQcdwHt/e9PrMvGCsa8OqG9X3w==",
+      "license": "MIT"
+    },
+    "node_modules/oniguruma-to-es": {
+      "version": "4.3.4",
+      "resolved": "https://registry.npmjs.org/oniguruma-to-es/-/oniguruma-to-es-4.3.4.tgz",
+      "integrity": "sha512-3VhUGN3w2eYxnTzHn+ikMI+fp/96KoRSVK9/kMTcFqj1NRDh2IhQCKvYxDnWePKRXY/AqH+Fuiyb7VHSzBjHfA==",
+      "license": "MIT",
+      "dependencies": {
+        "oniguruma-parser": "^0.12.1",
+        "regex": "^6.0.1",
+        "regex-recursion": "^6.0.2"
+      }
+    },
+    "node_modules/p-limit": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-3.1.0.tgz",
+      "integrity": "sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "yocto-queue": "^0.1.0"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/p-locate": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-5.0.0.tgz",
+      "integrity": "sha512-LaNjtRWUBY++zB5nE/NwcaoMylSPk+S+ZHNB1TzdbMJMny6dynpAGt7X/tl/QYq3TIeE6nxHppbo2LGymrG5Pw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "p-limit": "^3.0.2"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/pac-proxy-agent": {
+      "version": "7.2.0",
+      "resolved": "https://registry.npmjs.org/pac-proxy-agent/-/pac-proxy-agent-7.2.0.tgz",
+      "integrity": "sha512-TEB8ESquiLMc0lV8vcd5Ql/JAKAoyzHFXaStwjkzpOpC5Yv+pIzLfHvjTSdf3vpa2bMiUQrg9i6276yn8666aA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@tootallnate/quickjs-emscripten": "^0.23.0",
+        "agent-base": "^7.1.2",
+        "debug": "^4.3.4",
+        "get-uri": "^6.0.1",
+        "http-proxy-agent": "^7.0.0",
+        "https-proxy-agent": "^7.0.6",
+        "pac-resolver": "^7.0.1",
+        "socks-proxy-agent": "^8.0.5"
+      },
+      "engines": {
+        "node": ">= 14"
+      }
+    },
+    "node_modules/pac-resolver": {
+      "version": "7.0.1",
+      "resolved": "https://registry.npmjs.org/pac-resolver/-/pac-resolver-7.0.1.tgz",
+      "integrity": "sha512-5NPgf87AT2STgwa2ntRMr45jTKrYBGkVU36yT0ig/n/GMAa3oPqhZfIQ2kMEimReg0+t9kZViDVZ83qfVUlckg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "degenerator": "^5.0.0",
+        "netmask": "^2.0.2"
+      },
+      "engines": {
+        "node": ">= 14"
+      }
+    },
+    "node_modules/package-json-from-dist": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/package-json-from-dist/-/package-json-from-dist-1.0.1.tgz",
+      "integrity": "sha512-UEZIS3/by4OC8vL3P2dTXRETpebLI2NiI5vIrjaD/5UtrkFX/tNbwjTSRAGC/+7CAo2pIcBaRgWmcBBHcsaCIw==",
+      "dev": true,
+      "license": "BlueOak-1.0.0"
+    },
+    "node_modules/pako": {
+      "version": "1.0.11",
+      "resolved": "https://registry.npmjs.org/pako/-/pako-1.0.11.tgz",
+      "integrity": "sha512-4hLB8Py4zZce5s4yd9XzopqwVv/yGNhV1Bl8NTmCq1763HeK2+EwVTv+leGeL13Dnh2wfbqowVPXCIO0z4taYw==",
+      "dev": true,
+      "license": "(MIT AND Zlib)"
+    },
+    "node_modules/parse-json": {
+      "version": "7.1.1",
+      "resolved": "https://registry.npmjs.org/parse-json/-/parse-json-7.1.1.tgz",
+      "integrity": "sha512-SgOTCX/EZXtZxBE5eJ97P4yGM5n37BwRU+YMsH4vNzFqJV/oWFXXCmwFlgWUM4PrakybVOueJJ6pwHqSVhTFDw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/code-frame": "^7.21.4",
+        "error-ex": "^1.3.2",
+        "json-parse-even-better-errors": "^3.0.0",
+        "lines-and-columns": "^2.0.3",
+        "type-fest": "^3.8.0"
+      },
+      "engines": {
+        "node": ">=16"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/parse-json/node_modules/type-fest": {
+      "version": "3.13.1",
+      "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-3.13.1.tgz",
+      "integrity": "sha512-tLq3bSNx+xSpwvAJnzrK0Ep5CLNWjvFTOp71URMaAEWBfRb9nnJiBoUe0tF8bI4ZFO3omgBR6NvnbzVUT3Ly4g==",
+      "dev": true,
+      "license": "(MIT OR CC0-1.0)",
+      "engines": {
+        "node": ">=14.16"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/parse-ms": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/parse-ms/-/parse-ms-4.0.0.tgz",
+      "integrity": "sha512-TXfryirbmq34y8QBwgqCVLi+8oA3oWx2eAnSn62ITyEhEYaWRlVZ2DvMM9eZbMs/RfxPu/PK/aBLyGj4IrqMHw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/parse5": {
+      "version": "7.3.0",
+      "resolved": "https://registry.npmjs.org/parse5/-/parse5-7.3.0.tgz",
+      "integrity": "sha512-IInvU7fabl34qmi9gY8XOVxhYyMyuH2xUNpb2q8/Y+7552KlejkRvqvD19nMoUW/uQGGbqNpA6Tufu5FL5BZgw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "entities": "^6.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/inikulin/parse5?sponsor=1"
+      }
+    },
+    "node_modules/parse5-htmlparser2-tree-adapter": {
+      "version": "7.1.0",
+      "resolved": "https://registry.npmjs.org/parse5-htmlparser2-tree-adapter/-/parse5-htmlparser2-tree-adapter-7.1.0.tgz",
+      "integrity": "sha512-ruw5xyKs6lrpo9x9rCZqZZnIUntICjQAd0Wsmp396Ul9lN/h+ifgVV1x1gZHi8euej6wTfpqX8j+BFQxF0NS/g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "domhandler": "^5.0.3",
+        "parse5": "^7.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/inikulin/parse5?sponsor=1"
+      }
+    },
+    "node_modules/parse5-parser-stream": {
+      "version": "7.1.2",
+      "resolved": "https://registry.npmjs.org/parse5-parser-stream/-/parse5-parser-stream-7.1.2.tgz",
+      "integrity": "sha512-JyeQc9iwFLn5TbvvqACIF/VXG6abODeB3Fwmv/TGdLk2LfbWkaySGY72at4+Ty7EkPZj854u4CrICqNk2qIbow==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "parse5": "^7.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/inikulin/parse5?sponsor=1"
+      }
+    },
+    "node_modules/parse5/node_modules/entities": {
+      "version": "6.0.1",
+      "resolved": "https://registry.npmjs.org/entities/-/entities-6.0.1.tgz",
+      "integrity": "sha512-aN97NXWF6AWBTahfVOIrB/NShkzi5H7F9r1s9mD3cDj4Ko5f2qhhVoYMibXF7GlLveb/D2ioWay8lxI97Ven3g==",
+      "dev": true,
+      "license": "BSD-2-Clause",
+      "engines": {
+        "node": ">=0.12"
+      },
+      "funding": {
+        "url": "https://github.com/fb55/entities?sponsor=1"
+      }
+    },
+    "node_modules/path-exists": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-4.0.0.tgz",
+      "integrity": "sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/path-key": {
+      "version": "3.1.1",
+      "resolved": "https://registry.npmjs.org/path-key/-/path-key-3.1.1.tgz",
+      "integrity": "sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/path-scurry": {
+      "version": "1.11.1",
+      "resolved": "https://registry.npmjs.org/path-scurry/-/path-scurry-1.11.1.tgz",
+      "integrity": "sha512-Xa4Nw17FS9ApQFJ9umLiJS4orGjm7ZzwUrwamcGQuHSzDyth9boKDaycYdDcZDuqYATXw4HFXgaqWTctW/v1HA==",
+      "dev": true,
+      "license": "BlueOak-1.0.0",
+      "dependencies": {
+        "lru-cache": "^10.2.0",
+        "minipass": "^5.0.0 || ^6.0.2 || ^7.0.0"
+      },
+      "engines": {
+        "node": ">=16 || 14 >=14.18"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      }
+    },
+    "node_modules/pathe": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/pathe/-/pathe-2.0.3.tgz",
+      "integrity": "sha512-WUjGcAqP1gQacoQe+OBJsFA7Ld4DyXuUIjZ5cc75cLHvJ7dtNsTugphxIADwspS+AraAUePCKrSVtPLFj/F88w==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/pdfjs-dist": {
+      "version": "5.5.207",
+      "resolved": "https://registry.npmjs.org/pdfjs-dist/-/pdfjs-dist-5.5.207.tgz",
+      "integrity": "sha512-WMqqw06w1vUt9ZfT0gOFhMf3wHsWhaCrxGrckGs5Cci6ybDW87IvPaOd2pnBwT6BJuP/CzXDZxjFgmSULLdsdw==",
+      "license": "Apache-2.0",
+      "engines": {
+        "node": ">=20.19.0 || >=22.13.0 || >=24"
+      },
+      "optionalDependencies": {
+        "@napi-rs/canvas": "^0.1.95",
+        "node-readable-to-web-readable-stream": "^0.4.2"
+      }
+    },
+    "node_modules/pend": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/pend/-/pend-1.2.0.tgz",
+      "integrity": "sha512-F3asv42UuXchdzt+xXqfW1OGlVBe+mxa2mqI0pg5yAHZPvFmY3Y6drSf/GQ1A86WgWEN9Kzh/WrgKa6iGcHXLg==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/picocolors": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz",
+      "integrity": "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==",
+      "dev": true,
+      "license": "ISC"
+    },
+    "node_modules/picomatch": {
+      "version": "4.0.3",
+      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.3.tgz",
+      "integrity": "sha512-5gTmgEY/sqK6gFXLIsQNH19lWb4ebPDLA4SdLP7dsWkIXHWlG66oPuVvXSGFPppYZz8ZDZq0dYYrbHfBCVUb1Q==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/jonschlinkert"
+      }
+    },
+    "node_modules/postcss": {
+      "version": "8.5.8",
+      "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.5.8.tgz",
+      "integrity": "sha512-OW/rX8O/jXnm82Ey1k44pObPtdblfiuWnrd8X7GJ7emImCOstunGbXUpp7HdBrFQX6rJzn3sPT397Wp5aCwCHg==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/postcss/"
+        },
+        {
+          "type": "tidelift",
+          "url": "https://tidelift.com/funding/github/npm/postcss"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "nanoid": "^3.3.11",
+        "picocolors": "^1.1.1",
+        "source-map-js": "^1.2.1"
+      },
+      "engines": {
+        "node": "^10 || ^12 || >=14"
+      }
+    },
+    "node_modules/pretty-format": {
+      "version": "30.2.0",
+      "resolved": "https://registry.npmjs.org/pretty-format/-/pretty-format-30.2.0.tgz",
+      "integrity": "sha512-9uBdv/B4EefsuAL+pWqueZyZS2Ba+LxfFeQ9DN14HU4bN8bhaxKdkpjpB6fs9+pSjIBu+FXQHImEg8j/Lw0+vA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jest/schemas": "30.0.5",
+        "ansi-styles": "^5.2.0",
+        "react-is": "^18.3.1"
+      },
+      "engines": {
+        "node": "^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0"
+      }
+    },
+    "node_modules/pretty-ms": {
+      "version": "9.3.0",
+      "resolved": "https://registry.npmjs.org/pretty-ms/-/pretty-ms-9.3.0.tgz",
+      "integrity": "sha512-gjVS5hOP+M3wMm5nmNOucbIrqudzs9v/57bWRHQWLYklXqoXKrVfYW2W9+glfGsqtPgpiz5WwyEEB+ksXIx3gQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "parse-ms": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/process": {
+      "version": "0.11.10",
+      "resolved": "https://registry.npmjs.org/process/-/process-0.11.10.tgz",
+      "integrity": "sha512-cdGef/drWFoydD1JsMzuFf8100nZl+GT+yacc2bEced5f9Rjk4z+WtFUTBu9PhOi9j/jfmBPu0mMEY4wIdAF8A==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6.0"
+      }
+    },
+    "node_modules/process-nextick-args": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/process-nextick-args/-/process-nextick-args-2.0.1.tgz",
+      "integrity": "sha512-3ouUOpQhtgrbOa17J7+uxOTpITYWaGP7/AhoR3+A+/1e9skrzelGi/dXzEYyvbxubEF6Wn2ypscTKiKJFFn1ag==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/progress": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/progress/-/progress-2.0.3.tgz",
+      "integrity": "sha512-7PiHtLll5LdnKIMw100I+8xJXR5gW2QwWYkT6iJva0bXitZKa/XMrSbdmg3r2Xnaidz9Qumd0VPaMrZlF9V9sA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.4.0"
+      }
+    },
+    "node_modules/property-information": {
+      "version": "7.1.0",
+      "resolved": "https://registry.npmjs.org/property-information/-/property-information-7.1.0.tgz",
+      "integrity": "sha512-TwEZ+X+yCJmYfL7TPUOcvBZ4QfoT5YenQiJuX//0th53DE6w0xxLEtfK3iyryQFddXuvkIk51EEgrJQ0WJkOmQ==",
+      "license": "MIT",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
+    "node_modules/proxy-agent": {
+      "version": "6.5.0",
+      "resolved": "https://registry.npmjs.org/proxy-agent/-/proxy-agent-6.5.0.tgz",
+      "integrity": "sha512-TmatMXdr2KlRiA2CyDu8GqR8EjahTG3aY3nXjdzFyoZbmB8hrBsTyMezhULIXKnC0jpfjlmiZ3+EaCzoInSu/A==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "agent-base": "^7.1.2",
+        "debug": "^4.3.4",
+        "http-proxy-agent": "^7.0.1",
+        "https-proxy-agent": "^7.0.6",
+        "lru-cache": "^7.14.1",
+        "pac-proxy-agent": "^7.1.0",
+        "proxy-from-env": "^1.1.0",
+        "socks-proxy-agent": "^8.0.5"
+      },
+      "engines": {
+        "node": ">= 14"
+      }
+    },
+    "node_modules/proxy-agent/node_modules/lru-cache": {
+      "version": "7.18.3",
+      "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-7.18.3.tgz",
+      "integrity": "sha512-jumlc0BIUrS3qJGgIkWZsyfAM7NCWiBcCDhnd+3NNM5KbBmLTgHVfWBcg6W+rLUsIpzpERPsvwUP7CckAQSOoA==",
+      "dev": true,
+      "license": "ISC",
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/proxy-from-env": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/proxy-from-env/-/proxy-from-env-1.1.0.tgz",
+      "integrity": "sha512-D+zkORCbA9f1tdWRK0RaCR3GPv50cMxcrz4X8k5LTSUD1Dkw47mKJEZQNunItRTkWwgtaUSo1RVFRIG9ZXiFYg==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/pump": {
+      "version": "3.0.4",
+      "resolved": "https://registry.npmjs.org/pump/-/pump-3.0.4.tgz",
+      "integrity": "sha512-VS7sjc6KR7e1ukRFhQSY5LM2uBWAUPiOPa/A3mkKmiMwSmRFUITt0xuj+/lesgnCv+dPIEYlkzrcyXgquIHMcA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "end-of-stream": "^1.1.0",
+        "once": "^1.3.1"
+      }
+    },
+    "node_modules/query-selector-shadow-dom": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/query-selector-shadow-dom/-/query-selector-shadow-dom-1.0.1.tgz",
+      "integrity": "sha512-lT5yCqEBgfoMYpf3F2xQRK7zEr1rhIIZuceDK6+xRkJQ4NMbHTwXqk4NkwDwQMNqXgG9r9fyHnzwNVs6zV5KRw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/randombytes": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/randombytes/-/randombytes-2.1.0.tgz",
+      "integrity": "sha512-vYl3iOX+4CKUWuxGi9Ukhie6fsqXqS9FE2Zaic4tNFD2N2QQaXOMFbuKK4QmDHC0JO6B1Zp41J0LpT0oR68amQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "safe-buffer": "^5.1.0"
+      }
+    },
+    "node_modules/react-is": {
+      "version": "18.3.1",
+      "resolved": "https://registry.npmjs.org/react-is/-/react-is-18.3.1.tgz",
+      "integrity": "sha512-/LLMVyas0ljjAtoYiPqYiL8VWXzUUdThrmU5+n20DZv+a+ClRoevUzw5JxU+Ieh5/c87ytoTBV9G1FiKfNJdmg==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/read-pkg": {
+      "version": "8.1.0",
+      "resolved": "https://registry.npmjs.org/read-pkg/-/read-pkg-8.1.0.tgz",
+      "integrity": "sha512-PORM8AgzXeskHO/WEv312k9U03B8K9JSiWF/8N9sUuFjBa+9SF2u6K7VClzXwDXab51jCd8Nd36CNM+zR97ScQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/normalize-package-data": "^2.4.1",
+        "normalize-package-data": "^6.0.0",
+        "parse-json": "^7.0.0",
+        "type-fest": "^4.2.0"
+      },
+      "engines": {
+        "node": ">=16"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/read-pkg-up": {
+      "version": "10.1.0",
+      "resolved": "https://registry.npmjs.org/read-pkg-up/-/read-pkg-up-10.1.0.tgz",
+      "integrity": "sha512-aNtBq4jR8NawpKJQldrQcSW9y/d+KWH4v24HWkHljOZ7H0av+YTGANBzRh9A5pw7v/bLVsLVPpOhJ7gHNVy8lA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "find-up": "^6.3.0",
+        "read-pkg": "^8.1.0",
+        "type-fest": "^4.2.0"
+      },
+      "engines": {
+        "node": ">=16"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/read-pkg-up/node_modules/find-up": {
+      "version": "6.3.0",
+      "resolved": "https://registry.npmjs.org/find-up/-/find-up-6.3.0.tgz",
+      "integrity": "sha512-v2ZsoEuVHYy8ZIlYqwPe/39Cy+cFDzp4dXPaxNvkEuouymu+2Jbz0PxpKarJHYJTmv2HWT3O382qY8l4jMWthw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "locate-path": "^7.1.0",
+        "path-exists": "^5.0.0"
+      },
+      "engines": {
+        "node": "^12.20.0 || ^14.13.1 || >=16.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/read-pkg-up/node_modules/locate-path": {
+      "version": "7.2.0",
+      "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-7.2.0.tgz",
+      "integrity": "sha512-gvVijfZvn7R+2qyPX8mAuKcFGDf6Nc61GdvGafQsHL0sBIxfKzA+usWn4GFC/bk+QdwPUD4kWFJLhElipq+0VA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "p-locate": "^6.0.0"
+      },
+      "engines": {
+        "node": "^12.20.0 || ^14.13.1 || >=16.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/read-pkg-up/node_modules/p-limit": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-4.0.0.tgz",
+      "integrity": "sha512-5b0R4txpzjPWVw/cXXUResoD4hb6U/x9BH08L7nw+GN1sezDzPdxeRvpc9c433fZhBan/wusjbCsqwqm4EIBIQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "yocto-queue": "^1.0.0"
+      },
+      "engines": {
+        "node": "^12.20.0 || ^14.13.1 || >=16.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/read-pkg-up/node_modules/p-locate": {
+      "version": "6.0.0",
+      "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-6.0.0.tgz",
+      "integrity": "sha512-wPrq66Llhl7/4AGC6I+cqxT07LhXvWL08LNXz1fENOw0Ap4sRZZ/gZpTTJ5jpurzzzfS2W/Ge9BY3LgLjCShcw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "p-limit": "^4.0.0"
+      },
+      "engines": {
+        "node": "^12.20.0 || ^14.13.1 || >=16.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/read-pkg-up/node_modules/path-exists": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-5.0.0.tgz",
+      "integrity": "sha512-RjhtfwJOxzcFmNOi6ltcbcu4Iu+FL3zEj83dk4kAS+fVpTxXLO1b38RvJgT/0QwvV/L3aY9TAnyv0EOqW4GoMQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": "^12.20.0 || ^14.13.1 || >=16.0.0"
+      }
+    },
+    "node_modules/read-pkg-up/node_modules/yocto-queue": {
+      "version": "1.2.2",
+      "resolved": "https://registry.npmjs.org/yocto-queue/-/yocto-queue-1.2.2.tgz",
+      "integrity": "sha512-4LCcse/U2MHZ63HAJVE+v71o7yOdIe4cZ70Wpf8D/IyjDKYQLV5GD46B+hSTjJsvV5PztjvHoU580EftxjDZFQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=12.20"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/read-pkg/node_modules/hosted-git-info": {
+      "version": "7.0.2",
+      "resolved": "https://registry.npmjs.org/hosted-git-info/-/hosted-git-info-7.0.2.tgz",
+      "integrity": "sha512-puUZAUKT5m8Zzvs72XWy3HtvVbTWljRE66cP60bxJzAqf2DgICo7lYTY2IHUmLnNpjYvw5bvmoHvPc0QO2a62w==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "lru-cache": "^10.0.1"
+      },
+      "engines": {
+        "node": "^16.14.0 || >=18.0.0"
+      }
+    },
+    "node_modules/read-pkg/node_modules/normalize-package-data": {
+      "version": "6.0.2",
+      "resolved": "https://registry.npmjs.org/normalize-package-data/-/normalize-package-data-6.0.2.tgz",
+      "integrity": "sha512-V6gygoYb/5EmNI+MEGrWkC+e6+Rr7mTmfHrxDbLzxQogBkgzo76rkok0Am6thgSF7Mv2nLOajAJj5vDJZEFn7g==",
+      "dev": true,
+      "license": "BSD-2-Clause",
+      "dependencies": {
+        "hosted-git-info": "^7.0.0",
+        "semver": "^7.3.5",
+        "validate-npm-package-license": "^3.0.4"
+      },
+      "engines": {
+        "node": "^16.14.0 || >=18.0.0"
+      }
+    },
+    "node_modules/readable-stream": {
+      "version": "4.7.0",
+      "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-4.7.0.tgz",
+      "integrity": "sha512-oIGGmcpTLwPga8Bn6/Z75SVaH1z5dUut2ibSyAMVhmUggWpmDn2dapB0n7f8nwaSiRtepAsfJyfXIO5DCVAODg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "abort-controller": "^3.0.0",
+        "buffer": "^6.0.3",
+        "events": "^3.3.0",
+        "process": "^0.11.10",
+        "string_decoder": "^1.3.0"
+      },
+      "engines": {
+        "node": "^12.22.0 || ^14.17.0 || >=16.0.0"
+      }
+    },
+    "node_modules/readdir-glob": {
+      "version": "1.1.3",
+      "resolved": "https://registry.npmjs.org/readdir-glob/-/readdir-glob-1.1.3.tgz",
+      "integrity": "sha512-v05I2k7xN8zXvPD9N+z/uhXPaj0sUFCe2rcWZIpBsqxfP7xXFQ0tipAd/wjj1YxWyWtUS5IDJpOG82JKt2EAVA==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "minimatch": "^5.1.0"
+      }
+    },
+    "node_modules/readdir-glob/node_modules/minimatch": {
+      "version": "5.1.9",
+      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-5.1.9.tgz",
+      "integrity": "sha512-7o1wEA2RyMP7Iu7GNba9vc0RWWGACJOCZBJX2GJWip0ikV+wcOsgVuY9uE8CPiyQhkGFSlhuSkZPavN7u1c2Fw==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "brace-expansion": "^2.0.1"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/readdirp": {
+      "version": "4.1.2",
+      "resolved": "https://registry.npmjs.org/readdirp/-/readdirp-4.1.2.tgz",
+      "integrity": "sha512-GDhwkLfywWL2s6vEjyhri+eXmfH6j1L7JE27WhqLeYzoh/A3DBaYGEj2H/HFZCn/kMfim73FXxEJTw06WtxQwg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 14.18.0"
+      },
+      "funding": {
+        "type": "individual",
+        "url": "https://paulmillr.com/funding/"
+      }
+    },
+    "node_modules/recursive-readdir": {
+      "version": "2.2.3",
+      "resolved": "https://registry.npmjs.org/recursive-readdir/-/recursive-readdir-2.2.3.tgz",
+      "integrity": "sha512-8HrF5ZsXk5FAH9dgsx3BlUer73nIhuj+9OrQwEbLTPOBzGkL1lsFCR01am+v+0m2Cmbs1nP12hLDl5FA7EszKA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "minimatch": "^3.0.5"
+      },
+      "engines": {
+        "node": ">=6.0.0"
+      }
+    },
+    "node_modules/recursive-readdir/node_modules/brace-expansion": {
+      "version": "1.1.12",
+      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.12.tgz",
+      "integrity": "sha512-9T9UjW3r0UW5c1Q7GTwllptXwhvYmEzFhzMfZ9H7FQWt+uZePjZPjBP/W1ZEyZ1twGWom5/56TF4lPcqjnDHcg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "balanced-match": "^1.0.0",
+        "concat-map": "0.0.1"
+      }
+    },
+    "node_modules/recursive-readdir/node_modules/minimatch": {
+      "version": "3.1.5",
+      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.5.tgz",
+      "integrity": "sha512-VgjWUsnnT6n+NUk6eZq77zeFdpW2LWDzP6zFGrCbHXiYNul5Dzqk2HHQ5uFH2DNW5Xbp8+jVzaeNt94ssEEl4w==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "brace-expansion": "^1.1.7"
+      },
+      "engines": {
+        "node": "*"
+      }
+    },
+    "node_modules/regex": {
+      "version": "6.1.0",
+      "resolved": "https://registry.npmjs.org/regex/-/regex-6.1.0.tgz",
+      "integrity": "sha512-6VwtthbV4o/7+OaAF9I5L5V3llLEsoPyq9P1JVXkedTP33c7MfCG0/5NOPcSJn0TzXcG9YUrR0gQSWioew3LDg==",
+      "license": "MIT",
+      "dependencies": {
+        "regex-utilities": "^2.3.0"
+      }
+    },
+    "node_modules/regex-recursion": {
+      "version": "6.0.2",
+      "resolved": "https://registry.npmjs.org/regex-recursion/-/regex-recursion-6.0.2.tgz",
+      "integrity": "sha512-0YCaSCq2VRIebiaUviZNs0cBz1kg5kVS2UKUfNIx8YVs1cN3AV7NTctO5FOKBA+UT2BPJIWZauYHPqJODG50cg==",
+      "license": "MIT",
+      "dependencies": {
+        "regex-utilities": "^2.3.0"
+      }
+    },
+    "node_modules/regex-utilities": {
+      "version": "2.3.0",
+      "resolved": "https://registry.npmjs.org/regex-utilities/-/regex-utilities-2.3.0.tgz",
+      "integrity": "sha512-8VhliFJAWRaUiVvREIiW2NXXTmHs4vMNnSzuJVhscgmGav3g9VDxLrQndI3dZZVVdp0ZO/5v0xmX516/7M9cng==",
+      "license": "MIT"
+    },
+    "node_modules/require-directory": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/require-directory/-/require-directory-2.1.1.tgz",
+      "integrity": "sha512-fGxEI7+wsG9xrvdjsrlmL22OMTTiHRwAMroiEeMgq8gzoLC/PQr7RsRDSTLUg/bZAZtF+TVIkHc6/4RIKrui+Q==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/resolve-pkg-maps": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/resolve-pkg-maps/-/resolve-pkg-maps-1.0.0.tgz",
+      "integrity": "sha512-seS2Tj26TBVOC2NIc2rOe2y2ZO7efxITtLZcGSOnHHNOQ7CkiUBfw0Iw2ck6xkIhPwLhKNLS8BO+hEpngQlqzw==",
+      "dev": true,
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/privatenumber/resolve-pkg-maps?sponsor=1"
+      }
+    },
+    "node_modules/resq": {
+      "version": "1.11.0",
+      "resolved": "https://registry.npmjs.org/resq/-/resq-1.11.0.tgz",
+      "integrity": "sha512-G10EBz+zAAy3zUd/CDoBbXRL6ia9kOo3xRHrMDsHljI0GDkhYlyjwoCx5+3eCC4swi1uCoZQhskuJkj7Gp57Bw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "fast-deep-equal": "^2.0.1"
+      }
+    },
+    "node_modules/ret": {
+      "version": "0.5.0",
+      "resolved": "https://registry.npmjs.org/ret/-/ret-0.5.0.tgz",
+      "integrity": "sha512-I1XxrZSQ+oErkRR4jYbAyEEu2I0avBvvMM5JN+6EBprOGRCs63ENqZ3vjavq8fBw2+62G5LF5XelKwuJpcvcxw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/rgb2hex": {
+      "version": "0.2.5",
+      "resolved": "https://registry.npmjs.org/rgb2hex/-/rgb2hex-0.2.5.tgz",
+      "integrity": "sha512-22MOP1Rh7sAo1BZpDG6R5RFYzR2lYEgwq7HEmyW2qcsOqR2lQKmn+O//xV3YG/0rrhMC6KVX2hU+ZXuaw9a5bw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/rollup": {
+      "version": "4.59.0",
+      "resolved": "https://registry.npmjs.org/rollup/-/rollup-4.59.0.tgz",
+      "integrity": "sha512-2oMpl67a3zCH9H79LeMcbDhXW/UmWG/y2zuqnF2jQq5uq9TbM9TVyXvA4+t+ne2IIkBdrLpAaRQAvo7YI/Yyeg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/estree": "1.0.8"
+      },
+      "bin": {
+        "rollup": "dist/bin/rollup"
+      },
+      "engines": {
+        "node": ">=18.0.0",
+        "npm": ">=8.0.0"
+      },
+      "optionalDependencies": {
+        "@rollup/rollup-android-arm-eabi": "4.59.0",
+        "@rollup/rollup-android-arm64": "4.59.0",
+        "@rollup/rollup-darwin-arm64": "4.59.0",
+        "@rollup/rollup-darwin-x64": "4.59.0",
+        "@rollup/rollup-freebsd-arm64": "4.59.0",
+        "@rollup/rollup-freebsd-x64": "4.59.0",
+        "@rollup/rollup-linux-arm-gnueabihf": "4.59.0",
+        "@rollup/rollup-linux-arm-musleabihf": "4.59.0",
+        "@rollup/rollup-linux-arm64-gnu": "4.59.0",
+        "@rollup/rollup-linux-arm64-musl": "4.59.0",
+        "@rollup/rollup-linux-loong64-gnu": "4.59.0",
+        "@rollup/rollup-linux-loong64-musl": "4.59.0",
+        "@rollup/rollup-linux-ppc64-gnu": "4.59.0",
+        "@rollup/rollup-linux-ppc64-musl": "4.59.0",
+        "@rollup/rollup-linux-riscv64-gnu": "4.59.0",
+        "@rollup/rollup-linux-riscv64-musl": "4.59.0",
+        "@rollup/rollup-linux-s390x-gnu": "4.59.0",
+        "@rollup/rollup-linux-x64-gnu": "4.59.0",
+        "@rollup/rollup-linux-x64-musl": "4.59.0",
+        "@rollup/rollup-openbsd-x64": "4.59.0",
+        "@rollup/rollup-openharmony-arm64": "4.59.0",
+        "@rollup/rollup-win32-arm64-msvc": "4.59.0",
+        "@rollup/rollup-win32-ia32-msvc": "4.59.0",
+        "@rollup/rollup-win32-x64-gnu": "4.59.0",
+        "@rollup/rollup-win32-x64-msvc": "4.59.0",
+        "fsevents": "~2.3.2"
+      }
+    },
+    "node_modules/run-async": {
+      "version": "4.0.6",
+      "resolved": "https://registry.npmjs.org/run-async/-/run-async-4.0.6.tgz",
+      "integrity": "sha512-IoDlSLTs3Yq593mb3ZoKWKXMNu3UpObxhgA/Xuid5p4bbfi2jdY1Hj0m1K+0/tEuQTxIGMhQDqGjKb7RuxGpAQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.12.0"
+      }
+    },
+    "node_modules/rxjs": {
+      "version": "7.8.2",
+      "resolved": "https://registry.npmjs.org/rxjs/-/rxjs-7.8.2.tgz",
+      "integrity": "sha512-dhKf903U/PQZY6boNNtAGdWbG85WAbjT/1xYoZIC7FAY0yWapOBQVsVrDl58W86//e1VpMNBtRV4MaXfdMySFA==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "tslib": "^2.1.0"
+      }
+    },
+    "node_modules/sade": {
+      "version": "1.8.1",
+      "resolved": "https://registry.npmjs.org/sade/-/sade-1.8.1.tgz",
+      "integrity": "sha512-xal3CZX1Xlo/k4ApwCFrHVACi9fBqJ7V+mwhBsuf/1IOKbBy098Fex+Wa/5QMubw09pSZ/u8EY8PWgevJsXp1A==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "mri": "^1.1.0"
+      },
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/safaridriver": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/safaridriver/-/safaridriver-1.0.1.tgz",
+      "integrity": "sha512-jkg4434cYgtrIF2AeY/X0Wmd2W73cK5qIEFE3hDrrQenJH/2SDJIXGvPAigfvQTcE9+H31zkiNHbUqcihEiMRA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=18.0.0"
+      }
+    },
+    "node_modules/safe-buffer": {
+      "version": "5.2.1",
+      "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz",
+      "integrity": "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/feross"
+        },
+        {
+          "type": "patreon",
+          "url": "https://www.patreon.com/feross"
+        },
+        {
+          "type": "consulting",
+          "url": "https://feross.org/support"
+        }
+      ],
+      "license": "MIT"
+    },
+    "node_modules/safe-regex2": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/safe-regex2/-/safe-regex2-5.0.0.tgz",
+      "integrity": "sha512-YwJwe5a51WlK7KbOJREPdjNrpViQBI3p4T50lfwPuDhZnE3XGVTlGvi+aolc5+RvxDD6bnUmjVsU9n1eboLUYw==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/fastify"
+        },
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/fastify"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "ret": "~0.5.0"
+      }
+    },
+    "node_modules/safer-buffer": {
+      "version": "2.1.2",
+      "resolved": "https://registry.npmjs.org/safer-buffer/-/safer-buffer-2.1.2.tgz",
+      "integrity": "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/semver": {
+      "version": "7.7.4",
+      "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.4.tgz",
+      "integrity": "sha512-vFKC2IEtQnVhpT78h1Yp8wzwrf8CM+MzKMHGJZfBtzhZNycRFnXsHk6E5TxIkkMsgNS7mdX3AGB7x2QM2di4lA==",
+      "dev": true,
+      "license": "ISC",
+      "bin": {
+        "semver": "bin/semver.js"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/serialize-error": {
+      "version": "12.0.0",
+      "resolved": "https://registry.npmjs.org/serialize-error/-/serialize-error-12.0.0.tgz",
+      "integrity": "sha512-ZYkZLAvKTKQXWuh5XpBw7CdbSzagarX39WyZ2H07CDLC5/KfsRGlIXV8d4+tfqX1M7916mRqR1QfNHSij+c9Pw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "type-fest": "^4.31.0"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/serialize-javascript": {
+      "version": "6.0.2",
+      "resolved": "https://registry.npmjs.org/serialize-javascript/-/serialize-javascript-6.0.2.tgz",
+      "integrity": "sha512-Saa1xPByTTq2gdeFZYLLo+RFE35NHZkAbqZeWNd3BpzppeVisAqpDjcp8dyf6uIvEqJRd46jemmyA4iFIeVk8g==",
+      "dev": true,
+      "license": "BSD-3-Clause",
+      "dependencies": {
+        "randombytes": "^2.1.0"
+      }
+    },
+    "node_modules/setimmediate": {
+      "version": "1.0.5",
+      "resolved": "https://registry.npmjs.org/setimmediate/-/setimmediate-1.0.5.tgz",
+      "integrity": "sha512-MATJdZp8sLqDl/68LfQmbP8zKPLQNV6BIZoIgrscFDQ+RsvK/BxeDQOgyxKKoh0y/8h3BqVFnCqQ/gd+reiIXA==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/shebang-command": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/shebang-command/-/shebang-command-2.0.0.tgz",
+      "integrity": "sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "shebang-regex": "^3.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/shebang-regex": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/shebang-regex/-/shebang-regex-3.0.0.tgz",
+      "integrity": "sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/shiki": {
+      "version": "4.0.1",
+      "resolved": "https://registry.npmjs.org/shiki/-/shiki-4.0.1.tgz",
+      "integrity": "sha512-EkAEhDTN5WhpoQFXFw79OHIrSAfHhlImeCdSyg4u4XvrpxKEmdo/9x/HWSowujAnUrFsGOwWiE58a6GVentMnQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@shikijs/core": "4.0.1",
+        "@shikijs/engine-javascript": "4.0.1",
+        "@shikijs/engine-oniguruma": "4.0.1",
+        "@shikijs/langs": "4.0.1",
+        "@shikijs/themes": "4.0.1",
+        "@shikijs/types": "4.0.1",
+        "@shikijs/vscode-textmate": "^10.0.2",
+        "@types/hast": "^3.0.4"
+      },
+      "engines": {
+        "node": ">=20"
+      }
+    },
+    "node_modules/siginfo": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/siginfo/-/siginfo-2.0.0.tgz",
+      "integrity": "sha512-ybx0WO1/8bSBLEWXZvEd7gMW3Sn3JFlW3TvX1nREbDLRNQNaeNN8WK0meBwPdAaOI7TtRRRJn/Es1zhrrCHu7g==",
+      "dev": true,
+      "license": "ISC"
+    },
+    "node_modules/signal-exit": {
+      "version": "4.1.0",
+      "resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-4.1.0.tgz",
+      "integrity": "sha512-bzyZ1e88w9O1iNJbKnOlvYTrWPDl46O1bG0D3XInv+9tkPrxrN8jUUTiFlDkkmKWgn1M6CfIA13SuGqOa9Korw==",
+      "dev": true,
+      "license": "ISC",
+      "engines": {
+        "node": ">=14"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      }
+    },
+    "node_modules/slash": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/slash/-/slash-3.0.0.tgz",
+      "integrity": "sha512-g9Q1haeby36OSStwb4ntCGGGaKsaVSjQ68fBxoQcutl5fS1vuY18H3wSt3jFyFtrkx+Kz0V1G85A4MyAdDMi2Q==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/smart-buffer": {
+      "version": "4.2.0",
+      "resolved": "https://registry.npmjs.org/smart-buffer/-/smart-buffer-4.2.0.tgz",
+      "integrity": "sha512-94hK0Hh8rPqQl2xXc3HsaBoOXKV20MToPkcXvwbISWLEs+64sBq5kFgn2kJDHb1Pry9yrP0dxrCI9RRci7RXKg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 6.0.0",
+        "npm": ">= 3.0.0"
+      }
+    },
+    "node_modules/socks": {
+      "version": "2.8.7",
+      "resolved": "https://registry.npmjs.org/socks/-/socks-2.8.7.tgz",
+      "integrity": "sha512-HLpt+uLy/pxB+bum/9DzAgiKS8CX1EvbWxI4zlmgGCExImLdiad2iCwXT5Z4c9c3Eq8rP2318mPW2c+QbtjK8A==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "ip-address": "^10.0.1",
+        "smart-buffer": "^4.2.0"
+      },
+      "engines": {
+        "node": ">= 10.0.0",
+        "npm": ">= 3.0.0"
+      }
+    },
+    "node_modules/socks-proxy-agent": {
+      "version": "8.0.5",
+      "resolved": "https://registry.npmjs.org/socks-proxy-agent/-/socks-proxy-agent-8.0.5.tgz",
+      "integrity": "sha512-HehCEsotFqbPW9sJ8WVYB6UbmIMv7kUUORIF2Nncq4VQvBfNBLibW9YZR5dlYCSUhwcD628pRllm7n+E+YTzJw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "agent-base": "^7.1.2",
+        "debug": "^4.3.4",
+        "socks": "^2.8.3"
+      },
+      "engines": {
+        "node": ">= 14"
+      }
+    },
+    "node_modules/source-map": {
+      "version": "0.6.1",
+      "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz",
+      "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==",
+      "dev": true,
+      "license": "BSD-3-Clause",
+      "optional": true,
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/source-map-js": {
+      "version": "1.2.1",
+      "resolved": "https://registry.npmjs.org/source-map-js/-/source-map-js-1.2.1.tgz",
+      "integrity": "sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==",
+      "dev": true,
+      "license": "BSD-3-Clause",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/space-separated-tokens": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/space-separated-tokens/-/space-separated-tokens-2.0.2.tgz",
+      "integrity": "sha512-PEGlAwrG8yXGXRjW32fGbg66JAlOAwbObuqVoJpv/mRgoWDQfgH1wDPvtzWyUSNAXBGSk8h755YDbbcEy3SH2Q==",
+      "license": "MIT",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
+    "node_modules/spacetrim": {
+      "version": "0.11.59",
+      "resolved": "https://registry.npmjs.org/spacetrim/-/spacetrim-0.11.59.tgz",
+      "integrity": "sha512-lLYsktklSRKprreOm7NXReW8YiX2VBjbgmXYEziOoGf/qsJqAEACaDvoTtUOycwjpaSh+bT8eu0KrJn7UNxiCg==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "individual",
+          "url": "https://buymeacoffee.com/hejny"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/hejny/spacetrim/blob/main/README.md#%EF%B8%8F-contributing"
+        }
+      ],
+      "license": "Apache-2.0"
+    },
+    "node_modules/spdx-correct": {
+      "version": "3.2.0",
+      "resolved": "https://registry.npmjs.org/spdx-correct/-/spdx-correct-3.2.0.tgz",
+      "integrity": "sha512-kN9dJbvnySHULIluDHy32WHRUu3Og7B9sbY7tsFLctQkIqnMh3hErYgdMjTYuqmcXX+lK5T1lnUt3G7zNswmZA==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "spdx-expression-parse": "^3.0.0",
+        "spdx-license-ids": "^3.0.0"
+      }
+    },
+    "node_modules/spdx-exceptions": {
+      "version": "2.5.0",
+      "resolved": "https://registry.npmjs.org/spdx-exceptions/-/spdx-exceptions-2.5.0.tgz",
+      "integrity": "sha512-PiU42r+xO4UbUS1buo3LPJkjlO7430Xn5SVAhdpzzsPHsjbYVflnnFdATgabnLude+Cqu25p6N+g2lw/PFsa4w==",
+      "dev": true,
+      "license": "CC-BY-3.0"
+    },
+    "node_modules/spdx-expression-parse": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/spdx-expression-parse/-/spdx-expression-parse-3.0.1.tgz",
+      "integrity": "sha512-cbqHunsQWnJNE6KhVSMsMeH5H/L9EpymbzqTQ3uLwNCLZ1Q481oWaofqH7nO6V07xlXwY6PhQdQ2IedWx/ZK4Q==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "spdx-exceptions": "^2.1.0",
+        "spdx-license-ids": "^3.0.0"
+      }
+    },
+    "node_modules/spdx-license-ids": {
+      "version": "3.0.23",
+      "resolved": "https://registry.npmjs.org/spdx-license-ids/-/spdx-license-ids-3.0.23.tgz",
+      "integrity": "sha512-CWLcCCH7VLu13TgOH+r8p1O/Znwhqv/dbb6lqWy67G+pT1kHmeD/+V36AVb/vq8QMIQwVShJ6Ssl5FPh0fuSdw==",
+      "dev": true,
+      "license": "CC0-1.0"
+    },
+    "node_modules/split2": {
+      "version": "4.2.0",
+      "resolved": "https://registry.npmjs.org/split2/-/split2-4.2.0.tgz",
+      "integrity": "sha512-UcjcJOWknrNkF6PLX83qcHM6KHgVKNkV62Y8a5uYDVv9ydGQVwAHMKqHdJje1VTWpljG0WYpCDhrCdAOYH4TWg==",
+      "dev": true,
+      "license": "ISC",
+      "engines": {
+        "node": ">= 10.x"
+      }
+    },
+    "node_modules/stack-utils": {
+      "version": "2.0.6",
+      "resolved": "https://registry.npmjs.org/stack-utils/-/stack-utils-2.0.6.tgz",
+      "integrity": "sha512-XlkWvfIm6RmsWtNJx+uqtKLS8eqFbxUg0ZzLXqY0caEy9l7hruX8IpiDnjsLavoBgqCCR71TqWO8MaXYheJ3RQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "escape-string-regexp": "^2.0.0"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/stack-utils/node_modules/escape-string-regexp": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-2.0.0.tgz",
+      "integrity": "sha512-UpzcLCXolUWcNu5HtVMHYdXJjArjsF9C0aNnquZYY4uW/Vu0miy5YoWvbV345HauVvcAUnpRuhMMcqTcGOY2+w==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/stackback": {
+      "version": "0.0.2",
+      "resolved": "https://registry.npmjs.org/stackback/-/stackback-0.0.2.tgz",
+      "integrity": "sha512-1XMJE5fQo1jGH6Y/7ebnwPOBEkIEnT4QF32d5R1+VXdXveM0IBMJt8zfaxX1P3QhVwrYe+576+jkANtSS2mBbw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/std-env": {
+      "version": "3.10.0",
+      "resolved": "https://registry.npmjs.org/std-env/-/std-env-3.10.0.tgz",
+      "integrity": "sha512-5GS12FdOZNliM5mAOxFRg7Ir0pWz8MdpYm6AY6VPkGpbA7ZzmbzNcBJQ0GPvvyWgcY7QAhCgf9Uy89I03faLkg==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/stream-buffers": {
+      "version": "3.0.3",
+      "resolved": "https://registry.npmjs.org/stream-buffers/-/stream-buffers-3.0.3.tgz",
+      "integrity": "sha512-pqMqwQCso0PBJt2PQmDO0cFj0lyqmiwOMiMSkVtRokl7e+ZTRYgDHKnuZNbqjiJXgsg4nuqtD/zxuo9KqTp0Yw==",
+      "dev": true,
+      "license": "Unlicense",
+      "engines": {
+        "node": ">= 0.10.0"
+      }
+    },
+    "node_modules/streamx": {
+      "version": "2.23.0",
+      "resolved": "https://registry.npmjs.org/streamx/-/streamx-2.23.0.tgz",
+      "integrity": "sha512-kn+e44esVfn2Fa/O0CPFcex27fjIL6MkVae0Mm6q+E6f0hWv578YCERbv+4m02cjxvDsPKLnmxral/rR6lBMAg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "events-universal": "^1.0.0",
+        "fast-fifo": "^1.3.2",
+        "text-decoder": "^1.1.0"
+      }
+    },
+    "node_modules/string_decoder": {
+      "version": "1.3.0",
+      "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.3.0.tgz",
+      "integrity": "sha512-hkRX8U1WjJFd8LsDJ2yQ/wWWxaopEsABU1XfkM8A+j0+85JAGppt16cr1Whg6KIbb4okU6Mql6BOj+uup/wKeA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "safe-buffer": "~5.2.0"
+      }
+    },
+    "node_modules/string-width": {
+      "version": "5.1.2",
+      "resolved": "https://registry.npmjs.org/string-width/-/string-width-5.1.2.tgz",
+      "integrity": "sha512-HnLOCR3vjcY8beoNLtcjZ5/nxn2afmME6lhrDrebokqMap+XbeW8n9TXpPDOqdGK5qcI3oT0GKTW6wC7EMiVqA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "eastasianwidth": "^0.2.0",
+        "emoji-regex": "^9.2.2",
+        "strip-ansi": "^7.0.1"
+      },
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/string-width-cjs": {
+      "name": "string-width",
+      "version": "4.2.3",
+      "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz",
+      "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "emoji-regex": "^8.0.0",
+        "is-fullwidth-code-point": "^3.0.0",
+        "strip-ansi": "^6.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/string-width-cjs/node_modules/emoji-regex": {
+      "version": "8.0.0",
+      "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz",
+      "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/string-width-cjs/node_modules/strip-ansi": {
+      "version": "6.0.1",
+      "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz",
+      "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "ansi-regex": "^5.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/stringify-entities": {
+      "version": "4.0.4",
+      "resolved": "https://registry.npmjs.org/stringify-entities/-/stringify-entities-4.0.4.tgz",
+      "integrity": "sha512-IwfBptatlO+QCJUo19AqvrPNqlVMpW9YEL2LIVY+Rpv2qsjCGxaDLNRgeGsQWJhfItebuJhsGSLjaBbNSQ+ieg==",
+      "license": "MIT",
+      "dependencies": {
+        "character-entities-html4": "^2.0.0",
+        "character-entities-legacy": "^3.0.0"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
+    "node_modules/strip-ansi": {
+      "version": "7.2.0",
+      "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-7.2.0.tgz",
+      "integrity": "sha512-yDPMNjp4WyfYBkHnjIRLfca1i6KMyGCtsVgoKe/z1+6vukgaENdgGBZt+ZmKPc4gavvEZ5OgHfHdrazhgNyG7w==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "ansi-regex": "^6.2.2"
+      },
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/strip-ansi?sponsor=1"
+      }
+    },
+    "node_modules/strip-ansi-cjs": {
+      "name": "strip-ansi",
+      "version": "6.0.1",
+      "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz",
+      "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "ansi-regex": "^5.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/strip-ansi/node_modules/ansi-regex": {
+      "version": "6.2.2",
+      "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-6.2.2.tgz",
+      "integrity": "sha512-Bq3SmSpyFHaWjPk8If9yc6svM8c56dB5BAtW4Qbw5jHTwwXXcTLoRMkpDJp6VL0XzlWaCHTXrkFURMYmD0sLqg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/ansi-regex?sponsor=1"
+      }
+    },
+    "node_modules/strip-final-newline": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/strip-final-newline/-/strip-final-newline-4.0.0.tgz",
+      "integrity": "sha512-aulFJcD6YK8V1G7iRB5tigAP4TsHBZZrOV8pjV++zdUwmeV8uzbY7yn6h9MswN62adStNZFuCIx4haBnRuMDaw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/strip-json-comments": {
+      "version": "3.1.1",
+      "resolved": "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-3.1.1.tgz",
+      "integrity": "sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/strnum": {
+      "version": "2.2.0",
+      "resolved": "https://registry.npmjs.org/strnum/-/strnum-2.2.0.tgz",
+      "integrity": "sha512-Y7Bj8XyJxnPAORMZj/xltsfo55uOiyHcU2tnAVzHUnSJR/KsEX+9RoDeXEnsXtl/CX4fAcrt64gZ13aGaWPeBg==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/NaturalIntelligence"
+        }
+      ],
+      "license": "MIT"
+    },
+    "node_modules/style-mod": {
+      "version": "4.1.3",
+      "resolved": "https://registry.npmjs.org/style-mod/-/style-mod-4.1.3.tgz",
+      "integrity": "sha512-i/n8VsZydrugj3Iuzll8+x/00GH2vnYsk1eomD8QiRrSAeW6ItbCQDtfXCeJHd0iwiNagqjQkvpvREEPtW3IoQ==",
+      "license": "MIT"
+    },
+    "node_modules/supports-color": {
+      "version": "8.1.1",
+      "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-8.1.1.tgz",
+      "integrity": "sha512-MpUEN2OodtUzxvKQl72cUF7RQ5EiHsGvSsVG0ia9c5RbWGL2CI4C7EpPS8UTBIplnlzZiNuV56w+FuNxy3ty2Q==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "has-flag": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/supports-color?sponsor=1"
+      }
+    },
+    "node_modules/svelte": {
+      "version": "5.53.7",
+      "resolved": "https://registry.npmjs.org/svelte/-/svelte-5.53.7.tgz",
+      "integrity": "sha512-uxck1KI7JWtlfP3H6HOWi/94soAl23jsGJkBzN2BAWcQng0+lTrRNhxActFqORgnO9BHVd1hKJhG+ljRuIUWfQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jridgewell/remapping": "^2.3.4",
+        "@jridgewell/sourcemap-codec": "^1.5.0",
+        "@sveltejs/acorn-typescript": "^1.0.5",
+        "@types/estree": "^1.0.5",
+        "@types/trusted-types": "^2.0.7",
+        "acorn": "^8.12.1",
+        "aria-query": "5.3.1",
+        "axobject-query": "^4.1.0",
+        "clsx": "^2.1.1",
+        "devalue": "^5.6.3",
+        "esm-env": "^1.2.1",
+        "esrap": "^2.2.2",
+        "is-reference": "^3.0.3",
+        "locate-character": "^3.0.0",
+        "magic-string": "^0.30.11",
+        "zimmerframe": "^1.1.2"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/svelte-check": {
+      "version": "4.4.4",
+      "resolved": "https://registry.npmjs.org/svelte-check/-/svelte-check-4.4.4.tgz",
+      "integrity": "sha512-F1pGqXc710Oi/wTI4d/x7d6lgPwwfx1U6w3Q35n4xsC2e8C/yN2sM1+mWxjlMcpAfWucjlq4vPi+P4FZ8a14sQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jridgewell/trace-mapping": "^0.3.25",
+        "chokidar": "^4.0.1",
+        "fdir": "^6.2.0",
+        "picocolors": "^1.0.0",
+        "sade": "^1.7.4"
+      },
+      "bin": {
+        "svelte-check": "bin/svelte-check"
+      },
+      "engines": {
+        "node": ">= 18.0.0"
+      },
+      "peerDependencies": {
+        "svelte": "^4.0.0 || ^5.0.0-next.0",
+        "typescript": ">=5.0.0"
+      }
+    },
+    "node_modules/tar-fs": {
+      "version": "3.1.2",
+      "resolved": "https://registry.npmjs.org/tar-fs/-/tar-fs-3.1.2.tgz",
+      "integrity": "sha512-QGxxTxxyleAdyM3kpFs14ymbYmNFrfY+pHj7Z8FgtbZ7w2//VAgLMac7sT6nRpIHjppXO2AwwEOg0bPFVRcmXw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "pump": "^3.0.0",
+        "tar-stream": "^3.1.5"
+      },
+      "optionalDependencies": {
+        "bare-fs": "^4.0.1",
+        "bare-path": "^3.0.0"
+      }
+    },
+    "node_modules/tar-stream": {
+      "version": "3.1.8",
+      "resolved": "https://registry.npmjs.org/tar-stream/-/tar-stream-3.1.8.tgz",
+      "integrity": "sha512-U6QpVRyCGHva435KoNWy9PRoi2IFYCgtEhq9nmrPPpbRacPs9IH4aJ3gbrFC8dPcXvdSZ4XXfXT5Fshbp2MtlQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "b4a": "^1.6.4",
+        "bare-fs": "^4.5.5",
+        "fast-fifo": "^1.2.0",
+        "streamx": "^2.15.0"
+      }
+    },
+    "node_modules/teex": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/teex/-/teex-1.0.1.tgz",
+      "integrity": "sha512-eYE6iEI62Ni1H8oIa7KlDU6uQBtqr4Eajni3wX7rpfXD8ysFx8z0+dri+KWEPWpBsxXfxu58x/0jvTVT1ekOSg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "streamx": "^2.12.5"
+      }
+    },
+    "node_modules/text-decoder": {
+      "version": "1.2.7",
+      "resolved": "https://registry.npmjs.org/text-decoder/-/text-decoder-1.2.7.tgz",
+      "integrity": "sha512-vlLytXkeP4xvEq2otHeJfSQIRyWxo/oZGEbXrtEEF9Hnmrdly59sUbzZ/QgyWuLYHctCHxFF4tRQZNQ9k60ExQ==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "b4a": "^1.6.4"
+      }
+    },
+    "node_modules/tinybench": {
+      "version": "2.9.0",
+      "resolved": "https://registry.npmjs.org/tinybench/-/tinybench-2.9.0.tgz",
+      "integrity": "sha512-0+DUvqWMValLmha6lr4kD8iAMK1HzV0/aKnCtWb9v9641TnP/MFb7Pc2bxoxQjTXAErryXVgUOfv2YqNllqGeg==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/tinyexec": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/tinyexec/-/tinyexec-1.0.2.tgz",
+      "integrity": "sha512-W/KYk+NFhkmsYpuHq5JykngiOCnxeVL8v8dFnqxSD8qEEdRfXk1SDM6JzNqcERbcGYj9tMrDQBYV9cjgnunFIg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/tinyglobby": {
+      "version": "0.2.15",
+      "resolved": "https://registry.npmjs.org/tinyglobby/-/tinyglobby-0.2.15.tgz",
+      "integrity": "sha512-j2Zq4NyQYG5XMST4cbs02Ak8iJUdxRM0XI5QyxXuZOzKOINmWurp3smXu3y5wDcJrptwpSjgXHzIQxR0omXljQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "fdir": "^6.5.0",
+        "picomatch": "^4.0.3"
+      },
+      "engines": {
+        "node": ">=12.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/SuperchupuDev"
+      }
+    },
+    "node_modules/tinyrainbow": {
+      "version": "3.0.3",
+      "resolved": "https://registry.npmjs.org/tinyrainbow/-/tinyrainbow-3.0.3.tgz",
+      "integrity": "sha512-PSkbLUoxOFRzJYjjxHJt9xro7D+iilgMX/C9lawzVuYiIdcihh9DXmVibBe8lmcFrRi/VzlPjBxbN7rH24q8/Q==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=14.0.0"
+      }
+    },
+    "node_modules/to-regex-range": {
+      "version": "5.0.1",
+      "resolved": "https://registry.npmjs.org/to-regex-range/-/to-regex-range-5.0.1.tgz",
+      "integrity": "sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "is-number": "^7.0.0"
+      },
+      "engines": {
+        "node": ">=8.0"
+      }
+    },
+    "node_modules/trim-lines": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/trim-lines/-/trim-lines-3.0.1.tgz",
+      "integrity": "sha512-kRj8B+YHZCc9kQYdWfJB2/oUl9rA99qbowYYBtr4ui4mZyAQ2JpvVBd/6U2YloATfqBhBTSMhTpgBHtU0Mf3Rg==",
+      "license": "MIT",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
+    "node_modules/tslib": {
+      "version": "2.8.1",
+      "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.8.1.tgz",
+      "integrity": "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==",
+      "dev": true,
+      "license": "0BSD"
+    },
+    "node_modules/tsx": {
+      "version": "4.21.0",
+      "resolved": "https://registry.npmjs.org/tsx/-/tsx-4.21.0.tgz",
+      "integrity": "sha512-5C1sg4USs1lfG0GFb2RLXsdpXqBSEhAaA/0kPL01wxzpMqLILNxIxIOKiILz+cdg/pLnOUxFYOR5yhHU666wbw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "esbuild": "~0.27.0",
+        "get-tsconfig": "^4.7.5"
+      },
+      "bin": {
+        "tsx": "dist/cli.mjs"
+      },
+      "engines": {
+        "node": ">=18.0.0"
+      },
+      "optionalDependencies": {
+        "fsevents": "~2.3.3"
+      }
+    },
+    "node_modules/type-fest": {
+      "version": "4.41.0",
+      "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-4.41.0.tgz",
+      "integrity": "sha512-TeTSQ6H5YHvpqVwBRcnLDCBnDOHWYu7IvGbHT6N8AOymcr9PJGjc1GTtiWZTYg0NCgYwvnYWEkVChQAr9bjfwA==",
+      "dev": true,
+      "license": "(MIT OR CC0-1.0)",
+      "engines": {
+        "node": ">=16"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/typescript": {
+      "version": "5.9.3",
+      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.9.3.tgz",
+      "integrity": "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "bin": {
+        "tsc": "bin/tsc",
+        "tsserver": "bin/tsserver"
+      },
+      "engines": {
+        "node": ">=14.17"
+      }
+    },
+    "node_modules/undici": {
+      "version": "6.23.0",
+      "resolved": "https://registry.npmjs.org/undici/-/undici-6.23.0.tgz",
+      "integrity": "sha512-VfQPToRA5FZs/qJxLIinmU59u0r7LXqoJkCzinq3ckNJp3vKEh7jTWN589YQ5+aoAC/TGRLyJLCPKcLQbM8r9g==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=18.17"
+      }
+    },
+    "node_modules/undici-types": {
+      "version": "7.16.0",
+      "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-7.16.0.tgz",
+      "integrity": "sha512-Zz+aZWSj8LE6zoxD+xrjh4VfkIG8Ya6LvYkZqtUQGJPZjYl53ypCaUwWqo7eI0x66KBGeRo+mlBEkMSeSZ38Nw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/unicorn-magic": {
+      "version": "0.3.0",
+      "resolved": "https://registry.npmjs.org/unicorn-magic/-/unicorn-magic-0.3.0.tgz",
+      "integrity": "sha512-+QBBXBCvifc56fsbuxZQ6Sic3wqqc3WWaqxs58gvJrcOuN83HGTCwz3oS5phzU9LthRNE9VrJCFCLUgHeeFnfA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/unist-util-is": {
+      "version": "6.0.1",
+      "resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-6.0.1.tgz",
+      "integrity": "sha512-LsiILbtBETkDz8I9p1dQ0uyRUWuaQzd/cuEeS1hoRSyW5E5XGmTzlwY1OrNzzakGowI9Dr/I8HVaw4hTtnxy8g==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/unist": "^3.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/unist-util-position": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/unist-util-position/-/unist-util-position-5.0.0.tgz",
+      "integrity": "sha512-fucsC7HjXvkB5R3kTCO7kUjRdrS0BJt3M/FPxmHMBOm8JQi2BsHAHFsy27E0EolP8rp0NzXsJ+jNPyDWvOJZPA==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/unist": "^3.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/unist-util-stringify-position": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/unist-util-stringify-position/-/unist-util-stringify-position-4.0.0.tgz",
+      "integrity": "sha512-0ASV06AAoKCDkS2+xw5RXJywruurpbC4JZSm7nr7MOt1ojAzvyyaO+UxZf18j8FCF6kmzCZKcAgN/yu2gm2XgQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/unist": "^3.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/unist-util-visit": {
+      "version": "5.1.0",
+      "resolved": "https://registry.npmjs.org/unist-util-visit/-/unist-util-visit-5.1.0.tgz",
+      "integrity": "sha512-m+vIdyeCOpdr/QeQCu2EzxX/ohgS8KbnPDgFni4dQsfSCtpz8UqDyY5GjRru8PDKuYn7Fq19j1CQ+nJSsGKOzg==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/unist": "^3.0.0",
+        "unist-util-is": "^6.0.0",
+        "unist-util-visit-parents": "^6.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/unist-util-visit-parents": {
+      "version": "6.0.2",
+      "resolved": "https://registry.npmjs.org/unist-util-visit-parents/-/unist-util-visit-parents-6.0.2.tgz",
+      "integrity": "sha512-goh1s1TBrqSqukSc8wrjwWhL0hiJxgA8m4kFxGlQ+8FYQ3C/m11FcTs4YYem7V664AhHVvgoQLk890Ssdsr2IQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/unist": "^3.0.0",
+        "unist-util-is": "^6.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/urlpattern-polyfill": {
+      "version": "10.1.0",
+      "resolved": "https://registry.npmjs.org/urlpattern-polyfill/-/urlpattern-polyfill-10.1.0.tgz",
+      "integrity": "sha512-IGjKp/o0NL3Bso1PymYURCJxMPNAf/ILOpendP9f5B6e1rTJgdgiOvgfoT8VxCAdY+Wisb9uhGaJJf3yZ2V9nw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/userhome": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/userhome/-/userhome-1.0.1.tgz",
+      "integrity": "sha512-5cnLm4gseXjAclKowC4IjByaGsjtAoV6PrOQOljplNB54ReUYJP8HdAFq2muHinSDAh09PPX/uXDPfdxRHvuSA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8.0"
+      }
+    },
+    "node_modules/util-deprecate": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/util-deprecate/-/util-deprecate-1.0.2.tgz",
+      "integrity": "sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/validate-npm-package-license": {
+      "version": "3.0.4",
+      "resolved": "https://registry.npmjs.org/validate-npm-package-license/-/validate-npm-package-license-3.0.4.tgz",
+      "integrity": "sha512-DpKm2Ui/xN7/HQKCtpZxoRWBhZ9Z0kqtygG8XCgNQ8ZlDnxuQmWhj566j8fN4Cu3/JmbhsDo7fcAJq4s9h27Ew==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "spdx-correct": "^3.0.0",
+        "spdx-expression-parse": "^3.0.0"
+      }
+    },
+    "node_modules/vfile": {
+      "version": "6.0.3",
+      "resolved": "https://registry.npmjs.org/vfile/-/vfile-6.0.3.tgz",
+      "integrity": "sha512-KzIbH/9tXat2u30jf+smMwFCsno4wHVdNmzFyL+T/L3UGqqk6JKfVqOFOZEpZSHADH1k40ab6NUIXZq422ov3Q==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/unist": "^3.0.0",
+        "vfile-message": "^4.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/vfile-message": {
+      "version": "4.0.3",
+      "resolved": "https://registry.npmjs.org/vfile-message/-/vfile-message-4.0.3.tgz",
+      "integrity": "sha512-QTHzsGd1EhbZs4AsQ20JX1rC3cOlt/IWJruk893DfLRr57lcnOeMaWG4K0JrRta4mIJZKth2Au3mM3u03/JWKw==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/unist": "^3.0.0",
+        "unist-util-stringify-position": "^4.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/vite": {
+      "version": "7.3.1",
+      "resolved": "https://registry.npmjs.org/vite/-/vite-7.3.1.tgz",
+      "integrity": "sha512-w+N7Hifpc3gRjZ63vYBXA56dvvRlNWRczTdmCBBa+CotUzAPf5b7YMdMR/8CQoeYE5LX3W4wj6RYTgonm1b9DA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "esbuild": "^0.27.0",
+        "fdir": "^6.5.0",
+        "picomatch": "^4.0.3",
+        "postcss": "^8.5.6",
+        "rollup": "^4.43.0",
+        "tinyglobby": "^0.2.15"
+      },
+      "bin": {
+        "vite": "bin/vite.js"
+      },
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      },
+      "funding": {
+        "url": "https://github.com/vitejs/vite?sponsor=1"
+      },
+      "optionalDependencies": {
+        "fsevents": "~2.3.3"
+      },
+      "peerDependencies": {
+        "@types/node": "^20.19.0 || >=22.12.0",
+        "jiti": ">=1.21.0",
+        "less": "^4.0.0",
+        "lightningcss": "^1.21.0",
+        "sass": "^1.70.0",
+        "sass-embedded": "^1.70.0",
+        "stylus": ">=0.54.8",
+        "sugarss": "^5.0.0",
+        "terser": "^5.16.0",
+        "tsx": "^4.8.1",
+        "yaml": "^2.4.2"
+      },
+      "peerDependenciesMeta": {
+        "@types/node": {
+          "optional": true
+        },
+        "jiti": {
+          "optional": true
+        },
+        "less": {
+          "optional": true
+        },
+        "lightningcss": {
+          "optional": true
+        },
+        "sass": {
+          "optional": true
+        },
+        "sass-embedded": {
+          "optional": true
+        },
+        "stylus": {
+          "optional": true
+        },
+        "sugarss": {
+          "optional": true
+        },
+        "terser": {
+          "optional": true
+        },
+        "tsx": {
+          "optional": true
+        },
+        "yaml": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/vitefu": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/vitefu/-/vitefu-1.1.2.tgz",
+      "integrity": "sha512-zpKATdUbzbsycPFBN71nS2uzBUQiVnFoOrr2rvqv34S1lcAgMKKkjWleLGeiJlZ8lwCXvtWaRn7R3ZC16SYRuw==",
+      "dev": true,
+      "license": "MIT",
+      "workspaces": [
+        "tests/deps/*",
+        "tests/projects/*",
+        "tests/projects/workspace/packages/*"
+      ],
+      "peerDependencies": {
+        "vite": "^3.0.0 || ^4.0.0 || ^5.0.0 || ^6.0.0 || ^7.0.0 || ^8.0.0-beta.0"
+      },
+      "peerDependenciesMeta": {
+        "vite": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/vitest": {
+      "version": "4.0.18",
+      "resolved": "https://registry.npmjs.org/vitest/-/vitest-4.0.18.tgz",
+      "integrity": "sha512-hOQuK7h0FGKgBAas7v0mSAsnvrIgAvWmRFjmzpJ7SwFHH3g1k2u37JtYwOwmEKhK6ZO3v9ggDBBm0La1LCK4uQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@vitest/expect": "4.0.18",
+        "@vitest/mocker": "4.0.18",
+        "@vitest/pretty-format": "4.0.18",
+        "@vitest/runner": "4.0.18",
+        "@vitest/snapshot": "4.0.18",
+        "@vitest/spy": "4.0.18",
+        "@vitest/utils": "4.0.18",
+        "es-module-lexer": "^1.7.0",
+        "expect-type": "^1.2.2",
+        "magic-string": "^0.30.21",
+        "obug": "^2.1.1",
+        "pathe": "^2.0.3",
+        "picomatch": "^4.0.3",
+        "std-env": "^3.10.0",
+        "tinybench": "^2.9.0",
+        "tinyexec": "^1.0.2",
+        "tinyglobby": "^0.2.15",
+        "tinyrainbow": "^3.0.3",
+        "vite": "^6.0.0 || ^7.0.0",
+        "why-is-node-running": "^2.3.0"
+      },
+      "bin": {
+        "vitest": "vitest.mjs"
+      },
+      "engines": {
+        "node": "^20.0.0 || ^22.0.0 || >=24.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      },
+      "peerDependencies": {
+        "@edge-runtime/vm": "*",
+        "@opentelemetry/api": "^1.9.0",
+        "@types/node": "^20.0.0 || ^22.0.0 || >=24.0.0",
+        "@vitest/browser-playwright": "4.0.18",
+        "@vitest/browser-preview": "4.0.18",
+        "@vitest/browser-webdriverio": "4.0.18",
+        "@vitest/ui": "4.0.18",
+        "happy-dom": "*",
+        "jsdom": "*"
+      },
+      "peerDependenciesMeta": {
+        "@edge-runtime/vm": {
+          "optional": true
+        },
+        "@opentelemetry/api": {
+          "optional": true
+        },
+        "@types/node": {
+          "optional": true
+        },
+        "@vitest/browser-playwright": {
+          "optional": true
+        },
+        "@vitest/browser-preview": {
+          "optional": true
+        },
+        "@vitest/browser-webdriverio": {
+          "optional": true
+        },
+        "@vitest/ui": {
+          "optional": true
+        },
+        "happy-dom": {
+          "optional": true
+        },
+        "jsdom": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/w3c-keyname": {
+      "version": "2.2.8",
+      "resolved": "https://registry.npmjs.org/w3c-keyname/-/w3c-keyname-2.2.8.tgz",
+      "integrity": "sha512-dpojBhNsCNN7T82Tm7k26A6G9ML3NkhDsnw9n/eoxSRlVBB4CEtIQ/KTCLI2Fwf3ataSXRhYFkQi3SlnFwPvPQ==",
+      "license": "MIT"
+    },
+    "node_modules/wait-port": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/wait-port/-/wait-port-1.1.0.tgz",
+      "integrity": "sha512-3e04qkoN3LxTMLakdqeWth8nih8usyg+sf1Bgdf9wwUkp05iuK1eSY/QpLvscT/+F/gA89+LpUmmgBtesbqI2Q==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "chalk": "^4.1.2",
+        "commander": "^9.3.0",
+        "debug": "^4.3.4"
+      },
+      "bin": {
+        "wait-port": "bin/wait-port.js"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/wait-port/node_modules/ansi-styles": {
+      "version": "4.3.0",
+      "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz",
+      "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "color-convert": "^2.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/ansi-styles?sponsor=1"
+      }
+    },
+    "node_modules/wait-port/node_modules/chalk": {
+      "version": "4.1.2",
+      "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz",
+      "integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "ansi-styles": "^4.1.0",
+        "supports-color": "^7.1.0"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/chalk?sponsor=1"
+      }
+    },
+    "node_modules/wait-port/node_modules/commander": {
+      "version": "9.5.0",
+      "resolved": "https://registry.npmjs.org/commander/-/commander-9.5.0.tgz",
+      "integrity": "sha512-KRs7WVDKg86PWiuAqhDrAQnTXZKraVcCc6vFdL14qrZ/DcWwuRo7VoiYXalXO7S5GKpqYiVEwCbgFDfxNHKJBQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": "^12.20.0 || >=14"
+      }
+    },
+    "node_modules/wait-port/node_modules/supports-color": {
+      "version": "7.2.0",
+      "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz",
+      "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "has-flag": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/wcwidth": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/wcwidth/-/wcwidth-1.0.1.tgz",
+      "integrity": "sha512-XHPEwS0q6TaxcvG85+8EYkbiCux2XtWG2mkc47Ng2A77BQu9+DqIOJldST4HgPkuea7dvKSj5VgX3P1d4rW8Tg==",
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "defaults": "^1.0.3"
+      }
+    },
+    "node_modules/webdriver": {
+      "version": "9.24.0",
+      "resolved": "https://registry.npmjs.org/webdriver/-/webdriver-9.24.0.tgz",
+      "integrity": "sha512-2R31Ey83NzMsafkl4hdFq6GlIBvOODQMkueLjeRqYAITu3QCYiq9oqBdnWA6CdePuV4dbKlYsKRX0mwMiPclDA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/node": "^20.1.0",
+        "@types/ws": "^8.5.3",
+        "@wdio/config": "9.24.0",
+        "@wdio/logger": "9.18.0",
+        "@wdio/protocols": "9.24.0",
+        "@wdio/types": "9.24.0",
+        "@wdio/utils": "9.24.0",
+        "deepmerge-ts": "^7.0.3",
+        "https-proxy-agent": "^7.0.6",
+        "undici": "^6.21.3",
+        "ws": "^8.8.0"
+      },
+      "engines": {
+        "node": ">=18.20.0"
+      }
+    },
+    "node_modules/webdriver/node_modules/@types/node": {
+      "version": "20.19.37",
+      "resolved": "https://registry.npmjs.org/@types/node/-/node-20.19.37.tgz",
+      "integrity": "sha512-8kzdPJ3FsNsVIurqBs7oodNnCEVbni9yUEkaHbgptDACOPW04jimGagZ51E6+lXUwJjgnBw+hyko/lkFWCldqw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "undici-types": "~6.21.0"
+      }
+    },
+    "node_modules/webdriver/node_modules/undici-types": {
+      "version": "6.21.0",
+      "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-6.21.0.tgz",
+      "integrity": "sha512-iwDZqg0QAGrg9Rav5H4n0M64c3mkR59cJ6wQp+7C4nI0gsmExaedaYLNO44eT4AtBBwjbTiGPMlt2Md0T9H9JQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/webdriverio": {
+      "version": "9.24.0",
+      "resolved": "https://registry.npmjs.org/webdriverio/-/webdriverio-9.24.0.tgz",
+      "integrity": "sha512-LTJt6Z/iDM0ne/4ytd3BykoPv9CuJ+CAILOzlwFeMGn4Mj02i4Bk2Rg9o/jeJ89f52hnv4OPmNjD0e8nzWAy5g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/node": "^20.11.30",
+        "@types/sinonjs__fake-timers": "^8.1.5",
+        "@wdio/config": "9.24.0",
+        "@wdio/logger": "9.18.0",
+        "@wdio/protocols": "9.24.0",
+        "@wdio/repl": "9.16.2",
+        "@wdio/types": "9.24.0",
+        "@wdio/utils": "9.24.0",
+        "archiver": "^7.0.1",
+        "aria-query": "^5.3.0",
+        "cheerio": "^1.0.0-rc.12",
+        "css-shorthand-properties": "^1.1.1",
+        "css-value": "^0.0.1",
+        "grapheme-splitter": "^1.0.4",
+        "htmlfy": "^0.8.1",
+        "is-plain-obj": "^4.1.0",
+        "jszip": "^3.10.1",
+        "lodash.clonedeep": "^4.5.0",
+        "lodash.zip": "^4.2.0",
+        "query-selector-shadow-dom": "^1.0.1",
+        "resq": "^1.11.0",
+        "rgb2hex": "0.2.5",
+        "serialize-error": "^12.0.0",
+        "urlpattern-polyfill": "^10.0.0",
+        "webdriver": "9.24.0"
+      },
+      "engines": {
+        "node": ">=18.20.0"
+      },
+      "peerDependencies": {
+        "puppeteer-core": ">=22.x || <=24.x"
+      },
+      "peerDependenciesMeta": {
+        "puppeteer-core": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/webdriverio/node_modules/@types/node": {
+      "version": "20.19.37",
+      "resolved": "https://registry.npmjs.org/@types/node/-/node-20.19.37.tgz",
+      "integrity": "sha512-8kzdPJ3FsNsVIurqBs7oodNnCEVbni9yUEkaHbgptDACOPW04jimGagZ51E6+lXUwJjgnBw+hyko/lkFWCldqw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "undici-types": "~6.21.0"
+      }
+    },
+    "node_modules/webdriverio/node_modules/undici-types": {
+      "version": "6.21.0",
+      "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-6.21.0.tgz",
+      "integrity": "sha512-iwDZqg0QAGrg9Rav5H4n0M64c3mkR59cJ6wQp+7C4nI0gsmExaedaYLNO44eT4AtBBwjbTiGPMlt2Md0T9H9JQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/whatwg-encoding": {
+      "version": "3.1.1",
+      "resolved": "https://registry.npmjs.org/whatwg-encoding/-/whatwg-encoding-3.1.1.tgz",
+      "integrity": "sha512-6qN4hJdMwfYBtE3YBTTHhoeuUrDBPZmbQaxWAqSALV/MeEnR5z1xd8UKud2RAkFoPkmB+hli1TZSnyi84xz1vQ==",
+      "deprecated": "Use @exodus/bytes instead for a more spec-conformant and faster implementation",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "iconv-lite": "0.6.3"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/whatwg-encoding/node_modules/iconv-lite": {
+      "version": "0.6.3",
+      "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.6.3.tgz",
+      "integrity": "sha512-4fCk79wshMdzMp2rH06qWrJE4iolqLhCUH+OiuIgU++RB0+94NlDL81atO7GX55uUKueo0txHNtvEyI6D7WdMw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "safer-buffer": ">= 2.1.2 < 3.0.0"
+      },
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/whatwg-mimetype": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/whatwg-mimetype/-/whatwg-mimetype-4.0.0.tgz",
+      "integrity": "sha512-QaKxh0eNIi2mE9p2vEdzfagOKHCcj1pJ56EEHGQOVxp8r9/iszLUUV7v89x9O1p/T+NlTM5W7jW6+cz4Fq1YVg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/which": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/which/-/which-2.0.2.tgz",
+      "integrity": "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "isexe": "^2.0.0"
+      },
+      "bin": {
+        "node-which": "bin/node-which"
+      },
+      "engines": {
+        "node": ">= 8"
+      }
+    },
+    "node_modules/why-is-node-running": {
+      "version": "2.3.0",
+      "resolved": "https://registry.npmjs.org/why-is-node-running/-/why-is-node-running-2.3.0.tgz",
+      "integrity": "sha512-hUrmaWBdVDcxvYqnyh09zunKzROWjbZTiNy8dBEjkS7ehEDQibXJ7XvlmtbwuTclUiIyN+CyXQD4Vmko8fNm8w==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "siginfo": "^2.0.0",
+        "stackback": "0.0.2"
+      },
+      "bin": {
+        "why-is-node-running": "cli.js"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/workerpool": {
+      "version": "6.5.1",
+      "resolved": "https://registry.npmjs.org/workerpool/-/workerpool-6.5.1.tgz",
+      "integrity": "sha512-Fs4dNYcsdpYSAfVxhnl1L5zTksjvOJxtC5hzMNl+1t9B8hTJTdKDyZ5ju7ztgPy+ft9tBFXoOlDNiOT9WUXZlA==",
+      "dev": true,
+      "license": "Apache-2.0"
+    },
+    "node_modules/wrap-ansi": {
+      "version": "6.2.0",
+      "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-6.2.0.tgz",
+      "integrity": "sha512-r6lPcBGxZXlIcymEu7InxDMhdW0KDxpLgoFLcguasxCaJ/SOIZwINatK9KY/tf+ZrlywOKU0UDj3ATXUBfxJXA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "ansi-styles": "^4.0.0",
+        "string-width": "^4.1.0",
+        "strip-ansi": "^6.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/wrap-ansi-cjs": {
+      "name": "wrap-ansi",
+      "version": "7.0.0",
+      "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-7.0.0.tgz",
+      "integrity": "sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "ansi-styles": "^4.0.0",
+        "string-width": "^4.1.0",
+        "strip-ansi": "^6.0.0"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/wrap-ansi?sponsor=1"
+      }
+    },
+    "node_modules/wrap-ansi-cjs/node_modules/ansi-styles": {
+      "version": "4.3.0",
+      "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz",
+      "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "color-convert": "^2.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/ansi-styles?sponsor=1"
+      }
+    },
+    "node_modules/wrap-ansi-cjs/node_modules/emoji-regex": {
+      "version": "8.0.0",
+      "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz",
+      "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/wrap-ansi-cjs/node_modules/string-width": {
+      "version": "4.2.3",
+      "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz",
+      "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "emoji-regex": "^8.0.0",
+        "is-fullwidth-code-point": "^3.0.0",
+        "strip-ansi": "^6.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/wrap-ansi-cjs/node_modules/strip-ansi": {
+      "version": "6.0.1",
+      "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz",
+      "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "ansi-regex": "^5.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/wrap-ansi/node_modules/ansi-styles": {
+      "version": "4.3.0",
+      "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz",
+      "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "color-convert": "^2.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/ansi-styles?sponsor=1"
+      }
+    },
+    "node_modules/wrap-ansi/node_modules/emoji-regex": {
+      "version": "8.0.0",
+      "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz",
+      "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/wrap-ansi/node_modules/string-width": {
+      "version": "4.2.3",
+      "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz",
+      "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "emoji-regex": "^8.0.0",
+        "is-fullwidth-code-point": "^3.0.0",
+        "strip-ansi": "^6.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/wrap-ansi/node_modules/strip-ansi": {
+      "version": "6.0.1",
+      "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz",
+      "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "ansi-regex": "^5.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/wrappy": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz",
+      "integrity": "sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==",
+      "dev": true,
+      "license": "ISC"
+    },
+    "node_modules/ws": {
+      "version": "8.19.0",
+      "resolved": "https://registry.npmjs.org/ws/-/ws-8.19.0.tgz",
+      "integrity": "sha512-blAT2mjOEIi0ZzruJfIhb3nps74PRWTCz1IjglWEEpQl5XS/UNama6u2/rjFkDDouqr4L67ry+1aGIALViWjDg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=10.0.0"
+      },
+      "peerDependencies": {
+        "bufferutil": "^4.0.1",
+        "utf-8-validate": ">=5.0.2"
+      },
+      "peerDependenciesMeta": {
+        "bufferutil": {
+          "optional": true
+        },
+        "utf-8-validate": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/y18n": {
+      "version": "5.0.8",
+      "resolved": "https://registry.npmjs.org/y18n/-/y18n-5.0.8.tgz",
+      "integrity": "sha512-0pfFzegeDWJHJIAmTLRP2DwHjdF5s7jo9tuztdQxAhINCdvS+3nGINqPd00AphqJR/0LhANUS6/+7SCb98YOfA==",
+      "dev": true,
+      "license": "ISC",
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/yargs": {
+      "version": "17.7.2",
+      "resolved": "https://registry.npmjs.org/yargs/-/yargs-17.7.2.tgz",
+      "integrity": "sha512-7dSzzRQ++CKnNI/krKnYRV7JKKPUXMEh61soaHKg9mrWEhzFWhFnxPxGl+69cD1Ou63C13NUPCnmIcrvqCuM6w==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "cliui": "^8.0.1",
+        "escalade": "^3.1.1",
+        "get-caller-file": "^2.0.5",
+        "require-directory": "^2.1.1",
+        "string-width": "^4.2.3",
+        "y18n": "^5.0.5",
+        "yargs-parser": "^21.1.1"
+      },
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/yargs-parser": {
+      "version": "20.2.9",
+      "resolved": "https://registry.npmjs.org/yargs-parser/-/yargs-parser-20.2.9.tgz",
+      "integrity": "sha512-y11nGElTIV+CT3Zv9t7VKl+Q3hTQoT9a1Qzezhhl6Rp21gJ/IVTW7Z3y9EWXhuUBC2Shnf+DX0antecpAwSP8w==",
+      "dev": true,
+      "license": "ISC",
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/yargs-unparser": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/yargs-unparser/-/yargs-unparser-2.0.0.tgz",
+      "integrity": "sha512-7pRTIA9Qc1caZ0bZ6RYRGbHJthJWuakf+WmHK0rVeLkNrrGhfoabBNdue6kdINI6r4if7ocq9aD/n7xwKOdzOA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "camelcase": "^6.0.0",
+        "decamelize": "^4.0.0",
+        "flat": "^5.0.2",
+        "is-plain-obj": "^2.1.0"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/yargs-unparser/node_modules/decamelize": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/decamelize/-/decamelize-4.0.0.tgz",
+      "integrity": "sha512-9iE1PgSik9HeIIw2JO94IidnE3eBoQrFJ3w7sFuzSX4DpmZ3v5sZpUiV5Swcf6mQEF+Y0ru8Neo+p+nyh2J+hQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/yargs-unparser/node_modules/is-plain-obj": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/is-plain-obj/-/is-plain-obj-2.1.0.tgz",
+      "integrity": "sha512-YWnfyRwxL/+SsrWYfOpUtz5b3YD+nyfkHvjbcanzk8zgyO4ASD67uVMRt8k5bM4lLMDnXfriRhOpemw+NfT1eA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/yargs/node_modules/emoji-regex": {
+      "version": "8.0.0",
+      "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz",
+      "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/yargs/node_modules/string-width": {
+      "version": "4.2.3",
+      "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz",
+      "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "emoji-regex": "^8.0.0",
+        "is-fullwidth-code-point": "^3.0.0",
+        "strip-ansi": "^6.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/yargs/node_modules/strip-ansi": {
+      "version": "6.0.1",
+      "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz",
+      "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "ansi-regex": "^5.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/yargs/node_modules/yargs-parser": {
+      "version": "21.1.1",
+      "resolved": "https://registry.npmjs.org/yargs-parser/-/yargs-parser-21.1.1.tgz",
+      "integrity": "sha512-tVpsJW7DdjecAiFpbIB1e3qxIQsE6NoPc5/eTdrbbIC4h0LVsWhnoa3g+m2HclBIujHzsxZ4VJVA+GUuc2/LBw==",
+      "dev": true,
+      "license": "ISC",
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/yauzl": {
+      "version": "2.10.0",
+      "resolved": "https://registry.npmjs.org/yauzl/-/yauzl-2.10.0.tgz",
+      "integrity": "sha512-p4a9I6X6nu6IhoGmBqAcbJy1mlC4j27vEPZX9F4L4/vZT3Lyq1VkFHw/V/PUcB9Buo+DG3iHkT0x3Qya58zc3g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "buffer-crc32": "~0.2.3",
+        "fd-slicer": "~1.1.0"
+      }
+    },
+    "node_modules/yauzl/node_modules/buffer-crc32": {
+      "version": "0.2.13",
+      "resolved": "https://registry.npmjs.org/buffer-crc32/-/buffer-crc32-0.2.13.tgz",
+      "integrity": "sha512-VO9Ht/+p3SN7SKWqcrgEzjGbRSJYTx+Q1pTQC0wrWqHx0vpJraQ6GtHx8tvcg1rlK1byhU5gccxgOgj7B0TDkQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": "*"
+      }
+    },
+    "node_modules/yocto-queue": {
+      "version": "0.1.0",
+      "resolved": "https://registry.npmjs.org/yocto-queue/-/yocto-queue-0.1.0.tgz",
+      "integrity": "sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/yoctocolors": {
+      "version": "2.1.2",
+      "resolved": "https://registry.npmjs.org/yoctocolors/-/yoctocolors-2.1.2.tgz",
+      "integrity": "sha512-CzhO+pFNo8ajLM2d2IW/R93ipy99LWjtwblvC1RsoSUMZgyLbYFr221TnSNT7GjGdYui6P459mw9JH/g/zW2ug==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/yoctocolors-cjs": {
+      "version": "2.1.3",
+      "resolved": "https://registry.npmjs.org/yoctocolors-cjs/-/yoctocolors-cjs-2.1.3.tgz",
+      "integrity": "sha512-U/PBtDf35ff0D8X8D0jfdzHYEPFxAI7jJlxZXwCSez5M3190m+QobIfh+sWDWSHMCWWJN2AWamkegn6vr6YBTw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/zimmerframe": {
+      "version": "1.1.4",
+      "resolved": "https://registry.npmjs.org/zimmerframe/-/zimmerframe-1.1.4.tgz",
+      "integrity": "sha512-B58NGBEoc8Y9MWWCQGl/gq9xBCe4IiKM0a2x7GZdQKOW5Exr8S1W24J6OgM1njK8xCRGvAJIL/MxXHf6SkmQKQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/zip-stream": {
+      "version": "6.0.1",
+      "resolved": "https://registry.npmjs.org/zip-stream/-/zip-stream-6.0.1.tgz",
+      "integrity": "sha512-zK7YHHz4ZXpW89AHXUPbQVGKI7uvkd3hzusTdotCg1UxyaVtg0zFJSTfW/Dq5f7OBBVnq6cZIaC8Ti4hb6dtCA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "archiver-utils": "^5.0.0",
+        "compress-commons": "^6.0.2",
+        "readable-stream": "^4.0.0"
+      },
+      "engines": {
+        "node": ">= 14"
+      }
+    },
+    "node_modules/zwitch": {
+      "version": "2.0.4",
+      "resolved": "https://registry.npmjs.org/zwitch/-/zwitch-2.0.4.tgz",
+      "integrity": "sha512-bXE4cR/kVZhKZX/RjPEflHaKVhUVl85noU3v6b8apfQEc1x4A+zBxjZ4lN8LqGd6WZ3dl98pY4o717VFmoPp+A==",
+      "license": "MIT",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    }
+  }
+}
diff --git a/v2/package.json b/v2/package.json
new file mode 100644
index 0000000..8e14e16
--- /dev/null
+++ b/v2/package.json
@@ -0,0 +1,63 @@
+{
+  "name": "bterminal-v2",
+  "private": true,
+  "version": "0.1.0",
+  "type": "module",
+  "scripts": {
+    "dev": "vite",
+    "prebuild": "cp node_modules/pdfjs-dist/build/pdf.worker.min.mjs public/pdf.worker.min.mjs",
+    "build": "vite build",
+    "preview": "vite preview",
+    "check": "svelte-check --tsconfig ./tsconfig.app.json && tsc -p tsconfig.node.json",
+    "tauri": "cargo tauri",
+    "tauri:dev": "cargo tauri dev",
+    "tauri:build": "cargo tauri build",
+    "test": "vitest run",
+    "test:cargo": "cd src-tauri && cargo test",
+    "test:e2e": "wdio run tests/e2e/wdio.conf.js",
+    "test:all": "bash scripts/test-all.sh",
+    "test:all:e2e": "bash scripts/test-all.sh --e2e",
+    "build:sidecar": "esbuild sidecar/claude-runner.ts --bundle --platform=node --format=esm --outfile=sidecar/dist/claude-runner.mjs && esbuild sidecar/codex-runner.ts --bundle --platform=node --format=esm --outfile=sidecar/dist/codex-runner.mjs && esbuild sidecar/ollama-runner.ts --bundle --platform=node --format=esm --outfile=sidecar/dist/ollama-runner.mjs"
+  },
+  "devDependencies": {
+    "@sveltejs/vite-plugin-svelte": "^6.2.1",
+    "@tsconfig/svelte": "^5.0.6",
+    "@types/node": "^24.10.1",
+    "@wdio/cli": "^9.24.0",
+    "@wdio/local-runner": "^9.24.0",
+    "@wdio/mocha-framework": "^9.24.0",
+    "@wdio/spec-reporter": "^9.24.0",
+    "svelte": "^5.45.2",
+    "svelte-check": "^4.3.4",
+    "typescript": "~5.9.3",
+    "vite": "^7.3.1",
+    "vitest": "^4.0.18"
+  },
+  "dependencies": {
+    "@anthropic-ai/claude-agent-sdk": "^0.2.70",
+    "@codemirror/lang-cpp": "^6.0.3",
+    "@codemirror/lang-css": "^6.3.1",
+    "@codemirror/lang-go": "^6.0.1",
+    "@codemirror/lang-html": "^6.4.11",
+    "@codemirror/lang-java": "^6.0.2",
+    "@codemirror/lang-javascript": "^6.2.5",
+    "@codemirror/lang-json": "^6.0.2",
+    "@codemirror/lang-markdown": "^6.5.0",
+    "@codemirror/lang-php": "^6.0.2",
+    "@codemirror/lang-python": "^6.2.1",
+    "@codemirror/lang-rust": "^6.0.2",
+    "@codemirror/lang-sql": "^6.10.0",
+    "@codemirror/lang-xml": "^6.1.0",
+    "@codemirror/lang-yaml": "^6.1.2",
+    "@tauri-apps/api": "^2.10.1",
+    "@tauri-apps/plugin-dialog": "^2.6.0",
+    "@tauri-apps/plugin-updater": "^2.10.0",
+    "@xterm/addon-canvas": "^0.7.0",
+    "@xterm/addon-fit": "^0.11.0",
+    "@xterm/xterm": "^6.0.0",
+    "codemirror": "^6.0.2",
+    "marked": "^17.0.4",
+    "pdfjs-dist": "^5.5.207",
+    "shiki": "^4.0.1"
+  }
+}
diff --git a/v2/scripts/test-all.sh b/v2/scripts/test-all.sh
new file mode 100755
index 0000000..8953961
--- /dev/null
+++ b/v2/scripts/test-all.sh
@@ -0,0 +1,114 @@
+#!/usr/bin/env bash
+# BTerminal — unified test runner
+# Usage: ./scripts/test-all.sh [--e2e] [--verbose]
+#
+# Runs vitest (frontend) + cargo test (backend) by default.
+# Pass --e2e to also run WebDriverIO E2E tests (requires built binary).
+
+set -euo pipefail
+
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[0;33m'
+CYAN='\033[0;36m'
+BOLD='\033[1m'
+RESET='\033[0m'
+
+V2_DIR="$(cd "$(dirname "$0")/.." && pwd)"
+RUN_E2E=false
+VERBOSE=false
+FAILED=()
+
+for arg in "$@"; do
+  case "$arg" in
+    --e2e) RUN_E2E=true ;;
+    --verbose|-v) VERBOSE=true ;;
+    --help|-h)
+      echo "Usage: $0 [--e2e] [--verbose]"
+      echo "  --e2e      Also run WebDriverIO E2E tests (requires built binary)"
+      echo "  --verbose  Show full test output instead of summary"
+      exit 0
+      ;;
+    *) echo "Unknown option: $arg"; exit 1 ;;
+  esac
+done
+
+step() {
+  echo -e "\n${CYAN}${BOLD}━━━ $1 ━━━${RESET}"
+}
+
+pass() {
+  echo -e "${GREEN}✓ $1${RESET}"
+}
+
+fail() {
+  echo -e "${RED}✗ $1${RESET}"
+  FAILED+=("$1")
+}
+
+# --- Vitest (frontend) ---
+step "Vitest (frontend unit tests)"
+if $VERBOSE; then
+  (cd "$V2_DIR" && npm run test) && pass "Vitest" || fail "Vitest"
+else
+  if OUTPUT=$(cd "$V2_DIR" && npm run test 2>&1); then
+    SUMMARY=$(echo "$OUTPUT" | grep -E "Tests|Test Files" | tail -2)
+    echo "$SUMMARY"
+    pass "Vitest"
+  else
+    echo "$OUTPUT" | tail -20
+    fail "Vitest"
+  fi
+fi
+
+# --- Cargo test (backend) ---
+step "Cargo test (Rust backend)"
+if $VERBOSE; then
+  (cd "$V2_DIR/src-tauri" && cargo test) && pass "Cargo test" || fail "Cargo test"
+else
+  if OUTPUT=$(cd "$V2_DIR/src-tauri" && cargo test 2>&1); then
+    SUMMARY=$(echo "$OUTPUT" | grep -E "test result:|running" | head -5)
+    echo "$SUMMARY"
+    pass "Cargo test"
+  else
+    echo "$OUTPUT" | tail -20
+    fail "Cargo test"
+  fi
+fi
+
+# --- E2E (WebDriverIO) ---
+if $RUN_E2E; then
+  step "E2E tests (WebDriverIO + tauri-driver)"
+
+  # Check for built binary
+  BINARY=$(find "$V2_DIR/src-tauri/target" -name "bterminal*" -type f -executable -path "*/release/*" 2>/dev/null | head -1)
+  if [ -z "$BINARY" ]; then
+    echo -e "${YELLOW}⚠ No release binary found. Run 'npm run tauri build' first.${RESET}"
+    fail "E2E (no binary)"
+  else
+    if $VERBOSE; then
+      (cd "$V2_DIR" && npm run test:e2e) && pass "E2E" || fail "E2E"
+    else
+      if OUTPUT=$(cd "$V2_DIR" && npm run test:e2e 2>&1); then
+        SUMMARY=$(echo "$OUTPUT" | grep -E "passing|failing|skipped" | tail -3)
+        echo "$SUMMARY"
+        pass "E2E"
+      else
+        echo "$OUTPUT" | tail -30
+        fail "E2E"
+      fi
+    fi
+  fi
+else
+  echo -e "\n${YELLOW}Skipping E2E tests (pass --e2e to include)${RESET}"
+fi
+
+# --- Summary ---
+echo -e "\n${BOLD}━━━ Summary ━━━${RESET}"
+if [ ${#FAILED[@]} -eq 0 ]; then
+  echo -e "${GREEN}${BOLD}All test suites passed.${RESET}"
+  exit 0
+else
+  echo -e "${RED}${BOLD}Failed suites: ${FAILED[*]}${RESET}"
+  exit 1
+fi
diff --git a/v2/sidecar/agent-runner-deno.ts b/v2/sidecar/agent-runner-deno.ts
new file mode 100644
index 0000000..9617825
--- /dev/null
+++ b/v2/sidecar/agent-runner-deno.ts
@@ -0,0 +1,209 @@
+// Agent Runner — Deno sidecar entry point
+// Drop-in replacement for agent-runner.ts using Deno APIs
+// Uses @anthropic-ai/claude-agent-sdk via npm: specifier
+// Run: deno run --allow-run --allow-env --allow-read --allow-write --allow-net agent-runner-deno.ts
+
+import { TextLineStream } from "https://deno.land/std@0.224.0/streams/text_line_stream.ts";
+import { query } from "npm:@anthropic-ai/claude-agent-sdk";
+
+const encoder = new TextEncoder();
+
+// Active sessions with abort controllers
+const sessions = new Map<string, AbortController>();
+
+function send(msg: Record<string, unknown>) {
+  Deno.stdout.writeSync(encoder.encode(JSON.stringify(msg) + "\n"));
+}
+
+function log(message: string) {
+  Deno.stderr.writeSync(encoder.encode(`[sidecar] ${message}\n`));
+}
+
+interface QueryMessage {
+  type: "query";
+  sessionId: string;
+  prompt: string;
+  cwd?: string;
+  maxTurns?: number;
+  maxBudgetUsd?: number;
+  resumeSessionId?: string;
+  permissionMode?: string;
+  settingSources?: string[];
+  systemPrompt?: string;
+  model?: string;
+  claudeConfigDir?: string;
+  additionalDirectories?: string[];
+}
+
+interface StopMessage {
+  type: "stop";
+  sessionId: string;
+}
+
+function handleMessage(msg: Record<string, unknown>) {
+  switch (msg.type) {
+    case "ping":
+      send({ type: "pong" });
+      break;
+    case "query":
+      handleQuery(msg as unknown as QueryMessage);
+      break;
+    case "stop":
+      handleStop(msg as unknown as StopMessage);
+      break;
+    default:
+      send({ type: "error", message: `Unknown message type: ${msg.type}` });
+  }
+}
+
+async function handleQuery(msg: QueryMessage) {
+  const { sessionId, prompt, cwd, maxTurns, maxBudgetUsd, resumeSessionId, permissionMode, settingSources, systemPrompt, model, claudeConfigDir, additionalDirectories } = msg;
+
+  if (sessions.has(sessionId)) {
+    send({ type: "error", sessionId, message: "Session already running" });
+    return;
+  }
+
+  log(`Starting agent session ${sessionId} via SDK`);
+
+  const controller = new AbortController();
+
+  // Strip CLAUDE* env vars to prevent nesting detection
+  const cleanEnv: Record<string, string | undefined> = {};
+  for (const [key, value] of Object.entries(Deno.env.toObject())) {
+    if (!key.startsWith("CLAUDE")) {
+      cleanEnv[key] = value;
+    }
+  }
+  // Override CLAUDE_CONFIG_DIR for multi-account support
+  if (claudeConfigDir) {
+    cleanEnv["CLAUDE_CONFIG_DIR"] = claudeConfigDir;
+  }
+
+  if (!claudePath) {
+    send({ type: "agent_error", sessionId, message: "Claude CLI not found. Install Claude Code first." });
+    return;
+  }
+
+  try {
+    const q = query({
+      prompt,
+      options: {
+        pathToClaudeCodeExecutable: claudePath,
+        abortController: controller,
+        cwd: cwd || Deno.cwd(),
+        env: cleanEnv,
+        maxTurns: maxTurns ?? undefined,
+        maxBudgetUsd: maxBudgetUsd ?? undefined,
+        resume: resumeSessionId ?? undefined,
+        allowedTools: [
+          "Bash", "Read", "Write", "Edit", "Glob", "Grep",
+          "WebSearch", "WebFetch", "TodoWrite", "NotebookEdit",
+        ],
+        permissionMode: (permissionMode ?? "bypassPermissions") as "bypassPermissions" | "default",
+        allowDangerouslySkipPermissions: (permissionMode ?? "bypassPermissions") === "bypassPermissions",
+        settingSources: settingSources ?? ["user", "project"],
+        systemPrompt: systemPrompt
+          ? systemPrompt
+          : { type: "preset" as const, preset: "claude_code" as const },
+        model: model ?? undefined,
+        additionalDirectories: additionalDirectories ?? undefined,
+      },
+    });
+
+    sessions.set(sessionId, controller);
+    send({ type: "agent_started", sessionId });
+
+    for await (const message of q) {
+      const sdkMsg = message as Record<string, unknown>;
+      send({
+        type: "agent_event",
+        sessionId,
+        event: sdkMsg,
+      });
+    }
+
+    sessions.delete(sessionId);
+    send({
+      type: "agent_stopped",
+      sessionId,
+      exitCode: 0,
+      signal: null,
+    });
+  } catch (err: unknown) {
+    sessions.delete(sessionId);
+    const errMsg = err instanceof Error ? err.message : String(err);
+
+    if (errMsg.includes("aborted") || errMsg.includes("AbortError")) {
+      log(`Agent session ${sessionId} aborted`);
+      send({
+        type: "agent_stopped",
+        sessionId,
+        exitCode: null,
+        signal: "SIGTERM",
+      });
+    } else {
+      log(`Agent session ${sessionId} error: ${errMsg}`);
+      send({
+        type: "agent_error",
+        sessionId,
+        message: errMsg,
+      });
+    }
+  }
+}
+
+function handleStop(msg: StopMessage) {
+  const { sessionId } = msg;
+  const controller = sessions.get(sessionId);
+  if (!controller) {
+    send({ type: "error", sessionId, message: "Session not found" });
+    return;
+  }
+
+  log(`Stopping agent session ${sessionId}`);
+  controller.abort();
+}
+
+function findClaudeCli(): string | undefined {
+  const home = Deno.env.get("HOME") ?? Deno.env.get("USERPROFILE") ?? "";
+  const candidates = [
+    `${home}/.local/bin/claude`,
+    `${home}/.claude/local/claude`,
+    "/usr/local/bin/claude",
+    "/usr/bin/claude",
+  ];
+  for (const p of candidates) {
+    try { Deno.statSync(p); return p; } catch { /* not found */ }
+  }
+  try {
+    const proc = new Deno.Command("which", { args: ["claude"], stdout: "piped", stderr: "null" });
+    const out = new TextDecoder().decode(proc.outputSync().stdout).trim();
+    if (out) return out.split("\n")[0];
+  } catch { /* not found */ }
+  return undefined;
+}
+
+const claudePath = findClaudeCli();
+if (claudePath) {
+  log(`Found Claude CLI at ${claudePath}`);
+} else {
+  log("WARNING: Claude CLI not found — agent sessions will fail");
+}
+
+// Main: read NDJSON from stdin
+log("Sidecar started (Deno)");
+send({ type: "ready" });
+
+const lines = Deno.stdin.readable
+  .pipeThrough(new TextDecoderStream())
+  .pipeThrough(new TextLineStream());
+
+for await (const line of lines) {
+  try {
+    const msg = JSON.parse(line);
+    handleMessage(msg);
+  } catch {
+    log(`Invalid JSON: ${line}`);
+  }
+}
diff --git a/v2/sidecar/claude-runner.ts b/v2/sidecar/claude-runner.ts
new file mode 100644
index 0000000..6fa6a30
--- /dev/null
+++ b/v2/sidecar/claude-runner.ts
@@ -0,0 +1,224 @@
+// Claude Runner — Node.js sidecar entry point for Claude Code provider
+// Spawned by Rust SidecarManager, communicates via stdio NDJSON
+// Uses @anthropic-ai/claude-agent-sdk for Claude session management
+
+import { stdin, stdout, stderr } from 'process';
+import { createInterface } from 'readline';
+import { execSync } from 'child_process';
+import { existsSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+import { query, type Query } from '@anthropic-ai/claude-agent-sdk';
+
+const rl = createInterface({ input: stdin });
+
+// Active agent sessions keyed by session ID
+const sessions = new Map<string, { query: Query; controller: AbortController }>();
+
+function send(msg: Record<string, unknown>) {
+  stdout.write(JSON.stringify(msg) + '\n');
+}
+
+function log(message: string) {
+  stderr.write(`[sidecar] ${message}\n`);
+}
+
+rl.on('line', (line: string) => {
+  try {
+    const msg = JSON.parse(line);
+    handleMessage(msg).catch((err: unknown) => {
+      log(`Unhandled error in message handler: ${err}`);
+    });
+  } catch {
+    log(`Invalid JSON: ${line}`);
+  }
+});
+
+interface QueryMessage {
+  type: 'query';
+  sessionId: string;
+  prompt: string;
+  cwd?: string;
+  maxTurns?: number;
+  maxBudgetUsd?: number;
+  resumeSessionId?: string;
+  permissionMode?: string;
+  settingSources?: string[];
+  systemPrompt?: string;
+  model?: string;
+  claudeConfigDir?: string;
+  additionalDirectories?: string[];
+  worktreeName?: string;
+  extraEnv?: Record<string, string>;
+}
+
+interface StopMessage {
+  type: 'stop';
+  sessionId: string;
+}
+
+async function handleMessage(msg: Record<string, unknown>) {
+  switch (msg.type) {
+    case 'ping':
+      send({ type: 'pong' });
+      break;
+    case 'query':
+      await handleQuery(msg as unknown as QueryMessage);
+      break;
+    case 'stop':
+      handleStop(msg as unknown as StopMessage);
+      break;
+    default:
+      send({ type: 'error', message: `Unknown message type: ${msg.type}` });
+  }
+}
+
+async function handleQuery(msg: QueryMessage) {
+  const { sessionId, prompt, cwd, maxTurns, maxBudgetUsd, resumeSessionId, permissionMode, settingSources, systemPrompt, model, claudeConfigDir, additionalDirectories, worktreeName, extraEnv } = msg;
+
+  if (sessions.has(sessionId)) {
+    send({ type: 'error', sessionId, message: 'Session already running' });
+    return;
+  }
+
+  log(`Starting agent session ${sessionId} via SDK`);
+
+  const controller = new AbortController();
+
+  // Strip CLAUDE* and ANTHROPIC_* env vars to prevent nesting detection by the spawned CLI.
+  // Whitelist CLAUDE_CODE_EXPERIMENTAL_* so feature flags (e.g. agent teams) pass through.
+  const cleanEnv: Record<string, string | undefined> = {};
+  for (const [key, value] of Object.entries(process.env)) {
+    if (key.startsWith('CLAUDE_CODE_EXPERIMENTAL_')) {
+      cleanEnv[key] = value;
+    } else if (!key.startsWith('CLAUDE') && !key.startsWith('ANTHROPIC_')) {
+      cleanEnv[key] = value;
+    }
+  }
+  // Override CLAUDE_CONFIG_DIR for multi-account support
+  if (claudeConfigDir) {
+    cleanEnv['CLAUDE_CONFIG_DIR'] = claudeConfigDir;
+  }
+  // Inject extra environment variables (e.g. BTMSG_AGENT_ID for agent communication)
+  if (extraEnv) {
+    for (const [key, value] of Object.entries(extraEnv)) {
+      cleanEnv[key] = value;
+    }
+  }
+
+  try {
+    if (!claudePath) {
+      send({ type: 'agent_error', sessionId, message: 'Claude CLI not found. Install Claude Code first.' });
+      return;
+    }
+
+    const q = query({
+      prompt,
+      options: {
+        pathToClaudeCodeExecutable: claudePath,
+        abortController: controller,
+        cwd: cwd || process.cwd(),
+        env: cleanEnv,
+        maxTurns: maxTurns ?? undefined,
+        maxBudgetUsd: maxBudgetUsd ?? undefined,
+        resume: resumeSessionId ?? undefined,
+        allowedTools: [
+          'Bash', 'Read', 'Write', 'Edit', 'Glob', 'Grep',
+          'WebSearch', 'WebFetch', 'TodoWrite', 'NotebookEdit',
+        ],
+        permissionMode: (permissionMode ?? 'bypassPermissions') as 'bypassPermissions' | 'default',
+        allowDangerouslySkipPermissions: (permissionMode ?? 'bypassPermissions') === 'bypassPermissions',
+        settingSources: settingSources ?? ['user', 'project'],
+        systemPrompt: systemPrompt
+          ? systemPrompt
+          : { type: 'preset' as const, preset: 'claude_code' as const },
+        model: model ?? undefined,
+        additionalDirectories: additionalDirectories ?? undefined,
+        extraArgs: worktreeName ? { worktree: worktreeName } : undefined,
+      },
+    });
+
+    sessions.set(sessionId, { query: q, controller });
+    send({ type: 'agent_started', sessionId });
+
+    for await (const message of q) {
+      // Forward SDK messages as-is — they use the same format as CLI stream-json
+      const sdkMsg = message as Record<string, unknown>;
+      send({
+        type: 'agent_event',
+        sessionId,
+        event: sdkMsg,
+      });
+    }
+
+    // Session completed normally
+    sessions.delete(sessionId);
+    send({
+      type: 'agent_stopped',
+      sessionId,
+      exitCode: 0,
+      signal: null,
+    });
+  } catch (err: unknown) {
+    sessions.delete(sessionId);
+    const errMsg = err instanceof Error ? err.message : String(err);
+
+    if (controller.signal.aborted) {
+      log(`Agent session ${sessionId} aborted`);
+      send({
+        type: 'agent_stopped',
+        sessionId,
+        exitCode: null,
+        signal: 'SIGTERM',
+      });
+    } else {
+      log(`Agent session ${sessionId} error: ${errMsg}`);
+      send({
+        type: 'agent_error',
+        sessionId,
+        message: errMsg,
+      });
+    }
+  }
+}
+
+function handleStop(msg: StopMessage) {
+  const { sessionId } = msg;
+  const session = sessions.get(sessionId);
+  if (!session) {
+    send({ type: 'error', sessionId, message: 'Session not found' });
+    return;
+  }
+
+  log(`Stopping agent session ${sessionId}`);
+  session.controller.abort();
+}
+
+function findClaudeCli(): string | undefined {
+  // Check common locations
+  const candidates = [
+    join(homedir(), '.local', 'bin', 'claude'),
+    join(homedir(), '.claude', 'local', 'claude'),
+    '/usr/local/bin/claude',
+    '/usr/bin/claude',
+  ];
+  for (const p of candidates) {
+    if (existsSync(p)) return p;
+  }
+  // Fall back to which/where
+  try {
+    return execSync('which claude 2>/dev/null || where claude 2>nul', { encoding: 'utf-8' }).trim().split('\n')[0];
+  } catch {
+    return undefined;
+  }
+}
+
+const claudePath = findClaudeCli();
+if (claudePath) {
+  log(`Found Claude CLI at ${claudePath}`);
+} else {
+  log('WARNING: Claude CLI not found — agent sessions will fail');
+}
+
+log('Sidecar started');
+send({ type: 'ready' });
diff --git a/v2/sidecar/codex-runner.ts b/v2/sidecar/codex-runner.ts
new file mode 100644
index 0000000..f2b149e
--- /dev/null
+++ b/v2/sidecar/codex-runner.ts
@@ -0,0 +1,229 @@
+// Codex Runner — Node.js sidecar entry point for OpenAI Codex provider
+// Spawned by Rust SidecarManager, communicates via stdio NDJSON
+// Uses @openai/codex-sdk for Codex session management
+
+import { stdin, stdout, stderr } from 'process';
+import { createInterface } from 'readline';
+import { execSync } from 'child_process';
+import { existsSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+
+const rl = createInterface({ input: stdin });
+
+const sessions = new Map<string, { controller: AbortController }>();
+
+function send(msg: Record<string, unknown>) {
+  stdout.write(JSON.stringify(msg) + '\n');
+}
+
+function log(message: string) {
+  stderr.write(`[codex-sidecar] ${message}\n`);
+}
+
+rl.on('line', (line: string) => {
+  try {
+    const msg = JSON.parse(line);
+    handleMessage(msg).catch((err: unknown) => {
+      log(`Unhandled error in message handler: ${err}`);
+    });
+  } catch {
+    log(`Invalid JSON: ${line}`);
+  }
+});
+
+interface QueryMessage {
+  type: 'query';
+  sessionId: string;
+  prompt: string;
+  cwd?: string;
+  maxTurns?: number;
+  resumeSessionId?: string;
+  permissionMode?: string;
+  systemPrompt?: string;
+  model?: string;
+  providerConfig?: Record<string, unknown>;
+  extraEnv?: Record<string, string>;
+}
+
+interface StopMessage {
+  type: 'stop';
+  sessionId: string;
+}
+
+async function handleMessage(msg: Record<string, unknown>) {
+  switch (msg.type) {
+    case 'ping':
+      send({ type: 'pong' });
+      break;
+    case 'query':
+      await handleQuery(msg as unknown as QueryMessage);
+      break;
+    case 'stop':
+      handleStop(msg as unknown as StopMessage);
+      break;
+    default:
+      send({ type: 'error', message: `Unknown message type: ${msg.type}` });
+  }
+}
+
+async function handleQuery(msg: QueryMessage) {
+  const { sessionId, prompt, cwd, maxTurns, resumeSessionId, permissionMode, model, providerConfig, extraEnv } = msg;
+
+  if (sessions.has(sessionId)) {
+    send({ type: 'error', sessionId, message: 'Session already running' });
+    return;
+  }
+
+  log(`Starting Codex session ${sessionId}`);
+
+  const controller = new AbortController();
+
+  // Strip CODEX*/OPENAI* env vars to prevent nesting issues
+  const cleanEnv: Record<string, string | undefined> = {};
+  for (const [key, value] of Object.entries(process.env)) {
+    if (!key.startsWith('CODEX') && !key.startsWith('OPENAI')) {
+      cleanEnv[key] = value;
+    }
+  }
+  // Re-inject the API key
+  const apiKey = process.env.CODEX_API_KEY || process.env.OPENAI_API_KEY;
+  if (apiKey) {
+    cleanEnv['CODEX_API_KEY'] = apiKey;
+  }
+  // Inject extra environment variables (e.g. BTMSG_AGENT_ID for agent communication)
+  if (extraEnv) {
+    for (const [key, value] of Object.entries(extraEnv)) {
+      cleanEnv[key] = value;
+    }
+  }
+
+  // Dynamically import SDK — fails gracefully if not installed
+  let Codex: any;
+  try {
+    const sdk = await import('@openai/codex-sdk');
+    Codex = sdk.Codex ?? sdk.default;
+  } catch {
+    send({ type: 'agent_error', sessionId, message: 'Codex SDK not installed. Run: npm install @openai/codex-sdk' });
+    return;
+  }
+
+  if (!apiKey) {
+    send({ type: 'agent_error', sessionId, message: 'No API key. Set CODEX_API_KEY or OPENAI_API_KEY.' });
+    return;
+  }
+
+  try {
+    // Map permission mode to Codex sandbox/approval settings
+    const sandbox = mapSandboxMode(providerConfig?.sandbox as string | undefined, permissionMode);
+    const approvalPolicy = permissionMode === 'bypassPermissions' ? 'never' : 'on-request';
+
+    const codex = new Codex({
+      env: cleanEnv as Record<string, string>,
+      config: {
+        model: model ?? 'gpt-5.4',
+        approval_policy: approvalPolicy,
+        sandbox: sandbox,
+      },
+    });
+
+    const threadOpts: Record<string, unknown> = {
+      workingDirectory: cwd || process.cwd(),
+    };
+
+    const thread = resumeSessionId
+      ? codex.resumeThread(resumeSessionId)
+      : codex.startThread(threadOpts);
+
+    sessions.set(sessionId, { controller });
+    send({ type: 'agent_started', sessionId });
+
+    const streamResult = await thread.runStreamed(prompt);
+
+    for await (const event of streamResult.events) {
+      if (controller.signal.aborted) break;
+
+      // Forward raw Codex events — the message adapter parses them
+      send({
+        type: 'agent_event',
+        sessionId,
+        event: event as Record<string, unknown>,
+      });
+    }
+
+    sessions.delete(sessionId);
+    send({
+      type: 'agent_stopped',
+      sessionId,
+      exitCode: 0,
+      signal: null,
+    });
+  } catch (err: unknown) {
+    sessions.delete(sessionId);
+    const errMsg = err instanceof Error ? err.message : String(err);
+
+    if (controller.signal.aborted) {
+      log(`Codex session ${sessionId} aborted`);
+      send({
+        type: 'agent_stopped',
+        sessionId,
+        exitCode: null,
+        signal: 'SIGTERM',
+      });
+    } else {
+      log(`Codex session ${sessionId} error: ${errMsg}`);
+      send({
+        type: 'agent_error',
+        sessionId,
+        message: errMsg,
+      });
+    }
+  }
+}
+
+function handleStop(msg: StopMessage) {
+  const { sessionId } = msg;
+  const session = sessions.get(sessionId);
+  if (!session) {
+    send({ type: 'error', sessionId, message: 'Session not found' });
+    return;
+  }
+
+  log(`Stopping Codex session ${sessionId}`);
+  session.controller.abort();
+}
+
+function mapSandboxMode(
+  configSandbox: string | undefined,
+  permissionMode: string | undefined,
+): string {
+  if (configSandbox) return configSandbox;
+  if (permissionMode === 'bypassPermissions') return 'danger-full-access';
+  return 'workspace-write';
+}
+
+function findCodexCli(): string | undefined {
+  const candidates = [
+    join(homedir(), '.local', 'bin', 'codex'),
+    '/usr/local/bin/codex',
+    '/usr/bin/codex',
+  ];
+  for (const p of candidates) {
+    if (existsSync(p)) return p;
+  }
+  try {
+    return execSync('which codex 2>/dev/null || where codex 2>nul', { encoding: 'utf-8' }).trim().split('\n')[0];
+  } catch {
+    return undefined;
+  }
+}
+
+const codexPath = findCodexCli();
+if (codexPath) {
+  log(`Found Codex CLI at ${codexPath}`);
+} else {
+  log('Codex CLI not found — will use SDK if available');
+}
+
+log('Codex sidecar started');
+send({ type: 'ready' });
diff --git a/v2/sidecar/ollama-runner.ts b/v2/sidecar/ollama-runner.ts
new file mode 100644
index 0000000..8f3a9fb
--- /dev/null
+++ b/v2/sidecar/ollama-runner.ts
@@ -0,0 +1,269 @@
+// Ollama Runner — Node.js sidecar entry point for local Ollama provider
+// Spawned by Rust SidecarManager, communicates via stdio NDJSON
+// Uses direct HTTP to Ollama REST API (no external dependencies)
+
+import { stdin, stdout, stderr } from 'process';
+import { createInterface } from 'readline';
+
+const rl = createInterface({ input: stdin });
+
+const sessions = new Map<string, { controller: AbortController }>();
+
+function send(msg: Record<string, unknown>) {
+  stdout.write(JSON.stringify(msg) + '\n');
+}
+
+function log(message: string) {
+  stderr.write(`[ollama-sidecar] ${message}\n`);
+}
+
+rl.on('line', (line: string) => {
+  try {
+    const msg = JSON.parse(line);
+    handleMessage(msg).catch((err: unknown) => {
+      log(`Unhandled error in message handler: ${err}`);
+    });
+  } catch {
+    log(`Invalid JSON: ${line}`);
+  }
+});
+
+interface QueryMessage {
+  type: 'query';
+  sessionId: string;
+  prompt: string;
+  cwd?: string;
+  model?: string;
+  systemPrompt?: string;
+  providerConfig?: Record<string, unknown>;
+}
+
+interface StopMessage {
+  type: 'stop';
+  sessionId: string;
+}
+
+async function handleMessage(msg: Record<string, unknown>) {
+  switch (msg.type) {
+    case 'ping':
+      send({ type: 'pong' });
+      break;
+    case 'query':
+      await handleQuery(msg as unknown as QueryMessage);
+      break;
+    case 'stop':
+      handleStop(msg as unknown as StopMessage);
+      break;
+    default:
+      send({ type: 'error', message: `Unknown message type: ${msg.type}` });
+  }
+}
+
+async function handleQuery(msg: QueryMessage) {
+  const { sessionId, prompt, cwd, model, systemPrompt, providerConfig } = msg;
+
+  if (sessions.has(sessionId)) {
+    send({ type: 'error', sessionId, message: 'Session already running' });
+    return;
+  }
+
+  const ollamaHost = (providerConfig?.host as string) || process.env.OLLAMA_HOST || 'http://127.0.0.1:11434';
+  const ollamaModel = model || 'qwen3:8b';
+  const numCtx = (providerConfig?.num_ctx as number) || 32768;
+  const think = (providerConfig?.think as boolean) ?? false;
+
+  log(`Starting Ollama session ${sessionId} with model ${ollamaModel}`);
+
+  // Health check
+  try {
+    const healthRes = await fetch(`${ollamaHost}/api/version`);
+    if (!healthRes.ok) {
+      send({ type: 'agent_error', sessionId, message: `Ollama not reachable at ${ollamaHost} (HTTP ${healthRes.status})` });
+      return;
+    }
+  } catch (err: unknown) {
+    const errMsg = err instanceof Error ? err.message : String(err);
+    send({ type: 'agent_error', sessionId, message: `Cannot connect to Ollama at ${ollamaHost}: ${errMsg}` });
+    return;
+  }
+
+  const controller = new AbortController();
+  sessions.set(sessionId, { controller });
+  send({ type: 'agent_started', sessionId });
+
+  // Emit init event
+  send({
+    type: 'agent_event',
+    sessionId,
+    event: {
+      type: 'system',
+      subtype: 'init',
+      session_id: sessionId,
+      model: ollamaModel,
+      cwd: cwd || process.cwd(),
+    },
+  });
+
+  // Build messages array
+  const messages: Array<{ role: string; content: string }> = [];
+  if (systemPrompt && typeof systemPrompt === 'string') {
+    messages.push({ role: 'system', content: systemPrompt });
+  }
+  messages.push({ role: 'user', content: prompt });
+
+  try {
+    const res = await fetch(`${ollamaHost}/api/chat`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        model: ollamaModel,
+        messages,
+        stream: true,
+        options: { num_ctx: numCtx },
+        think,
+      }),
+      signal: controller.signal,
+    });
+
+    if (!res.ok) {
+      const errBody = await res.text();
+      let errMsg: string;
+      try {
+        const parsed = JSON.parse(errBody);
+        errMsg = parsed.error || errBody;
+      } catch {
+        errMsg = errBody;
+      }
+      send({ type: 'agent_error', sessionId, message: `Ollama error (${res.status}): ${errMsg}` });
+      sessions.delete(sessionId);
+      return;
+    }
+
+    if (!res.body) {
+      send({ type: 'agent_error', sessionId, message: 'No response body from Ollama' });
+      sessions.delete(sessionId);
+      return;
+    }
+
+    // Parse NDJSON stream
+    const reader = res.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = '';
+
+    while (true) {
+      if (controller.signal.aborted) break;
+
+      const { done, value } = await reader.read();
+      if (done) break;
+
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split('\n');
+      buffer = lines.pop() || '';
+
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed) continue;
+
+        try {
+          const chunk = JSON.parse(trimmed) as Record<string, unknown>;
+
+          // Check for mid-stream error
+          if (typeof chunk.error === 'string') {
+            send({
+              type: 'agent_event',
+              sessionId,
+              event: { type: 'error', message: chunk.error },
+            });
+            continue;
+          }
+
+          // Forward as chunk event for the message adapter
+          send({
+            type: 'agent_event',
+            sessionId,
+            event: {
+              type: 'chunk',
+              message: chunk.message,
+              done: chunk.done,
+              done_reason: chunk.done_reason,
+              model: chunk.model,
+              prompt_eval_count: chunk.prompt_eval_count,
+              eval_count: chunk.eval_count,
+              eval_duration: chunk.eval_duration,
+              total_duration: chunk.total_duration,
+            },
+          });
+        } catch {
+          log(`Failed to parse Ollama chunk: ${trimmed}`);
+        }
+      }
+    }
+
+    // Process remaining buffer
+    if (buffer.trim()) {
+      try {
+        const chunk = JSON.parse(buffer.trim()) as Record<string, unknown>;
+        send({
+          type: 'agent_event',
+          sessionId,
+          event: {
+            type: 'chunk',
+            message: chunk.message,
+            done: chunk.done,
+            done_reason: chunk.done_reason,
+            model: chunk.model,
+            prompt_eval_count: chunk.prompt_eval_count,
+            eval_count: chunk.eval_count,
+            eval_duration: chunk.eval_duration,
+            total_duration: chunk.total_duration,
+          },
+        });
+      } catch {
+        log(`Failed to parse final Ollama buffer: ${buffer}`);
+      }
+    }
+
+    sessions.delete(sessionId);
+    send({
+      type: 'agent_stopped',
+      sessionId,
+      exitCode: 0,
+      signal: null,
+    });
+  } catch (err: unknown) {
+    sessions.delete(sessionId);
+    const errMsg = err instanceof Error ? err.message : String(err);
+
+    if (controller.signal.aborted) {
+      log(`Ollama session ${sessionId} aborted`);
+      send({
+        type: 'agent_stopped',
+        sessionId,
+        exitCode: null,
+        signal: 'SIGTERM',
+      });
+    } else {
+      log(`Ollama session ${sessionId} error: ${errMsg}`);
+      send({
+        type: 'agent_error',
+        sessionId,
+        message: errMsg,
+      });
+    }
+  }
+}
+
+function handleStop(msg: StopMessage) {
+  const { sessionId } = msg;
+  const session = sessions.get(sessionId);
+  if (!session) {
+    send({ type: 'error', sessionId, message: 'Session not found' });
+    return;
+  }
+
+  log(`Stopping Ollama session ${sessionId}`);
+  session.controller.abort();
+}
+
+log('Ollama sidecar started');
+send({ type: 'ready' });
diff --git a/v2/sidecar/package-lock.json b/v2/sidecar/package-lock.json
new file mode 100644
index 0000000..ac2b98b
--- /dev/null
+++ b/v2/sidecar/package-lock.json
@@ -0,0 +1,481 @@
+{
+  "name": "bterminal-sidecar",
+  "version": "0.1.0",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "bterminal-sidecar",
+      "version": "0.1.0",
+      "devDependencies": {
+        "esbuild": "0.25.4"
+      }
+    },
+    "node_modules/@esbuild/aix-ppc64": {
+      "version": "0.25.4",
+      "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.25.4.tgz",
+      "integrity": "sha512-1VCICWypeQKhVbE9oW/sJaAmjLxhVqacdkvPLEjwlttjfwENRSClS8EjBz0KzRyFSCPDIkuXW34Je/vk7zdB7Q==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "aix"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/android-arm": {
+      "version": "0.25.4",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.25.4.tgz",
+      "integrity": "sha512-QNdQEps7DfFwE3hXiU4BZeOV68HHzYwGd0Nthhd3uCkkEKK7/R6MTgM0P7H7FAs5pU/DIWsviMmEGxEoxIZ+ZQ==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/android-arm64": {
+      "version": "0.25.4",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.25.4.tgz",
+      "integrity": "sha512-bBy69pgfhMGtCnwpC/x5QhfxAz/cBgQ9enbtwjf6V9lnPI/hMyT9iWpR1arm0l3kttTr4L0KSLpKmLp/ilKS9A==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/android-x64": {
+      "version": "0.25.4",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.25.4.tgz",
+      "integrity": "sha512-TVhdVtQIFuVpIIR282btcGC2oGQoSfZfmBdTip2anCaVYcqWlZXGcdcKIUklfX2wj0JklNYgz39OBqh2cqXvcQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/darwin-arm64": {
+      "version": "0.25.4",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.25.4.tgz",
+      "integrity": "sha512-Y1giCfM4nlHDWEfSckMzeWNdQS31BQGs9/rouw6Ub91tkK79aIMTH3q9xHvzH8d0wDru5Ci0kWB8b3up/nl16g==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/darwin-x64": {
+      "version": "0.25.4",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.25.4.tgz",
+      "integrity": "sha512-CJsry8ZGM5VFVeyUYB3cdKpd/H69PYez4eJh1W/t38vzutdjEjtP7hB6eLKBoOdxcAlCtEYHzQ/PJ/oU9I4u0A==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/freebsd-arm64": {
+      "version": "0.25.4",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.25.4.tgz",
+      "integrity": "sha512-yYq+39NlTRzU2XmoPW4l5Ifpl9fqSk0nAJYM/V/WUGPEFfek1epLHJIkTQM6bBs1swApjO5nWgvr843g6TjxuQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/freebsd-x64": {
+      "version": "0.25.4",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.25.4.tgz",
+      "integrity": "sha512-0FgvOJ6UUMflsHSPLzdfDnnBBVoCDtBTVyn/MrWloUNvq/5SFmh13l3dvgRPkDihRxb77Y17MbqbCAa2strMQQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-arm": {
+      "version": "0.25.4",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.25.4.tgz",
+      "integrity": "sha512-kro4c0P85GMfFYqW4TWOpvmF8rFShbWGnrLqlzp4X1TNWjRY3JMYUfDCtOxPKOIY8B0WC8HN51hGP4I4hz4AaQ==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-arm64": {
+      "version": "0.25.4",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.25.4.tgz",
+      "integrity": "sha512-+89UsQTfXdmjIvZS6nUnOOLoXnkUTB9hR5QAeLrQdzOSWZvNSAXAtcRDHWtqAUtAmv7ZM1WPOOeSxDzzzMogiQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-ia32": {
+      "version": "0.25.4",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.25.4.tgz",
+      "integrity": "sha512-yTEjoapy8UP3rv8dB0ip3AfMpRbyhSN3+hY8mo/i4QXFeDxmiYbEKp3ZRjBKcOP862Ua4b1PDfwlvbuwY7hIGQ==",
+      "cpu": [
+        "ia32"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-loong64": {
+      "version": "0.25.4",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.25.4.tgz",
+      "integrity": "sha512-NeqqYkrcGzFwi6CGRGNMOjWGGSYOpqwCjS9fvaUlX5s3zwOtn1qwg1s2iE2svBe4Q/YOG1q6875lcAoQK/F4VA==",
+      "cpu": [
+        "loong64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-mips64el": {
+      "version": "0.25.4",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.25.4.tgz",
+      "integrity": "sha512-IcvTlF9dtLrfL/M8WgNI/qJYBENP3ekgsHbYUIzEzq5XJzzVEV/fXY9WFPfEEXmu3ck2qJP8LG/p3Q8f7Zc2Xg==",
+      "cpu": [
+        "mips64el"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-ppc64": {
+      "version": "0.25.4",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.25.4.tgz",
+      "integrity": "sha512-HOy0aLTJTVtoTeGZh4HSXaO6M95qu4k5lJcH4gxv56iaycfz1S8GO/5Jh6X4Y1YiI0h7cRyLi+HixMR+88swag==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-riscv64": {
+      "version": "0.25.4",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.25.4.tgz",
+      "integrity": "sha512-i8JUDAufpz9jOzo4yIShCTcXzS07vEgWzyX3NH2G7LEFVgrLEhjwL3ajFE4fZI3I4ZgiM7JH3GQ7ReObROvSUA==",
+      "cpu": [
+        "riscv64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-s390x": {
+      "version": "0.25.4",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.25.4.tgz",
+      "integrity": "sha512-jFnu+6UbLlzIjPQpWCNh5QtrcNfMLjgIavnwPQAfoGx4q17ocOU9MsQ2QVvFxwQoWpZT8DvTLooTvmOQXkO51g==",
+      "cpu": [
+        "s390x"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-x64": {
+      "version": "0.25.4",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.25.4.tgz",
+      "integrity": "sha512-6e0cvXwzOnVWJHq+mskP8DNSrKBr1bULBvnFLpc1KY+d+irZSgZ02TGse5FsafKS5jg2e4pbvK6TPXaF/A6+CA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/netbsd-arm64": {
+      "version": "0.25.4",
+      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-arm64/-/netbsd-arm64-0.25.4.tgz",
+      "integrity": "sha512-vUnkBYxZW4hL/ie91hSqaSNjulOnYXE1VSLusnvHg2u3jewJBz3YzB9+oCw8DABeVqZGg94t9tyZFoHma8gWZQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "netbsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/netbsd-x64": {
+      "version": "0.25.4",
+      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.25.4.tgz",
+      "integrity": "sha512-XAg8pIQn5CzhOB8odIcAm42QsOfa98SBeKUdo4xa8OvX8LbMZqEtgeWE9P/Wxt7MlG2QqvjGths+nq48TrUiKw==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "netbsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/openbsd-arm64": {
+      "version": "0.25.4",
+      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-arm64/-/openbsd-arm64-0.25.4.tgz",
+      "integrity": "sha512-Ct2WcFEANlFDtp1nVAXSNBPDxyU+j7+tId//iHXU2f/lN5AmO4zLyhDcpR5Cz1r08mVxzt3Jpyt4PmXQ1O6+7A==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openbsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/openbsd-x64": {
+      "version": "0.25.4",
+      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.25.4.tgz",
+      "integrity": "sha512-xAGGhyOQ9Otm1Xu8NT1ifGLnA6M3sJxZ6ixylb+vIUVzvvd6GOALpwQrYrtlPouMqd/vSbgehz6HaVk4+7Afhw==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openbsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/sunos-x64": {
+      "version": "0.25.4",
+      "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.25.4.tgz",
+      "integrity": "sha512-Mw+tzy4pp6wZEK0+Lwr76pWLjrtjmJyUB23tHKqEDP74R3q95luY/bXqXZeYl4NYlvwOqoRKlInQialgCKy67Q==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "sunos"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/win32-arm64": {
+      "version": "0.25.4",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.25.4.tgz",
+      "integrity": "sha512-AVUP428VQTSddguz9dO9ngb+E5aScyg7nOeJDrF1HPYu555gmza3bDGMPhmVXL8svDSoqPCsCPjb265yG/kLKQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/win32-ia32": {
+      "version": "0.25.4",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.25.4.tgz",
+      "integrity": "sha512-i1sW+1i+oWvQzSgfRcxxG2k4I9n3O9NRqy8U+uugaT2Dy7kLO9Y7wI72haOahxceMX8hZAzgGou1FhndRldxRg==",
+      "cpu": [
+        "ia32"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/win32-x64": {
+      "version": "0.25.4",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.25.4.tgz",
+      "integrity": "sha512-nOT2vZNw6hJ+z43oP1SPea/G/6AbN6X+bGNhNuq8NtRHy4wsMhw765IKLNmnjek7GvjWBYQ8Q5VBoYTFg9y1UQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/esbuild": {
+      "version": "0.25.4",
+      "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.25.4.tgz",
+      "integrity": "sha512-8pgjLUcUjcgDg+2Q4NYXnPbo/vncAY4UmyaCm0jZevERqCHZIaWwdJHkf8XQtu4AxSKCdvrUbT0XUr1IdZzI8Q==",
+      "dev": true,
+      "hasInstallScript": true,
+      "license": "MIT",
+      "bin": {
+        "esbuild": "bin/esbuild"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "optionalDependencies": {
+        "@esbuild/aix-ppc64": "0.25.4",
+        "@esbuild/android-arm": "0.25.4",
+        "@esbuild/android-arm64": "0.25.4",
+        "@esbuild/android-x64": "0.25.4",
+        "@esbuild/darwin-arm64": "0.25.4",
+        "@esbuild/darwin-x64": "0.25.4",
+        "@esbuild/freebsd-arm64": "0.25.4",
+        "@esbuild/freebsd-x64": "0.25.4",
+        "@esbuild/linux-arm": "0.25.4",
+        "@esbuild/linux-arm64": "0.25.4",
+        "@esbuild/linux-ia32": "0.25.4",
+        "@esbuild/linux-loong64": "0.25.4",
+        "@esbuild/linux-mips64el": "0.25.4",
+        "@esbuild/linux-ppc64": "0.25.4",
+        "@esbuild/linux-riscv64": "0.25.4",
+        "@esbuild/linux-s390x": "0.25.4",
+        "@esbuild/linux-x64": "0.25.4",
+        "@esbuild/netbsd-arm64": "0.25.4",
+        "@esbuild/netbsd-x64": "0.25.4",
+        "@esbuild/openbsd-arm64": "0.25.4",
+        "@esbuild/openbsd-x64": "0.25.4",
+        "@esbuild/sunos-x64": "0.25.4",
+        "@esbuild/win32-arm64": "0.25.4",
+        "@esbuild/win32-ia32": "0.25.4",
+        "@esbuild/win32-x64": "0.25.4"
+      }
+    }
+  }
+}
diff --git a/v2/sidecar/package.json b/v2/sidecar/package.json
new file mode 100644
index 0000000..afd62b2
--- /dev/null
+++ b/v2/sidecar/package.json
@@ -0,0 +1,12 @@
+{
+  "name": "bterminal-sidecar",
+  "private": true,
+  "version": "0.1.0",
+  "type": "module",
+  "scripts": {
+    "build": "esbuild claude-runner.ts --bundle --platform=node --target=node20 --outfile=dist/claude-runner.mjs --format=esm"
+  },
+  "devDependencies": {
+    "esbuild": "0.25.4"
+  }
+}
diff --git a/v2/src-tauri/.gitignore b/v2/src-tauri/.gitignore
new file mode 100644
index 0000000..502406b
--- /dev/null
+++ b/v2/src-tauri/.gitignore
@@ -0,0 +1,4 @@
+# Generated by Cargo
+# will have compiled files and executables
+/target/
+/gen/schemas
diff --git a/v2/src-tauri/Cargo.toml b/v2/src-tauri/Cargo.toml
new file mode 100644
index 0000000..6e32a62
--- /dev/null
+++ b/v2/src-tauri/Cargo.toml
@@ -0,0 +1,45 @@
+[package]
+name = "bterminal"
+version = "0.1.0"
+description = "Multi-session Claude agent dashboard"
+authors = ["DexterFromLab"]
+license = "MIT"
+edition = "2021"
+rust-version = "1.77.2"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[lib]
+name = "bterminal_lib"
+crate-type = ["staticlib", "cdylib", "rlib"]
+
+[build-dependencies]
+tauri-build = { version = "2.5.6", features = [] }
+
+[dependencies]
+bterminal-core = { path = "../bterminal-core" }
+serde_json = "1.0"
+serde = { version = "1.0", features = ["derive"] }
+log = "0.4"
+tauri = { version = "2.10.3", features = [] }
+rusqlite = { version = "0.31", features = ["bundled-full"] }
+dirs = "5"
+notify = { version = "6", features = ["macos_fsevent"] }
+tauri-plugin-updater = "2.10.0"
+tauri-plugin-dialog = "2"
+rfd = { version = "0.16", default-features = false, features = ["gtk3"] }
+uuid = { version = "1", features = ["v4"] }
+tokio-tungstenite = { version = "0.21", features = ["native-tls"] }
+tokio = { version = "1", features = ["full"] }
+futures-util = "0.3"
+tracing = "0.1"
+tracing-subscriber = { version = "0.3", features = ["env-filter", "json"] }
+opentelemetry = "0.28"
+opentelemetry_sdk = { version = "0.28", features = ["rt-tokio"] }
+opentelemetry-otlp = { version = "0.28", features = ["http-proto", "reqwest-client"] }
+tracing-opentelemetry = "0.29"
+keyring = { version = "3", features = ["linux-native"] }
+notify-rust = "4"
+
+[dev-dependencies]
+tempfile = "3"
diff --git a/v2/src-tauri/build.rs b/v2/src-tauri/build.rs
new file mode 100644
index 0000000..795b9b7
--- /dev/null
+++ b/v2/src-tauri/build.rs
@@ -0,0 +1,3 @@
+fn main() {
+  tauri_build::build()
+}
diff --git a/v2/src-tauri/capabilities/default.json b/v2/src-tauri/capabilities/default.json
new file mode 100644
index 0000000..96d0efe
--- /dev/null
+++ b/v2/src-tauri/capabilities/default.json
@@ -0,0 +1,12 @@
+{
+  "$schema": "../gen/schemas/desktop-schema.json",
+  "identifier": "default",
+  "description": "enables the default permissions",
+  "windows": [
+    "main"
+  ],
+  "permissions": [
+    "core:default",
+    "dialog:default"
+  ]
+}
diff --git a/v2/src-tauri/icons/128x128.png b/v2/src-tauri/icons/128x128.png
new file mode 100644
index 0000000..5c5f833
Binary files /dev/null and b/v2/src-tauri/icons/128x128.png differ
diff --git a/v2/src-tauri/icons/128x128@2x.png b/v2/src-tauri/icons/128x128@2x.png
new file mode 100644
index 0000000..f49d48d
Binary files /dev/null and b/v2/src-tauri/icons/128x128@2x.png differ
diff --git a/v2/src-tauri/icons/32x32.png b/v2/src-tauri/icons/32x32.png
new file mode 100644
index 0000000..43c9c77
Binary files /dev/null and b/v2/src-tauri/icons/32x32.png differ
diff --git a/v2/src-tauri/icons/Square107x107Logo.png b/v2/src-tauri/icons/Square107x107Logo.png
new file mode 100644
index 0000000..f35d84f
Binary files /dev/null and b/v2/src-tauri/icons/Square107x107Logo.png differ
diff --git a/v2/src-tauri/icons/Square142x142Logo.png b/v2/src-tauri/icons/Square142x142Logo.png
new file mode 100644
index 0000000..1823bb2
Binary files /dev/null and b/v2/src-tauri/icons/Square142x142Logo.png differ
diff --git a/v2/src-tauri/icons/Square150x150Logo.png b/v2/src-tauri/icons/Square150x150Logo.png
new file mode 100644
index 0000000..dc2b22c
Binary files /dev/null and b/v2/src-tauri/icons/Square150x150Logo.png differ
diff --git a/v2/src-tauri/icons/Square284x284Logo.png b/v2/src-tauri/icons/Square284x284Logo.png
new file mode 100644
index 0000000..0ed3984
Binary files /dev/null and b/v2/src-tauri/icons/Square284x284Logo.png differ
diff --git a/v2/src-tauri/icons/Square30x30Logo.png b/v2/src-tauri/icons/Square30x30Logo.png
new file mode 100644
index 0000000..60bf0ea
Binary files /dev/null and b/v2/src-tauri/icons/Square30x30Logo.png differ
diff --git a/v2/src-tauri/icons/Square310x310Logo.png b/v2/src-tauri/icons/Square310x310Logo.png
new file mode 100644
index 0000000..c8ca0ad
Binary files /dev/null and b/v2/src-tauri/icons/Square310x310Logo.png differ
diff --git a/v2/src-tauri/icons/Square44x44Logo.png b/v2/src-tauri/icons/Square44x44Logo.png
new file mode 100644
index 0000000..8756459
Binary files /dev/null and b/v2/src-tauri/icons/Square44x44Logo.png differ
diff --git a/v2/src-tauri/icons/Square71x71Logo.png b/v2/src-tauri/icons/Square71x71Logo.png
new file mode 100644
index 0000000..2c8023c
Binary files /dev/null and b/v2/src-tauri/icons/Square71x71Logo.png differ
diff --git a/v2/src-tauri/icons/Square89x89Logo.png b/v2/src-tauri/icons/Square89x89Logo.png
new file mode 100644
index 0000000..2c5e603
Binary files /dev/null and b/v2/src-tauri/icons/Square89x89Logo.png differ
diff --git a/v2/src-tauri/icons/StoreLogo.png b/v2/src-tauri/icons/StoreLogo.png
new file mode 100644
index 0000000..17d142c
Binary files /dev/null and b/v2/src-tauri/icons/StoreLogo.png differ
diff --git a/v2/src-tauri/icons/icon.icns b/v2/src-tauri/icons/icon.icns
new file mode 100644
index 0000000..a2993ad
Binary files /dev/null and b/v2/src-tauri/icons/icon.icns differ
diff --git a/v2/src-tauri/icons/icon.ico b/v2/src-tauri/icons/icon.ico
new file mode 100644
index 0000000..29767e9
Binary files /dev/null and b/v2/src-tauri/icons/icon.ico differ
diff --git a/v2/src-tauri/icons/icon.png b/v2/src-tauri/icons/icon.png
new file mode 100644
index 0000000..2dbd21b
Binary files /dev/null and b/v2/src-tauri/icons/icon.png differ
diff --git a/v2/src-tauri/src/btmsg.rs b/v2/src-tauri/src/btmsg.rs
new file mode 100644
index 0000000..b5ca5aa
--- /dev/null
+++ b/v2/src-tauri/src/btmsg.rs
@@ -0,0 +1,1783 @@
+// btmsg — Access to btmsg SQLite database
+// Database at ~/.local/share/bterminal/btmsg.db (created by btmsg CLI)
+// Path configurable via init() for test isolation.
+
+use rusqlite::{params, Connection, OpenFlags};
+use serde::{Deserialize, Serialize};
+use std::path::PathBuf;
+use std::sync::OnceLock;
+
+static DB_PATH: OnceLock<PathBuf> = OnceLock::new();
+
+/// Set the btmsg database path. Must be called before any db access.
+/// Called from lib.rs setup with AppConfig-resolved path.
+pub fn init(path: PathBuf) {
+    let _ = DB_PATH.set(path);
+}
+
+fn db_path() -> PathBuf {
+    DB_PATH.get().cloned().unwrap_or_else(|| {
+        dirs::data_dir()
+            .unwrap_or_else(|| PathBuf::from("."))
+            .join("bterminal")
+            .join("btmsg.db")
+    })
+}
+
+fn open_db() -> Result<Connection, String> {
+    let path = db_path();
+    if !path.exists() {
+        return Err("btmsg database not found. Run 'btmsg register' first.".into());
+    }
+    let conn = Connection::open_with_flags(&path, OpenFlags::SQLITE_OPEN_READ_WRITE)
+        .map_err(|e| format!("Failed to open btmsg.db: {e}"))?;
+    conn.query_row("PRAGMA journal_mode=WAL", [], |_| Ok(()))
+        .map_err(|e| format!("Failed to set WAL mode: {e}"))?;
+    conn.pragma_update(None, "busy_timeout", 5000)
+        .map_err(|e| format!("Failed to set busy_timeout: {e}"))?;
+    Ok(conn)
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct BtmsgAgent {
+    pub id: String,
+    pub name: String,
+    pub role: String,
+    pub group_id: String,
+    pub tier: i32,
+    pub model: Option<String>,
+    pub status: String,
+    pub unread_count: i32,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct BtmsgMessage {
+    pub id: String,
+    pub from_agent: String,
+    pub to_agent: String,
+    pub content: String,
+    pub read: bool,
+    pub reply_to: Option<String>,
+    pub created_at: String,
+    pub sender_name: Option<String>,
+    pub sender_role: Option<String>,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct BtmsgFeedMessage {
+    pub id: String,
+    pub from_agent: String,
+    pub to_agent: String,
+    pub content: String,
+    pub created_at: String,
+    pub reply_to: Option<String>,
+    pub sender_name: String,
+    pub sender_role: String,
+    pub recipient_name: String,
+    pub recipient_role: String,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct BtmsgChannel {
+    pub id: String,
+    pub name: String,
+    pub group_id: String,
+    pub created_by: String,
+    pub member_count: i32,
+    pub created_at: String,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct BtmsgChannelMessage {
+    pub id: String,
+    pub channel_id: String,
+    pub from_agent: String,
+    pub content: String,
+    pub created_at: String,
+    pub sender_name: String,
+    pub sender_role: String,
+}
+
+pub fn get_agents(group_id: &str) -> Result<Vec<BtmsgAgent>, String> {
+    let db = open_db()?;
+    let mut stmt = db.prepare(
+        "SELECT a.*, (SELECT COUNT(*) FROM messages m WHERE m.to_agent = a.id AND m.read = 0) as unread_count \
+         FROM agents a WHERE a.group_id = ? ORDER BY a.tier, a.role, a.name"
+    ).map_err(|e| format!("Query error: {e}"))?;
+
+    let agents = stmt.query_map(params![group_id], |row| {
+        Ok(BtmsgAgent {
+            id: row.get("id")?,
+            name: row.get("name")?,
+            role: row.get("role")?,
+            group_id: row.get("group_id")?,
+            tier: row.get("tier")?,
+            model: row.get("model")?,
+            status: row.get::<_, Option<String>>("status")?.unwrap_or_else(|| "stopped".into()),
+            unread_count: row.get("unread_count")?,
+        })
+    }).map_err(|e| format!("Query error: {e}"))?;
+
+    agents.collect::<Result<Vec<_>, _>>().map_err(|e| format!("Row error: {e}"))
+}
+
+pub fn unread_count(agent_id: &str) -> Result<i32, String> {
+    let db = open_db()?;
+    db.query_row(
+        "SELECT COUNT(*) FROM messages WHERE to_agent = ? AND read = 0",
+        params![agent_id],
+        |row| row.get(0),
+    ).map_err(|e| format!("Query error: {e}"))
+}
+
+pub fn unread_messages(agent_id: &str) -> Result<Vec<BtmsgMessage>, String> {
+    let db = open_db()?;
+    let mut stmt = db.prepare(
+        "SELECT m.id, m.from_agent, m.to_agent, m.content, m.read, m.reply_to, m.created_at, \
+         a.name AS sender_name, a.role AS sender_role \
+         FROM messages m JOIN agents a ON m.from_agent = a.id \
+         WHERE m.to_agent = ? AND m.read = 0 ORDER BY m.created_at ASC"
+    ).map_err(|e| format!("Query error: {e}"))?;
+
+    let msgs = stmt.query_map(params![agent_id], |row| {
+        Ok(BtmsgMessage {
+            id: row.get("id")?,
+            from_agent: row.get("from_agent")?,
+            to_agent: row.get("to_agent")?,
+            content: row.get("content")?,
+            read: row.get::<_, i32>("read")? != 0,
+            reply_to: row.get("reply_to")?,
+            created_at: row.get("created_at")?,
+            sender_name: row.get("sender_name")?,
+            sender_role: row.get("sender_role")?,
+        })
+    }).map_err(|e| format!("Query error: {e}"))?;
+
+    msgs.collect::<Result<Vec<_>, _>>().map_err(|e| format!("Row error: {e}"))
+}
+
+pub fn history(agent_id: &str, other_id: &str, limit: i32) -> Result<Vec<BtmsgMessage>, String> {
+    let db = open_db()?;
+    let mut stmt = db.prepare(
+        "SELECT m.id, m.from_agent, m.to_agent, m.content, m.read, m.reply_to, m.created_at, \
+         a.name AS sender_name, a.role AS sender_role \
+         FROM messages m JOIN agents a ON m.from_agent = a.id \
+         WHERE (m.from_agent = ?1 AND m.to_agent = ?2) OR (m.from_agent = ?2 AND m.to_agent = ?1) \
+         ORDER BY m.created_at ASC LIMIT ?3"
+    ).map_err(|e| format!("Query error: {e}"))?;
+
+    let msgs = stmt.query_map(params![agent_id, other_id, limit], |row| {
+        Ok(BtmsgMessage {
+            id: row.get("id")?,
+            from_agent: row.get("from_agent")?,
+            to_agent: row.get("to_agent")?,
+            content: row.get("content")?,
+            read: row.get::<_, i32>("read")? != 0,
+            reply_to: row.get("reply_to")?,
+            created_at: row.get("created_at")?,
+            sender_name: row.get("sender_name")?,
+            sender_role: row.get("sender_role")?,
+        })
+    }).map_err(|e| format!("Query error: {e}"))?;
+
+    msgs.collect::<Result<Vec<_>, _>>().map_err(|e| format!("Row error: {e}"))
+}
+
+/// Default heartbeat staleness threshold: 5 minutes
+const STALE_HEARTBEAT_SECS: i64 = 300;
+
+pub fn send_message(from_agent: &str, to_agent: &str, content: &str) -> Result<String, String> {
+    let db = open_db()?;
+
+    // Get sender's group and tier
+    let (group_id, sender_tier): (String, i32) = db.query_row(
+        "SELECT group_id, tier FROM agents WHERE id = ?",
+        params![from_agent],
+        |row| Ok((row.get(0)?, row.get(1)?)),
+    ).map_err(|e| format!("Sender not found: {e}"))?;
+
+    // Admin (tier 0) bypasses contact restrictions
+    if sender_tier > 0 {
+        let allowed: bool = db.query_row(
+            "SELECT COUNT(*) > 0 FROM contacts WHERE agent_id = ? AND contact_id = ?",
+            params![from_agent, to_agent],
+            |row| row.get(0),
+        ).map_err(|e| format!("Contact check error: {e}"))?;
+
+        if !allowed {
+            return Err(format!("Not allowed to message '{to_agent}'"));
+        }
+    }
+
+    // Check if recipient is stale (no heartbeat in 5 min) — route to dead letter queue
+    let now = std::time::SystemTime::now()
+        .duration_since(std::time::UNIX_EPOCH)
+        .unwrap_or_default()
+        .as_secs() as i64;
+    let cutoff = now - STALE_HEARTBEAT_SECS;
+
+    let recipient_stale: bool = db
+        .query_row(
+            "SELECT COALESCE(h.timestamp, 0) < ?1 FROM agents a \
+             LEFT JOIN heartbeats h ON a.id = h.agent_id \
+             WHERE a.id = ?2",
+            params![cutoff, to_agent],
+            |row| row.get(0),
+        )
+        .unwrap_or(false);
+
+    if recipient_stale {
+        // Queue to dead letter instead of delivering
+        let error_msg = format!("Recipient '{}' is stale (no heartbeat in {} seconds)", to_agent, STALE_HEARTBEAT_SECS);
+        db.execute(
+            "INSERT INTO dead_letter_queue (from_agent, to_agent, content, error) VALUES (?1, ?2, ?3, ?4)",
+            params![from_agent, to_agent, content, error_msg],
+        )
+        .map_err(|e| format!("Dead letter insert error: {e}"))?;
+
+        // Also log audit event
+        let _ = db.execute(
+            "INSERT INTO audit_log (agent_id, event_type, detail) VALUES (?1, 'dead_letter', ?2)",
+            params![from_agent, format!("Message to '{}' routed to dead letter queue: {}", to_agent, error_msg)],
+        );
+
+        return Err(error_msg);
+    }
+
+    let msg_id = uuid::Uuid::new_v4().to_string();
+    db.execute(
+        "INSERT INTO messages (id, from_agent, to_agent, content, group_id) VALUES (?1, ?2, ?3, ?4, ?5)",
+        params![msg_id, from_agent, to_agent, content, group_id],
+    ).map_err(|e| format!("Insert error: {e}"))?;
+
+    Ok(msg_id)
+}
+
+pub fn set_status(agent_id: &str, status: &str) -> Result<(), String> {
+    let db = open_db()?;
+    db.execute(
+        "UPDATE agents SET status = ?, last_active_at = datetime('now') WHERE id = ?",
+        params![status, agent_id],
+    ).map_err(|e| format!("Update error: {e}"))?;
+    Ok(())
+}
+
+pub fn ensure_admin(group_id: &str) -> Result<(), String> {
+    let db = open_db()?;
+
+    let exists: bool = db.query_row(
+        "SELECT COUNT(*) > 0 FROM agents WHERE id = 'admin'",
+        [],
+        |row| row.get(0),
+    ).map_err(|e| format!("Query error: {e}"))?;
+
+    if !exists {
+        db.execute(
+            "INSERT INTO agents (id, name, role, group_id, tier, status) \
+             VALUES ('admin', 'Operator', 'admin', ?, 0, 'active')",
+            params![group_id],
+        ).map_err(|e| format!("Insert error: {e}"))?;
+    }
+
+    // Ensure admin has bidirectional contacts with ALL agents in the group
+    let mut stmt = db.prepare(
+        "SELECT id FROM agents WHERE group_id = ? AND id != 'admin'"
+    ).map_err(|e| format!("Query error: {e}"))?;
+    let agent_ids: Vec<String> = stmt.query_map(params![group_id], |row| row.get(0))
+        .map_err(|e| format!("Query error: {e}"))?
+        .collect::<Result<Vec<_>, _>>()
+        .map_err(|e| format!("Row error: {e}"))?;
+    drop(stmt);
+
+    for aid in &agent_ids {
+        db.execute(
+            "INSERT OR IGNORE INTO contacts (agent_id, contact_id) VALUES ('admin', ?)",
+            params![aid],
+        ).map_err(|e| format!("Insert error: {e}"))?;
+        db.execute(
+            "INSERT OR IGNORE INTO contacts (agent_id, contact_id) VALUES (?, 'admin')",
+            params![aid],
+        ).map_err(|e| format!("Insert error: {e}"))?;
+    }
+
+    Ok(())
+}
+
+/// Register all agents from groups.json into the btmsg database.
+/// Creates/updates agent records and sets up contact permissions:
+/// - All Tier 1 agents get bidirectional contacts with each other
+/// - Manager gets contacts with ALL agents (Tier 1 + Tier 2)
+/// - Other Tier 1 agents get contacts with Manager
+/// Also ensures admin agent and review channels exist.
+pub fn register_agents_from_groups(groups: &crate::groups::GroupsFile) -> Result<(), String> {
+    for group in &groups.groups {
+        register_group_agents(group)?;
+    }
+    Ok(())
+}
+
+/// Register all agents for a single group.
+fn register_group_agents(group: &crate::groups::GroupConfig) -> Result<(), String> {
+    let db = open_db_or_create()?;
+    let group_id = &group.id;
+
+    // Collect agent IDs by tier for contact setup
+    let mut tier1_ids: Vec<String> = Vec::new();
+    let mut tier2_ids: Vec<String> = Vec::new();
+    let mut manager_id: Option<String> = None;
+
+    // Register Tier 1 agents (from agents array)
+    for agent in &group.agents {
+        let tier = match agent.role.as_str() {
+            "manager" | "architect" | "tester" | "reviewer" => 1,
+            _ => 2,
+        };
+        upsert_agent(
+            &db,
+            &agent.id,
+            &agent.name,
+            &agent.role,
+            group_id,
+            tier,
+            agent.model.as_deref(),
+            agent.cwd.as_deref(),
+            agent.system_prompt.as_deref(),
+        )?;
+        if tier == 1 {
+            tier1_ids.push(agent.id.clone());
+            if agent.role == "manager" {
+                manager_id = Some(agent.id.clone());
+            }
+        } else {
+            tier2_ids.push(agent.id.clone());
+        }
+    }
+
+    // Register Tier 2 agents (from projects array)
+    for project in &group.projects {
+        upsert_agent(
+            &db,
+            &project.id,
+            &project.name,
+            "project",
+            group_id,
+            2,
+            None,
+            Some(&project.cwd),
+            None,
+        )?;
+        tier2_ids.push(project.id.clone());
+    }
+
+    // Set up contact permissions
+
+    // All Tier 1 agents: bidirectional contacts with each other
+    for i in 0..tier1_ids.len() {
+        for j in (i + 1)..tier1_ids.len() {
+            db.execute(
+                "INSERT OR IGNORE INTO contacts (agent_id, contact_id) VALUES (?1, ?2)",
+                params![tier1_ids[i], tier1_ids[j]],
+            ).map_err(|e| format!("Contact insert error: {e}"))?;
+            db.execute(
+                "INSERT OR IGNORE INTO contacts (agent_id, contact_id) VALUES (?1, ?2)",
+                params![tier1_ids[j], tier1_ids[i]],
+            ).map_err(|e| format!("Contact insert error: {e}"))?;
+        }
+    }
+
+    // Manager gets contacts with ALL Tier 2 agents (bidirectional)
+    if let Some(ref mgr_id) = manager_id {
+        for t2_id in &tier2_ids {
+            db.execute(
+                "INSERT OR IGNORE INTO contacts (agent_id, contact_id) VALUES (?1, ?2)",
+                params![mgr_id, t2_id],
+            ).map_err(|e| format!("Contact insert error: {e}"))?;
+            db.execute(
+                "INSERT OR IGNORE INTO contacts (agent_id, contact_id) VALUES (?1, ?2)",
+                params![t2_id, mgr_id],
+            ).map_err(|e| format!("Contact insert error: {e}"))?;
+        }
+    }
+
+    // Ensure review channels exist
+    ensure_review_channels_for_group(&db, group_id);
+
+    // Drop the connection before calling ensure_admin (which opens its own)
+    drop(db);
+
+    // Ensure admin agent exists with contacts to all agents
+    let _ = ensure_admin(group_id);
+
+    Ok(())
+}
+
+fn upsert_agent(
+    db: &Connection,
+    id: &str,
+    name: &str,
+    role: &str,
+    group_id: &str,
+    tier: i32,
+    model: Option<&str>,
+    cwd: Option<&str>,
+    system_prompt: Option<&str>,
+) -> Result<(), String> {
+    db.execute(
+        "INSERT INTO agents (id, name, role, group_id, tier, model, cwd, system_prompt)
+         VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8)
+         ON CONFLICT(id) DO UPDATE SET
+            name = excluded.name,
+            role = excluded.role,
+            group_id = excluded.group_id,
+            tier = excluded.tier,
+            model = excluded.model,
+            cwd = excluded.cwd,
+            system_prompt = excluded.system_prompt",
+        params![id, name, role, group_id, tier, model, cwd, system_prompt],
+    )
+    .map_err(|e| format!("Upsert agent error: {e}"))?;
+    Ok(())
+}
+
+/// Ensure #review-queue and #review-log channels exist for a group (public wrapper).
+fn ensure_review_channels_for_group(db: &Connection, group_id: &str) {
+    for name in &["review-queue", "review-log"] {
+        let exists: bool = db
+            .query_row(
+                "SELECT COUNT(*) > 0 FROM channels WHERE name = ?1 AND group_id = ?2",
+                params![name, group_id],
+                |row| row.get(0),
+            )
+            .unwrap_or(false);
+        if !exists {
+            let id = uuid::Uuid::new_v4().to_string();
+            let _ = db.execute(
+                "INSERT INTO channels (id, name, group_id, created_by) VALUES (?1, ?2, ?3, 'system')",
+                params![id, name, group_id],
+            );
+        }
+    }
+}
+
+/// Open btmsg database, creating it with schema if it doesn't exist.
+fn open_db_or_create() -> Result<Connection, String> {
+    let path = db_path();
+    if let Some(parent) = path.parent() {
+        std::fs::create_dir_all(parent)
+            .map_err(|e| format!("Failed to create data dir: {e}"))?;
+    }
+
+    let conn = Connection::open_with_flags(
+        &path,
+        OpenFlags::SQLITE_OPEN_READ_WRITE | OpenFlags::SQLITE_OPEN_CREATE,
+    )
+    .map_err(|e| format!("Failed to open/create btmsg.db: {e}"))?;
+
+    conn.query_row("PRAGMA journal_mode=WAL", [], |_| Ok(()))
+        .map_err(|e| format!("Failed to set WAL mode: {e}"))?;
+    conn.pragma_update(None, "busy_timeout", 5000)
+        .map_err(|e| format!("Failed to set busy_timeout: {e}"))?;
+
+    // Create tables if they don't exist (same schema as Python btmsg CLI)
+    conn.execute_batch(
+        "CREATE TABLE IF NOT EXISTS agents (
+            id TEXT PRIMARY KEY,
+            name TEXT NOT NULL,
+            role TEXT NOT NULL,
+            group_id TEXT NOT NULL,
+            tier INTEGER NOT NULL DEFAULT 2,
+            model TEXT,
+            cwd TEXT,
+            system_prompt TEXT,
+            status TEXT DEFAULT 'stopped',
+            last_active_at TEXT,
+            created_at TEXT DEFAULT (datetime('now'))
+        );
+
+        CREATE TABLE IF NOT EXISTS contacts (
+            agent_id TEXT NOT NULL,
+            contact_id TEXT NOT NULL,
+            PRIMARY KEY (agent_id, contact_id),
+            FOREIGN KEY (agent_id) REFERENCES agents(id),
+            FOREIGN KEY (contact_id) REFERENCES agents(id)
+        );
+
+        CREATE TABLE IF NOT EXISTS messages (
+            id TEXT PRIMARY KEY,
+            from_agent TEXT NOT NULL,
+            to_agent TEXT NOT NULL,
+            content TEXT NOT NULL,
+            read INTEGER DEFAULT 0,
+            reply_to TEXT,
+            group_id TEXT NOT NULL,
+            created_at TEXT DEFAULT (datetime('now')),
+            FOREIGN KEY (from_agent) REFERENCES agents(id),
+            FOREIGN KEY (to_agent) REFERENCES agents(id)
+        );
+
+        CREATE INDEX IF NOT EXISTS idx_messages_to ON messages(to_agent, read);
+        CREATE INDEX IF NOT EXISTS idx_messages_from ON messages(from_agent);
+        CREATE INDEX IF NOT EXISTS idx_messages_group ON messages(group_id);
+        CREATE INDEX IF NOT EXISTS idx_messages_reply ON messages(reply_to);
+
+        CREATE TABLE IF NOT EXISTS channels (
+            id TEXT PRIMARY KEY,
+            name TEXT NOT NULL,
+            group_id TEXT NOT NULL,
+            created_by TEXT NOT NULL,
+            created_at TEXT DEFAULT (datetime('now'))
+        );
+
+        CREATE TABLE IF NOT EXISTS channel_members (
+            channel_id TEXT NOT NULL,
+            agent_id TEXT NOT NULL,
+            joined_at TEXT DEFAULT (datetime('now')),
+            PRIMARY KEY (channel_id, agent_id),
+            FOREIGN KEY (channel_id) REFERENCES channels(id),
+            FOREIGN KEY (agent_id) REFERENCES agents(id)
+        );
+
+        CREATE TABLE IF NOT EXISTS channel_messages (
+            id TEXT PRIMARY KEY,
+            channel_id TEXT NOT NULL,
+            from_agent TEXT NOT NULL,
+            content TEXT NOT NULL,
+            created_at TEXT DEFAULT (datetime('now')),
+            FOREIGN KEY (channel_id) REFERENCES channels(id),
+            FOREIGN KEY (from_agent) REFERENCES agents(id)
+        );
+
+        CREATE INDEX IF NOT EXISTS idx_channel_messages ON channel_messages(channel_id, created_at);
+
+        CREATE TABLE IF NOT EXISTS tasks (
+            id TEXT PRIMARY KEY,
+            title TEXT NOT NULL,
+            description TEXT DEFAULT '',
+            status TEXT DEFAULT 'todo',
+            priority TEXT DEFAULT 'medium',
+            assigned_to TEXT,
+            created_by TEXT NOT NULL,
+            group_id TEXT NOT NULL,
+            parent_task_id TEXT,
+            sort_order INTEGER DEFAULT 0,
+            created_at TEXT DEFAULT (datetime('now')),
+            updated_at TEXT DEFAULT (datetime('now')),
+            FOREIGN KEY (assigned_to) REFERENCES agents(id),
+            FOREIGN KEY (created_by) REFERENCES agents(id)
+        );
+
+        CREATE TABLE IF NOT EXISTS task_comments (
+            id TEXT PRIMARY KEY,
+            task_id TEXT NOT NULL,
+            agent_id TEXT NOT NULL,
+            content TEXT NOT NULL,
+            created_at TEXT DEFAULT (datetime('now')),
+            FOREIGN KEY (task_id) REFERENCES tasks(id),
+            FOREIGN KEY (agent_id) REFERENCES agents(id)
+        );
+
+        CREATE INDEX IF NOT EXISTS idx_tasks_group ON tasks(group_id);
+        CREATE INDEX IF NOT EXISTS idx_tasks_status ON tasks(status);
+        CREATE INDEX IF NOT EXISTS idx_tasks_assigned ON tasks(assigned_to);
+        CREATE INDEX IF NOT EXISTS idx_task_comments_task ON task_comments(task_id);
+
+        CREATE TABLE IF NOT EXISTS heartbeats (
+            agent_id TEXT PRIMARY KEY,
+            timestamp INTEGER NOT NULL,
+            FOREIGN KEY (agent_id) REFERENCES agents(id)
+        );
+
+        CREATE TABLE IF NOT EXISTS dead_letter_queue (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            from_agent TEXT NOT NULL,
+            to_agent TEXT NOT NULL,
+            content TEXT NOT NULL,
+            error TEXT NOT NULL,
+            created_at TEXT DEFAULT (datetime('now')),
+            FOREIGN KEY (from_agent) REFERENCES agents(id),
+            FOREIGN KEY (to_agent) REFERENCES agents(id)
+        );
+
+        CREATE INDEX IF NOT EXISTS idx_dead_letter_from ON dead_letter_queue(from_agent);
+        CREATE INDEX IF NOT EXISTS idx_dead_letter_to ON dead_letter_queue(to_agent);
+
+        CREATE TABLE IF NOT EXISTS audit_log (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            agent_id TEXT NOT NULL,
+            event_type TEXT NOT NULL,
+            detail TEXT NOT NULL,
+            created_at TEXT DEFAULT (datetime('now')),
+            FOREIGN KEY (agent_id) REFERENCES agents(id)
+        );
+
+        CREATE INDEX IF NOT EXISTS idx_audit_log_agent ON audit_log(agent_id);
+        CREATE INDEX IF NOT EXISTS idx_audit_log_type ON audit_log(event_type);"
+    ).map_err(|e| format!("Schema creation error: {e}"))?;
+
+    Ok(conn)
+}
+
+// ---- Heartbeat monitoring ----
+
+#[derive(Debug, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct AgentHeartbeat {
+    pub agent_id: String,
+    pub agent_name: String,
+    pub agent_role: String,
+    pub timestamp: i64,
+}
+
+pub fn record_heartbeat(agent_id: &str) -> Result<(), String> {
+    let db = open_db()?;
+    let now = std::time::SystemTime::now()
+        .duration_since(std::time::UNIX_EPOCH)
+        .map_err(|e| format!("Time error: {e}"))?
+        .as_secs() as i64;
+    db.execute(
+        "INSERT INTO heartbeats (agent_id, timestamp) VALUES (?1, ?2) \
+         ON CONFLICT(agent_id) DO UPDATE SET timestamp = excluded.timestamp",
+        params![agent_id, now],
+    )
+    .map_err(|e| format!("Heartbeat upsert error: {e}"))?;
+    Ok(())
+}
+
+pub fn get_agent_heartbeats(group_id: &str) -> Result<Vec<AgentHeartbeat>, String> {
+    let db = open_db()?;
+    let mut stmt = db
+        .prepare(
+            "SELECT h.agent_id, a.name AS agent_name, a.role AS agent_role, h.timestamp \
+             FROM heartbeats h JOIN agents a ON h.agent_id = a.id \
+             WHERE a.group_id = ? ORDER BY h.timestamp DESC",
+        )
+        .map_err(|e| format!("Query error: {e}"))?;
+
+    let rows = stmt
+        .query_map(params![group_id], |row| {
+            Ok(AgentHeartbeat {
+                agent_id: row.get("agent_id")?,
+                agent_name: row.get("agent_name")?,
+                agent_role: row.get("agent_role")?,
+                timestamp: row.get("timestamp")?,
+            })
+        })
+        .map_err(|e| format!("Query error: {e}"))?;
+
+    rows.collect::<Result<Vec<_>, _>>()
+        .map_err(|e| format!("Row error: {e}"))
+}
+
+pub fn get_stale_agents(group_id: &str, threshold_secs: i64) -> Result<Vec<String>, String> {
+    let db = open_db()?;
+    let now = std::time::SystemTime::now()
+        .duration_since(std::time::UNIX_EPOCH)
+        .map_err(|e| format!("Time error: {e}"))?
+        .as_secs() as i64;
+    let cutoff = now - threshold_secs;
+
+    // Agents in the group that either have no heartbeat or heartbeat older than cutoff
+    let mut stmt = db
+        .prepare(
+            "SELECT a.id FROM agents a LEFT JOIN heartbeats h ON a.id = h.agent_id \
+             WHERE a.group_id = ? AND a.tier > 0 AND (h.timestamp IS NULL OR h.timestamp < ?)",
+        )
+        .map_err(|e| format!("Query error: {e}"))?;
+
+    let ids = stmt
+        .query_map(params![group_id, cutoff], |row| row.get::<_, String>(0))
+        .map_err(|e| format!("Query error: {e}"))?;
+
+    ids.collect::<Result<Vec<_>, _>>()
+        .map_err(|e| format!("Row error: {e}"))
+}
+
+// ---- Dead letter queue ----
+
+#[derive(Debug, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct DeadLetter {
+    pub id: i64,
+    pub from_agent: String,
+    pub to_agent: String,
+    pub content: String,
+    pub error: String,
+    pub created_at: String,
+}
+
+pub fn queue_dead_letter(
+    from_agent: &str,
+    to_agent: &str,
+    content: &str,
+    error: &str,
+) -> Result<(), String> {
+    let db = open_db()?;
+    db.execute(
+        "INSERT INTO dead_letter_queue (from_agent, to_agent, content, error) VALUES (?1, ?2, ?3, ?4)",
+        params![from_agent, to_agent, content, error],
+    )
+    .map_err(|e| format!("Dead letter insert error: {e}"))?;
+    Ok(())
+}
+
+pub fn get_dead_letters(group_id: &str, limit: i32) -> Result<Vec<DeadLetter>, String> {
+    let db = open_db()?;
+    let mut stmt = db
+        .prepare(
+            "SELECT d.id, d.from_agent, d.to_agent, d.content, d.error, d.created_at \
+             FROM dead_letter_queue d \
+             JOIN agents a ON d.to_agent = a.id \
+             WHERE a.group_id = ? \
+             ORDER BY d.created_at DESC LIMIT ?",
+        )
+        .map_err(|e| format!("Query error: {e}"))?;
+
+    let rows = stmt
+        .query_map(params![group_id, limit], |row| {
+            Ok(DeadLetter {
+                id: row.get("id")?,
+                from_agent: row.get("from_agent")?,
+                to_agent: row.get("to_agent")?,
+                content: row.get("content")?,
+                error: row.get("error")?,
+                created_at: row.get("created_at")?,
+            })
+        })
+        .map_err(|e| format!("Query error: {e}"))?;
+
+    rows.collect::<Result<Vec<_>, _>>()
+        .map_err(|e| format!("Row error: {e}"))
+}
+
+pub fn clear_dead_letters(group_id: &str) -> Result<(), String> {
+    let db = open_db()?;
+    db.execute(
+        "DELETE FROM dead_letter_queue WHERE to_agent IN (SELECT id FROM agents WHERE group_id = ?)",
+        params![group_id],
+    )
+    .map_err(|e| format!("Delete error: {e}"))?;
+    Ok(())
+}
+
+// ---- Audit log ----
+
+#[derive(Debug, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct AuditEntry {
+    pub id: i64,
+    pub agent_id: String,
+    pub event_type: String,
+    pub detail: String,
+    pub created_at: String,
+}
+
+pub fn log_audit_event(agent_id: &str, event_type: &str, detail: &str) -> Result<(), String> {
+    let db = open_db_or_create()?;
+    db.execute(
+        "INSERT INTO audit_log (agent_id, event_type, detail) VALUES (?1, ?2, ?3)",
+        params![agent_id, event_type, detail],
+    )
+    .map_err(|e| format!("Audit log insert error: {e}"))?;
+    Ok(())
+}
+
+pub fn get_audit_log(group_id: &str, limit: i32, offset: i32) -> Result<Vec<AuditEntry>, String> {
+    let db = open_db()?;
+    let mut stmt = db
+        .prepare(
+            "SELECT al.id, al.agent_id, al.event_type, al.detail, al.created_at \
+             FROM audit_log al \
+             JOIN agents a ON al.agent_id = a.id \
+             WHERE a.group_id = ? \
+             ORDER BY al.created_at DESC, al.id DESC LIMIT ? OFFSET ?",
+        )
+        .map_err(|e| format!("Query error: {e}"))?;
+
+    let rows = stmt
+        .query_map(params![group_id, limit, offset], |row| {
+            Ok(AuditEntry {
+                id: row.get("id")?,
+                agent_id: row.get("agent_id")?,
+                event_type: row.get("event_type")?,
+                detail: row.get("detail")?,
+                created_at: row.get("created_at")?,
+            })
+        })
+        .map_err(|e| format!("Query error: {e}"))?;
+
+    rows.collect::<Result<Vec<_>, _>>()
+        .map_err(|e| format!("Row error: {e}"))
+}
+
+pub fn get_audit_log_for_agent(
+    agent_id: &str,
+    limit: i32,
+) -> Result<Vec<AuditEntry>, String> {
+    let db = open_db()?;
+    let mut stmt = db
+        .prepare(
+            "SELECT id, agent_id, event_type, detail, created_at \
+             FROM audit_log WHERE agent_id = ? ORDER BY created_at DESC, id DESC LIMIT ?",
+        )
+        .map_err(|e| format!("Query error: {e}"))?;
+
+    let rows = stmt
+        .query_map(params![agent_id, limit], |row| {
+            Ok(AuditEntry {
+                id: row.get("id")?,
+                agent_id: row.get("agent_id")?,
+                event_type: row.get("event_type")?,
+                detail: row.get("detail")?,
+                created_at: row.get("created_at")?,
+            })
+        })
+        .map_err(|e| format!("Query error: {e}"))?;
+
+    rows.collect::<Result<Vec<_>, _>>()
+        .map_err(|e| format!("Row error: {e}"))
+}
+
+pub fn all_feed(group_id: &str, limit: i32) -> Result<Vec<BtmsgFeedMessage>, String> {
+    let db = open_db()?;
+    let mut stmt = db.prepare(
+        "SELECT m.id, m.from_agent, m.to_agent, m.content, m.created_at, m.reply_to, \
+         a1.name AS sender_name, a1.role AS sender_role, \
+         a2.name AS recipient_name, a2.role AS recipient_role \
+         FROM messages m \
+         JOIN agents a1 ON m.from_agent = a1.id \
+         JOIN agents a2 ON m.to_agent = a2.id \
+         WHERE m.group_id = ? \
+         ORDER BY m.created_at DESC LIMIT ?"
+    ).map_err(|e| format!("Query error: {e}"))?;
+
+    let msgs = stmt.query_map(params![group_id, limit], |row| {
+        Ok(BtmsgFeedMessage {
+            id: row.get("id")?,
+            from_agent: row.get("from_agent")?,
+            to_agent: row.get("to_agent")?,
+            content: row.get("content")?,
+            created_at: row.get("created_at")?,
+            reply_to: row.get("reply_to")?,
+            sender_name: row.get("sender_name")?,
+            sender_role: row.get("sender_role")?,
+            recipient_name: row.get("recipient_name")?,
+            recipient_role: row.get("recipient_role")?,
+        })
+    }).map_err(|e| format!("Query error: {e}"))?;
+
+    msgs.collect::<Result<Vec<_>, _>>().map_err(|e| format!("Row error: {e}"))
+}
+
+pub fn mark_read_conversation(reader_id: &str, sender_id: &str) -> Result<(), String> {
+    let db = open_db()?;
+    db.execute(
+        "UPDATE messages SET read = 1 WHERE to_agent = ? AND from_agent = ? AND read = 0",
+        params![reader_id, sender_id],
+    ).map_err(|e| format!("Update error: {e}"))?;
+    Ok(())
+}
+
+pub fn get_channels(group_id: &str) -> Result<Vec<BtmsgChannel>, String> {
+    let db = open_db()?;
+    let mut stmt = db.prepare(
+        "SELECT c.id, c.name, c.group_id, c.created_by, \
+         (SELECT COUNT(*) FROM channel_members cm WHERE cm.channel_id = c.id) AS member_count, \
+         c.created_at \
+         FROM channels c WHERE c.group_id = ? ORDER BY c.name"
+    ).map_err(|e| format!("Query error: {e}"))?;
+
+    let channels = stmt.query_map(params![group_id], |row| {
+        Ok(BtmsgChannel {
+            id: row.get("id")?,
+            name: row.get("name")?,
+            group_id: row.get("group_id")?,
+            created_by: row.get("created_by")?,
+            member_count: row.get("member_count")?,
+            created_at: row.get("created_at")?,
+        })
+    }).map_err(|e| format!("Query error: {e}"))?;
+
+    channels.collect::<Result<Vec<_>, _>>().map_err(|e| format!("Row error: {e}"))
+}
+
+pub fn get_channel_messages(channel_id: &str, limit: i32) -> Result<Vec<BtmsgChannelMessage>, String> {
+    let db = open_db()?;
+    let mut stmt = db.prepare(
+        "SELECT cm.id, cm.channel_id, cm.from_agent, cm.content, cm.created_at, \
+         a.name AS sender_name, a.role AS sender_role \
+         FROM channel_messages cm JOIN agents a ON cm.from_agent = a.id \
+         WHERE cm.channel_id = ? ORDER BY cm.created_at ASC LIMIT ?"
+    ).map_err(|e| format!("Query error: {e}"))?;
+
+    let msgs = stmt.query_map(params![channel_id, limit], |row| {
+        Ok(BtmsgChannelMessage {
+            id: row.get("id")?,
+            channel_id: row.get("channel_id")?,
+            from_agent: row.get("from_agent")?,
+            content: row.get("content")?,
+            created_at: row.get("created_at")?,
+            sender_name: row.get("sender_name")?,
+            sender_role: row.get("sender_role")?,
+        })
+    }).map_err(|e| format!("Query error: {e}"))?;
+
+    msgs.collect::<Result<Vec<_>, _>>().map_err(|e| format!("Row error: {e}"))
+}
+
+pub fn send_channel_message(channel_id: &str, from_agent: &str, content: &str) -> Result<String, String> {
+    let db = open_db()?;
+
+    // Verify channel exists
+    let _: String = db.query_row(
+        "SELECT id FROM channels WHERE id = ?",
+        params![channel_id],
+        |row| row.get(0),
+    ).map_err(|e| format!("Channel not found: {e}"))?;
+
+    // Check membership (admin bypasses)
+    let sender_tier: i32 = db.query_row(
+        "SELECT tier FROM agents WHERE id = ?",
+        params![from_agent],
+        |row| row.get(0),
+    ).map_err(|e| format!("Sender not found: {e}"))?;
+
+    if sender_tier > 0 {
+        let is_member: bool = db.query_row(
+            "SELECT COUNT(*) > 0 FROM channel_members WHERE channel_id = ? AND agent_id = ?",
+            params![channel_id, from_agent],
+            |row| row.get(0),
+        ).map_err(|e| format!("Membership check error: {e}"))?;
+
+        if !is_member {
+            return Err("Not a member of this channel".into());
+        }
+    }
+
+    let msg_id = uuid::Uuid::new_v4().to_string();
+    db.execute(
+        "INSERT INTO channel_messages (id, channel_id, from_agent, content) VALUES (?1, ?2, ?3, ?4)",
+        params![msg_id, channel_id, from_agent, content],
+    ).map_err(|e| format!("Insert error: {e}"))?;
+
+    Ok(msg_id)
+}
+
+pub fn create_channel(name: &str, group_id: &str, created_by: &str) -> Result<String, String> {
+    let db = open_db()?;
+    let channel_id = uuid::Uuid::new_v4().to_string()[..8].to_string();
+
+    db.execute(
+        "INSERT INTO channels (id, name, group_id, created_by) VALUES (?1, ?2, ?3, ?4)",
+        params![channel_id, name, group_id, created_by],
+    ).map_err(|e| format!("Insert error: {e}"))?;
+
+    // Auto-add creator as member
+    db.execute(
+        "INSERT INTO channel_members (channel_id, agent_id) VALUES (?1, ?2)",
+        params![channel_id, created_by],
+    ).map_err(|e| format!("Insert error: {e}"))?;
+
+    Ok(channel_id)
+}
+
+pub fn add_channel_member(channel_id: &str, agent_id: &str) -> Result<(), String> {
+    let db = open_db()?;
+    db.execute(
+        "INSERT OR IGNORE INTO channel_members (channel_id, agent_id) VALUES (?1, ?2)",
+        params![channel_id, agent_id],
+    ).map_err(|e| format!("Insert error: {e}"))?;
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use rusqlite::Connection;
+
+    /// Create an in-memory DB with the btmsg schema for testing.
+    fn test_db() -> Connection {
+        let conn = Connection::open_in_memory().unwrap();
+        conn.execute_batch(
+            "CREATE TABLE agents (
+                id TEXT PRIMARY KEY,
+                name TEXT NOT NULL,
+                role TEXT NOT NULL,
+                group_id TEXT NOT NULL,
+                tier INTEGER NOT NULL DEFAULT 1,
+                model TEXT,
+                cwd TEXT,
+                system_prompt TEXT,
+                status TEXT DEFAULT 'stopped',
+                last_active_at TEXT
+            );
+            CREATE TABLE messages (
+                id TEXT PRIMARY KEY,
+                from_agent TEXT NOT NULL,
+                to_agent TEXT NOT NULL,
+                content TEXT NOT NULL,
+                group_id TEXT NOT NULL,
+                read INTEGER DEFAULT 0,
+                reply_to TEXT,
+                created_at TEXT DEFAULT (datetime('now'))
+            );
+            CREATE TABLE contacts (
+                agent_id TEXT NOT NULL,
+                contact_id TEXT NOT NULL,
+                PRIMARY KEY (agent_id, contact_id)
+            );
+            CREATE TABLE channels (
+                id TEXT PRIMARY KEY,
+                name TEXT NOT NULL,
+                group_id TEXT NOT NULL,
+                created_by TEXT NOT NULL,
+                created_at TEXT DEFAULT (datetime('now'))
+            );
+            CREATE TABLE channel_members (
+                channel_id TEXT NOT NULL,
+                agent_id TEXT NOT NULL,
+                PRIMARY KEY (channel_id, agent_id)
+            );
+            CREATE TABLE channel_messages (
+                id TEXT PRIMARY KEY,
+                channel_id TEXT NOT NULL,
+                from_agent TEXT NOT NULL,
+                content TEXT NOT NULL,
+                created_at TEXT DEFAULT (datetime('now'))
+            );
+            CREATE TABLE heartbeats (
+                agent_id TEXT PRIMARY KEY,
+                timestamp INTEGER NOT NULL
+            );
+            CREATE TABLE dead_letter_queue (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                from_agent TEXT NOT NULL,
+                to_agent TEXT NOT NULL,
+                content TEXT NOT NULL,
+                error TEXT NOT NULL,
+                created_at TEXT DEFAULT (datetime('now'))
+            );
+            CREATE TABLE audit_log (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                agent_id TEXT NOT NULL,
+                event_type TEXT NOT NULL,
+                detail TEXT NOT NULL,
+                created_at TEXT DEFAULT (datetime('now'))
+            );",
+        )
+        .unwrap();
+        conn
+    }
+
+    fn seed_agents(conn: &Connection) {
+        conn.execute(
+            "INSERT INTO agents (id, name, role, group_id, tier, model, system_prompt, status)
+             VALUES ('a1', 'Coder', 'developer', 'g1', 1, 'claude-4', 'You are a coder', 'active')",
+            [],
+        ).unwrap();
+        conn.execute(
+            "INSERT INTO agents (id, name, role, group_id, tier, model, system_prompt, status)
+             VALUES ('a2', 'Reviewer', 'reviewer', 'g1', 2, NULL, 'You review code', 'sleeping')",
+            [],
+        ).unwrap();
+        conn.execute(
+            "INSERT INTO agents (id, name, role, group_id, tier, model, system_prompt, status)
+             VALUES ('admin', 'Operator', 'admin', 'g1', 0, NULL, NULL, 'active')",
+            [],
+        ).unwrap();
+    }
+
+    // ---- CRITICAL REGRESSION: get_agents named column access ----
+    // Bug: positional index 7 returned system_prompt instead of status (column 8).
+    // Fix: named access via row.get("status").
+
+    #[test]
+    fn test_get_agents_returns_status_not_system_prompt() {
+        let conn = test_db();
+        seed_agents(&conn);
+
+        let mut stmt = conn.prepare(
+            "SELECT a.*, (SELECT COUNT(*) FROM messages m WHERE m.to_agent = a.id AND m.read = 0) as unread_count \
+             FROM agents a WHERE a.group_id = ? ORDER BY a.tier, a.role, a.name"
+        ).unwrap();
+
+        let agents: Vec<BtmsgAgent> = stmt.query_map(params!["g1"], |row| {
+            Ok(BtmsgAgent {
+                id: row.get("id")?,
+                name: row.get("name")?,
+                role: row.get("role")?,
+                group_id: row.get("group_id")?,
+                tier: row.get("tier")?,
+                model: row.get("model")?,
+                status: row.get::<_, Option<String>>("status")?.unwrap_or_else(|| "stopped".into()),
+                unread_count: row.get("unread_count")?,
+            })
+        }).unwrap().collect::<Result<Vec<_>, _>>().unwrap();
+
+        assert_eq!(agents.len(), 3);
+
+        // admin (tier 0) comes first
+        assert_eq!(agents[0].id, "admin");
+        assert_eq!(agents[0].status, "active");
+        assert_eq!(agents[0].tier, 0);
+
+        // Coder — status must be "active", NOT "You are a coder" (system_prompt)
+        let coder = agents.iter().find(|a| a.id == "a1").unwrap();
+        assert_eq!(coder.status, "active");
+        assert_eq!(coder.name, "Coder");
+        assert_eq!(coder.model, Some("claude-4".to_string()));
+
+        // Reviewer — status must be "sleeping", NOT "You review code" (system_prompt)
+        let reviewer = agents.iter().find(|a| a.id == "a2").unwrap();
+        assert_eq!(reviewer.status, "sleeping");
+        assert_eq!(reviewer.model, None);
+    }
+
+    #[test]
+    fn test_get_agents_unread_count() {
+        let conn = test_db();
+        seed_agents(&conn);
+
+        // Send 2 unread messages to a1
+        conn.execute(
+            "INSERT INTO messages (id, from_agent, to_agent, content, group_id, read) VALUES ('m1', 'a2', 'a1', 'hi', 'g1', 0)",
+            [],
+        ).unwrap();
+        conn.execute(
+            "INSERT INTO messages (id, from_agent, to_agent, content, group_id, read) VALUES ('m2', 'admin', 'a1', 'task', 'g1', 0)",
+            [],
+        ).unwrap();
+        // Send 1 read message to a1
+        conn.execute(
+            "INSERT INTO messages (id, from_agent, to_agent, content, group_id, read) VALUES ('m3', 'a2', 'a1', 'old', 'g1', 1)",
+            [],
+        ).unwrap();
+
+        let mut stmt = conn.prepare(
+            "SELECT a.*, (SELECT COUNT(*) FROM messages m WHERE m.to_agent = a.id AND m.read = 0) as unread_count \
+             FROM agents a WHERE a.group_id = ? ORDER BY a.tier, a.role, a.name"
+        ).unwrap();
+
+        let agents: Vec<BtmsgAgent> = stmt.query_map(params!["g1"], |row| {
+            Ok(BtmsgAgent {
+                id: row.get("id")?,
+                name: row.get("name")?,
+                role: row.get("role")?,
+                group_id: row.get("group_id")?,
+                tier: row.get("tier")?,
+                model: row.get("model")?,
+                status: row.get::<_, Option<String>>("status")?.unwrap_or_else(|| "stopped".into()),
+                unread_count: row.get("unread_count")?,
+            })
+        }).unwrap().collect::<Result<Vec<_>, _>>().unwrap();
+
+        let coder = agents.iter().find(|a| a.id == "a1").unwrap();
+        assert_eq!(coder.unread_count, 2);
+
+        let reviewer = agents.iter().find(|a| a.id == "a2").unwrap();
+        assert_eq!(reviewer.unread_count, 0);
+    }
+
+    // ---- REGRESSION: all_feed JOIN alias disambiguation ----
+    // Bug: JOINed queries had duplicate "name" columns. Fixed with AS aliases.
+
+    #[test]
+    fn test_all_feed_returns_correct_sender_and_recipient_names() {
+        let conn = test_db();
+        seed_agents(&conn);
+
+        conn.execute(
+            "INSERT INTO messages (id, from_agent, to_agent, content, group_id) VALUES ('m1', 'a1', 'a2', 'review this', 'g1')",
+            [],
+        ).unwrap();
+
+        let mut stmt = conn.prepare(
+            "SELECT m.id, m.from_agent, m.to_agent, m.content, m.created_at, m.reply_to, \
+             a1.name AS sender_name, a1.role AS sender_role, \
+             a2.name AS recipient_name, a2.role AS recipient_role \
+             FROM messages m \
+             JOIN agents a1 ON m.from_agent = a1.id \
+             JOIN agents a2 ON m.to_agent = a2.id \
+             WHERE m.group_id = ? \
+             ORDER BY m.created_at DESC LIMIT ?"
+        ).unwrap();
+
+        let msgs: Vec<BtmsgFeedMessage> = stmt.query_map(params!["g1", 100], |row| {
+            Ok(BtmsgFeedMessage {
+                id: row.get("id")?,
+                from_agent: row.get("from_agent")?,
+                to_agent: row.get("to_agent")?,
+                content: row.get("content")?,
+                created_at: row.get("created_at")?,
+                reply_to: row.get("reply_to")?,
+                sender_name: row.get("sender_name")?,
+                sender_role: row.get("sender_role")?,
+                recipient_name: row.get("recipient_name")?,
+                recipient_role: row.get("recipient_role")?,
+            })
+        }).unwrap().collect::<Result<Vec<_>, _>>().unwrap();
+
+        assert_eq!(msgs.len(), 1);
+        assert_eq!(msgs[0].sender_name, "Coder");
+        assert_eq!(msgs[0].sender_role, "developer");
+        assert_eq!(msgs[0].recipient_name, "Reviewer");
+        assert_eq!(msgs[0].recipient_role, "reviewer");
+    }
+
+    // ---- REGRESSION: unread_messages JOIN alias ----
+
+    #[test]
+    fn test_unread_messages_returns_sender_info() {
+        let conn = test_db();
+        seed_agents(&conn);
+
+        conn.execute(
+            "INSERT INTO messages (id, from_agent, to_agent, content, group_id, read) VALUES ('m1', 'a1', 'a2', 'check this', 'g1', 0)",
+            [],
+        ).unwrap();
+
+        let mut stmt = conn.prepare(
+            "SELECT m.id, m.from_agent, m.to_agent, m.content, m.read, m.reply_to, m.created_at, \
+             a.name AS sender_name, a.role AS sender_role \
+             FROM messages m JOIN agents a ON m.from_agent = a.id \
+             WHERE m.to_agent = ? AND m.read = 0 ORDER BY m.created_at ASC"
+        ).unwrap();
+
+        let msgs: Vec<BtmsgMessage> = stmt.query_map(params!["a2"], |row| {
+            Ok(BtmsgMessage {
+                id: row.get("id")?,
+                from_agent: row.get("from_agent")?,
+                to_agent: row.get("to_agent")?,
+                content: row.get("content")?,
+                read: row.get::<_, i32>("read")? != 0,
+                reply_to: row.get("reply_to")?,
+                created_at: row.get("created_at")?,
+                sender_name: row.get("sender_name")?,
+                sender_role: row.get("sender_role")?,
+            })
+        }).unwrap().collect::<Result<Vec<_>, _>>().unwrap();
+
+        assert_eq!(msgs.len(), 1);
+        assert_eq!(msgs[0].sender_name, Some("Coder".to_string()));
+        assert_eq!(msgs[0].sender_role, Some("developer".to_string()));
+        assert!(!msgs[0].read);
+    }
+
+    // ---- REGRESSION: channel_messages JOIN alias ----
+
+    #[test]
+    fn test_channel_messages_returns_sender_info() {
+        let conn = test_db();
+        seed_agents(&conn);
+
+        conn.execute(
+            "INSERT INTO channels (id, name, group_id, created_by) VALUES ('ch1', 'general', 'g1', 'admin')",
+            [],
+        ).unwrap();
+        conn.execute(
+            "INSERT INTO channel_members (channel_id, agent_id) VALUES ('ch1', 'a1')",
+            [],
+        ).unwrap();
+        conn.execute(
+            "INSERT INTO channel_messages (id, channel_id, from_agent, content) VALUES ('cm1', 'ch1', 'a1', 'hello channel')",
+            [],
+        ).unwrap();
+
+        let mut stmt = conn.prepare(
+            "SELECT cm.id, cm.channel_id, cm.from_agent, cm.content, cm.created_at, \
+             a.name AS sender_name, a.role AS sender_role \
+             FROM channel_messages cm JOIN agents a ON cm.from_agent = a.id \
+             WHERE cm.channel_id = ? ORDER BY cm.created_at ASC LIMIT ?"
+        ).unwrap();
+
+        let msgs: Vec<BtmsgChannelMessage> = stmt.query_map(params!["ch1", 100], |row| {
+            Ok(BtmsgChannelMessage {
+                id: row.get("id")?,
+                channel_id: row.get("channel_id")?,
+                from_agent: row.get("from_agent")?,
+                content: row.get("content")?,
+                created_at: row.get("created_at")?,
+                sender_name: row.get("sender_name")?,
+                sender_role: row.get("sender_role")?,
+            })
+        }).unwrap().collect::<Result<Vec<_>, _>>().unwrap();
+
+        assert_eq!(msgs.len(), 1);
+        assert_eq!(msgs[0].sender_name, "Coder");
+        assert_eq!(msgs[0].sender_role, "developer");
+    }
+
+    // ---- serde camelCase serialization ----
+
+    #[test]
+    fn test_btmsg_agent_serializes_to_camel_case() {
+        let agent = BtmsgAgent {
+            id: "a1".into(),
+            name: "Test".into(),
+            role: "dev".into(),
+            group_id: "g1".into(),
+            tier: 1,
+            model: None,
+            status: "active".into(),
+            unread_count: 5,
+        };
+
+        let json = serde_json::to_value(&agent).unwrap();
+        // Verify camelCase keys (matches TypeScript interface)
+        assert!(json.get("groupId").is_some(), "expected camelCase 'groupId'");
+        assert!(json.get("unreadCount").is_some(), "expected camelCase 'unreadCount'");
+        assert!(json.get("group_id").is_none(), "should not have snake_case 'group_id'");
+        assert!(json.get("unread_count").is_none(), "should not have snake_case 'unread_count'");
+    }
+
+    #[test]
+    fn test_btmsg_message_serializes_to_camel_case() {
+        let msg = BtmsgMessage {
+            id: "m1".into(),
+            from_agent: "a1".into(),
+            to_agent: "a2".into(),
+            content: "hi".into(),
+            read: false,
+            reply_to: None,
+            created_at: "2026-01-01".into(),
+            sender_name: Some("Coder".into()),
+            sender_role: Some("dev".into()),
+        };
+
+        let json = serde_json::to_value(&msg).unwrap();
+        assert!(json.get("fromAgent").is_some(), "expected camelCase 'fromAgent'");
+        assert!(json.get("toAgent").is_some(), "expected camelCase 'toAgent'");
+        assert!(json.get("replyTo").is_some(), "expected camelCase 'replyTo'");
+        assert!(json.get("createdAt").is_some(), "expected camelCase 'createdAt'");
+        assert!(json.get("senderName").is_some(), "expected camelCase 'senderName'");
+        assert!(json.get("senderRole").is_some(), "expected camelCase 'senderRole'");
+    }
+
+    #[test]
+    fn test_btmsg_feed_message_serializes_to_camel_case() {
+        let msg = BtmsgFeedMessage {
+            id: "m1".into(),
+            from_agent: "a1".into(),
+            to_agent: "a2".into(),
+            content: "hi".into(),
+            created_at: "2026-01-01".into(),
+            reply_to: None,
+            sender_name: "Coder".into(),
+            sender_role: "dev".into(),
+            recipient_name: "Reviewer".into(),
+            recipient_role: "reviewer".into(),
+        };
+
+        let json = serde_json::to_value(&msg).unwrap();
+        assert!(json.get("recipientName").is_some(), "expected camelCase 'recipientName'");
+        assert!(json.get("recipientRole").is_some(), "expected camelCase 'recipientRole'");
+    }
+
+    // ---- Agent registration tests ----
+
+    #[test]
+    fn test_upsert_agent_inserts_new() {
+        let conn = test_db();
+        upsert_agent(&conn, "mgr1", "Manager", "manager", "g1", 1, Some("claude-4"), None, Some("You manage")).unwrap();
+
+        let agent = conn.query_row(
+            "SELECT * FROM agents WHERE id = 'mgr1'", [],
+            |row| Ok((
+                row.get::<_, String>("name").unwrap(),
+                row.get::<_, String>("role").unwrap(),
+                row.get::<_, i32>("tier").unwrap(),
+                row.get::<_, Option<String>>("model").unwrap(),
+                row.get::<_, Option<String>>("system_prompt").unwrap(),
+            )),
+        ).unwrap();
+        assert_eq!(agent.0, "Manager");
+        assert_eq!(agent.1, "manager");
+        assert_eq!(agent.2, 1);
+        assert_eq!(agent.3, Some("claude-4".to_string()));
+        assert_eq!(agent.4, Some("You manage".to_string()));
+    }
+
+    #[test]
+    fn test_upsert_agent_updates_existing() {
+        let conn = test_db();
+        upsert_agent(&conn, "a1", "OldName", "manager", "g1", 1, None, None, None).unwrap();
+        upsert_agent(&conn, "a1", "NewName", "architect", "g1", 1, Some("model-x"), None, None).unwrap();
+
+        let (name, role, model): (String, String, Option<String>) = conn.query_row(
+            "SELECT name, role, model FROM agents WHERE id = 'a1'", [],
+            |row| Ok((row.get(0)?, row.get(1)?, row.get(2)?)),
+        ).unwrap();
+        assert_eq!(name, "NewName");
+        assert_eq!(role, "architect");
+        assert_eq!(model, Some("model-x".to_string()));
+    }
+
+    #[test]
+    fn test_ensure_review_channels_for_group_creates_both() {
+        let conn = test_db();
+        ensure_review_channels_for_group(&conn, "g1");
+
+        let queue: i64 = conn.query_row(
+            "SELECT COUNT(*) FROM channels WHERE name = 'review-queue' AND group_id = 'g1'",
+            [], |row| row.get(0),
+        ).unwrap();
+        let log: i64 = conn.query_row(
+            "SELECT COUNT(*) FROM channels WHERE name = 'review-log' AND group_id = 'g1'",
+            [], |row| row.get(0),
+        ).unwrap();
+        assert_eq!(queue, 1);
+        assert_eq!(log, 1);
+
+        // Idempotent
+        ensure_review_channels_for_group(&conn, "g1");
+        let queue2: i64 = conn.query_row(
+            "SELECT COUNT(*) FROM channels WHERE name = 'review-queue' AND group_id = 'g1'",
+            [], |row| row.get(0),
+        ).unwrap();
+        assert_eq!(queue2, 1);
+    }
+
+    #[test]
+    fn test_upsert_preserves_status() {
+        let conn = test_db();
+        upsert_agent(&conn, "a1", "Agent", "manager", "g1", 1, None, None, None).unwrap();
+
+        // Manually set status to 'active'
+        conn.execute("UPDATE agents SET status = 'active' WHERE id = 'a1'", []).unwrap();
+
+        // Upsert should NOT overwrite status (ON CONFLICT only updates name/role/etc)
+        upsert_agent(&conn, "a1", "Agent Updated", "manager", "g1", 1, None, None, None).unwrap();
+
+        let status: String = conn.query_row(
+            "SELECT status FROM agents WHERE id = 'a1'", [],
+            |row| row.get(0),
+        ).unwrap();
+        assert_eq!(status, "active", "upsert should preserve existing status");
+    }
+
+    // ---- Heartbeat tests ----
+
+    #[test]
+    fn test_heartbeat_upsert_and_query() {
+        let conn = test_db();
+        seed_agents(&conn);
+
+        let now = std::time::SystemTime::now()
+            .duration_since(std::time::UNIX_EPOCH)
+            .unwrap()
+            .as_secs() as i64;
+
+        // Insert heartbeat for a1
+        conn.execute(
+            "INSERT INTO heartbeats (agent_id, timestamp) VALUES ('a1', ?1) \
+             ON CONFLICT(agent_id) DO UPDATE SET timestamp = excluded.timestamp",
+            params![now],
+        ).unwrap();
+
+        // Query heartbeats for group
+        let mut stmt = conn.prepare(
+            "SELECT h.agent_id, a.name AS agent_name, a.role AS agent_role, h.timestamp \
+             FROM heartbeats h JOIN agents a ON h.agent_id = a.id \
+             WHERE a.group_id = ? ORDER BY h.timestamp DESC"
+        ).unwrap();
+
+        let heartbeats: Vec<AgentHeartbeat> = stmt.query_map(params!["g1"], |row| {
+            Ok(AgentHeartbeat {
+                agent_id: row.get("agent_id")?,
+                agent_name: row.get("agent_name")?,
+                agent_role: row.get("agent_role")?,
+                timestamp: row.get("timestamp")?,
+            })
+        }).unwrap().collect::<Result<Vec<_>, _>>().unwrap();
+
+        assert_eq!(heartbeats.len(), 1);
+        assert_eq!(heartbeats[0].agent_id, "a1");
+        assert_eq!(heartbeats[0].agent_name, "Coder");
+        assert_eq!(heartbeats[0].timestamp, now);
+
+        // Upsert overwrites
+        let later = now + 10;
+        conn.execute(
+            "INSERT INTO heartbeats (agent_id, timestamp) VALUES ('a1', ?1) \
+             ON CONFLICT(agent_id) DO UPDATE SET timestamp = excluded.timestamp",
+            params![later],
+        ).unwrap();
+
+        let ts: i64 = conn.query_row(
+            "SELECT timestamp FROM heartbeats WHERE agent_id = 'a1'", [],
+            |row| row.get(0),
+        ).unwrap();
+        assert_eq!(ts, later);
+    }
+
+    #[test]
+    fn test_stale_agents_detection() {
+        let conn = test_db();
+        seed_agents(&conn);
+
+        let now = std::time::SystemTime::now()
+            .duration_since(std::time::UNIX_EPOCH)
+            .unwrap()
+            .as_secs() as i64;
+
+        // a1 has a recent heartbeat, a2 has a stale one
+        conn.execute("INSERT INTO heartbeats (agent_id, timestamp) VALUES ('a1', ?)", params![now]).unwrap();
+        conn.execute("INSERT INTO heartbeats (agent_id, timestamp) VALUES ('a2', ?)", params![now - 600]).unwrap();
+
+        // Stale threshold: 300 seconds
+        let cutoff = now - 300;
+        let mut stmt = conn.prepare(
+            "SELECT a.id FROM agents a LEFT JOIN heartbeats h ON a.id = h.agent_id \
+             WHERE a.group_id = ? AND a.tier > 0 AND (h.timestamp IS NULL OR h.timestamp < ?)"
+        ).unwrap();
+
+        let stale: Vec<String> = stmt.query_map(params!["g1", cutoff], |row| {
+            row.get::<_, String>(0)
+        }).unwrap().collect::<Result<Vec<_>, _>>().unwrap();
+
+        assert_eq!(stale.len(), 1);
+        assert_eq!(stale[0], "a2");
+    }
+
+    // ---- Dead letter queue tests ----
+
+    #[test]
+    fn test_dead_letter_queue_insert_and_query() {
+        let conn = test_db();
+        seed_agents(&conn);
+
+        conn.execute(
+            "INSERT INTO dead_letter_queue (from_agent, to_agent, content, error) VALUES ('a1', 'a2', 'hello', 'stale')",
+            [],
+        ).unwrap();
+
+        let mut stmt = conn.prepare(
+            "SELECT d.id, d.from_agent, d.to_agent, d.content, d.error, d.created_at \
+             FROM dead_letter_queue d JOIN agents a ON d.to_agent = a.id \
+             WHERE a.group_id = ? ORDER BY d.created_at DESC LIMIT 50"
+        ).unwrap();
+
+        let letters: Vec<DeadLetter> = stmt.query_map(params!["g1"], |row| {
+            Ok(DeadLetter {
+                id: row.get("id")?,
+                from_agent: row.get("from_agent")?,
+                to_agent: row.get("to_agent")?,
+                content: row.get("content")?,
+                error: row.get("error")?,
+                created_at: row.get("created_at")?,
+            })
+        }).unwrap().collect::<Result<Vec<_>, _>>().unwrap();
+
+        assert_eq!(letters.len(), 1);
+        assert_eq!(letters[0].from_agent, "a1");
+        assert_eq!(letters[0].to_agent, "a2");
+        assert_eq!(letters[0].content, "hello");
+        assert_eq!(letters[0].error, "stale");
+    }
+
+    #[test]
+    fn test_dead_letter_clear() {
+        let conn = test_db();
+        seed_agents(&conn);
+
+        conn.execute(
+            "INSERT INTO dead_letter_queue (from_agent, to_agent, content, error) VALUES ('a1', 'a2', 'msg', 'err')",
+            [],
+        ).unwrap();
+
+        let count: i64 = conn.query_row(
+            "SELECT COUNT(*) FROM dead_letter_queue", [], |row| row.get(0),
+        ).unwrap();
+        assert_eq!(count, 1);
+
+        conn.execute(
+            "DELETE FROM dead_letter_queue WHERE to_agent IN (SELECT id FROM agents WHERE group_id = ?)",
+            params!["g1"],
+        ).unwrap();
+
+        let count: i64 = conn.query_row(
+            "SELECT COUNT(*) FROM dead_letter_queue", [], |row| row.get(0),
+        ).unwrap();
+        assert_eq!(count, 0);
+    }
+
+    // ---- Audit log tests ----
+
+    #[test]
+    fn test_audit_log_insert_and_query() {
+        let conn = test_db();
+        seed_agents(&conn);
+
+        conn.execute(
+            "INSERT INTO audit_log (agent_id, event_type, detail) VALUES ('a1', 'status_change', 'Started running')",
+            [],
+        ).unwrap();
+        conn.execute(
+            "INSERT INTO audit_log (agent_id, event_type, detail) VALUES ('a1', 'wake_event', 'Auto-wake triggered')",
+            [],
+        ).unwrap();
+
+        let mut stmt = conn.prepare(
+            "SELECT al.id, al.agent_id, al.event_type, al.detail, al.created_at \
+             FROM audit_log al JOIN agents a ON al.agent_id = a.id \
+             WHERE a.group_id = ? ORDER BY al.created_at DESC, al.id DESC LIMIT ? OFFSET ?"
+        ).unwrap();
+
+        let entries: Vec<AuditEntry> = stmt.query_map(params!["g1", 50, 0], |row| {
+            Ok(AuditEntry {
+                id: row.get("id")?,
+                agent_id: row.get("agent_id")?,
+                event_type: row.get("event_type")?,
+                detail: row.get("detail")?,
+                created_at: row.get("created_at")?,
+            })
+        }).unwrap().collect::<Result<Vec<_>, _>>().unwrap();
+
+        assert_eq!(entries.len(), 2);
+        // Reverse chronological (by id tiebreaker) — most recent first
+        assert_eq!(entries[0].event_type, "wake_event");
+        assert_eq!(entries[1].event_type, "status_change");
+    }
+
+    #[test]
+    fn test_audit_log_for_agent() {
+        let conn = test_db();
+        seed_agents(&conn);
+
+        conn.execute(
+            "INSERT INTO audit_log (agent_id, event_type, detail) VALUES ('a1', 'status_change', 'started')",
+            [],
+        ).unwrap();
+        conn.execute(
+            "INSERT INTO audit_log (agent_id, event_type, detail) VALUES ('a2', 'btmsg_sent', 'sent msg')",
+            [],
+        ).unwrap();
+
+        let mut stmt = conn.prepare(
+            "SELECT id, agent_id, event_type, detail, created_at \
+             FROM audit_log WHERE agent_id = ? ORDER BY created_at DESC LIMIT ?"
+        ).unwrap();
+
+        let entries: Vec<AuditEntry> = stmt.query_map(params!["a1", 50], |row| {
+            Ok(AuditEntry {
+                id: row.get("id")?,
+                agent_id: row.get("agent_id")?,
+                event_type: row.get("event_type")?,
+                detail: row.get("detail")?,
+                created_at: row.get("created_at")?,
+            })
+        }).unwrap().collect::<Result<Vec<_>, _>>().unwrap();
+
+        assert_eq!(entries.len(), 1);
+        assert_eq!(entries[0].agent_id, "a1");
+        assert_eq!(entries[0].event_type, "status_change");
+    }
+
+    #[test]
+    fn test_agent_heartbeat_serializes_to_camel_case() {
+        let hb = AgentHeartbeat {
+            agent_id: "a1".into(),
+            agent_name: "Coder".into(),
+            agent_role: "developer".into(),
+            timestamp: 1234567890,
+        };
+        let json = serde_json::to_value(&hb).unwrap();
+        assert!(json.get("agentId").is_some(), "expected camelCase 'agentId'");
+        assert!(json.get("agentName").is_some(), "expected camelCase 'agentName'");
+        assert!(json.get("agentRole").is_some(), "expected camelCase 'agentRole'");
+        assert!(json.get("agent_id").is_none(), "should not have snake_case 'agent_id'");
+    }
+
+    #[test]
+    fn test_dead_letter_serializes_to_camel_case() {
+        let dl = DeadLetter {
+            id: 1,
+            from_agent: "a1".into(),
+            to_agent: "a2".into(),
+            content: "hello".into(),
+            error: "stale".into(),
+            created_at: "2026-01-01".into(),
+        };
+        let json = serde_json::to_value(&dl).unwrap();
+        assert!(json.get("fromAgent").is_some(), "expected camelCase 'fromAgent'");
+        assert!(json.get("toAgent").is_some(), "expected camelCase 'toAgent'");
+        assert!(json.get("createdAt").is_some(), "expected camelCase 'createdAt'");
+    }
+
+    #[test]
+    fn test_audit_entry_serializes_to_camel_case() {
+        let entry = AuditEntry {
+            id: 1,
+            agent_id: "a1".into(),
+            event_type: "status_change".into(),
+            detail: "started".into(),
+            created_at: "2026-01-01".into(),
+        };
+        let json = serde_json::to_value(&entry).unwrap();
+        assert!(json.get("agentId").is_some(), "expected camelCase 'agentId'");
+        assert!(json.get("eventType").is_some(), "expected camelCase 'eventType'");
+        assert!(json.get("createdAt").is_some(), "expected camelCase 'createdAt'");
+        assert!(json.get("agent_id").is_none(), "should not have snake_case");
+    }
+
+    // ---- WAL checkpoint tests ----
+
+    #[test]
+    fn test_checkpoint_wal_on_temp_database() {
+        let dir = tempfile::tempdir().unwrap();
+        let db_path = dir.path().join("test_wal.db");
+
+        // Create a WAL-mode database with some data
+        {
+            let conn = Connection::open(&db_path).unwrap();
+            conn.query_row("PRAGMA journal_mode=WAL", [], |_| Ok(())).unwrap();
+            conn.execute_batch("CREATE TABLE t (id INTEGER PRIMARY KEY, val TEXT);").unwrap();
+            for i in 0..100 {
+                conn.execute("INSERT INTO t (val) VALUES (?)", params![format!("row-{i}")]).unwrap();
+            }
+            // Keep connection open while we checkpoint from another connection
+            // to simulate the real scenario (app holds a conn, background task checkpoints)
+
+            // Run checkpoint from a separate connection (like the background task does)
+            let result = crate::checkpoint_wal(&db_path);
+            assert!(result.is_ok(), "checkpoint_wal should succeed: {:?}", result);
+        }
+
+        // Verify data is still intact after checkpoint
+        let conn = Connection::open(&db_path).unwrap();
+        let count: i64 = conn.query_row("SELECT COUNT(*) FROM t", [], |row| row.get(0)).unwrap();
+        assert_eq!(count, 100, "all rows should survive checkpoint");
+    }
+
+    #[test]
+    fn test_checkpoint_wal_nonexistent_db_is_ok() {
+        let result = crate::checkpoint_wal(std::path::Path::new("/tmp/nonexistent_bterminal_test.db"));
+        assert!(result.is_ok(), "checkpoint_wal should return Ok for missing DB");
+    }
+
+    #[test]
+    fn test_contact_permissions_bidirectional() {
+        let conn = test_db();
+        upsert_agent(&conn, "mgr", "Manager", "manager", "g1", 1, None, None, None).unwrap();
+        upsert_agent(&conn, "arch", "Architect", "architect", "g1", 1, None, None, None).unwrap();
+
+        // Set up bidirectional contacts (simulating what register_group_agents does)
+        conn.execute("INSERT OR IGNORE INTO contacts (agent_id, contact_id) VALUES ('mgr', 'arch')", []).unwrap();
+        conn.execute("INSERT OR IGNORE INTO contacts (agent_id, contact_id) VALUES ('arch', 'mgr')", []).unwrap();
+
+        let fwd: bool = conn.query_row(
+            "SELECT COUNT(*) > 0 FROM contacts WHERE agent_id = 'mgr' AND contact_id = 'arch'",
+            [], |row| row.get(0),
+        ).unwrap();
+        let rev: bool = conn.query_row(
+            "SELECT COUNT(*) > 0 FROM contacts WHERE agent_id = 'arch' AND contact_id = 'mgr'",
+            [], |row| row.get(0),
+        ).unwrap();
+        assert!(fwd, "forward contact should exist");
+        assert!(rev, "reverse contact should exist");
+    }
+}
diff --git a/v2/src-tauri/src/bttask.rs b/v2/src-tauri/src/bttask.rs
new file mode 100644
index 0000000..6c46cfe
--- /dev/null
+++ b/v2/src-tauri/src/bttask.rs
@@ -0,0 +1,766 @@
+// bttask — Read access to task board SQLite tables in btmsg.db
+// Tasks table created by bttask CLI, shared DB with btmsg
+// Path configurable via init() for test isolation.
+
+use rusqlite::{params, Connection, OpenFlags};
+use serde::{Deserialize, Serialize};
+use std::path::PathBuf;
+use std::sync::OnceLock;
+
+static DB_PATH: OnceLock<PathBuf> = OnceLock::new();
+
+/// Set the bttask database path. Must be called before any db access.
+/// Called from lib.rs setup with AppConfig-resolved path.
+pub fn init(path: PathBuf) {
+    let _ = DB_PATH.set(path);
+}
+
+fn db_path() -> PathBuf {
+    DB_PATH.get().cloned().unwrap_or_else(|| {
+        dirs::data_dir()
+            .unwrap_or_else(|| PathBuf::from("."))
+            .join("bterminal")
+            .join("btmsg.db")
+    })
+}
+
+fn open_db() -> Result<Connection, String> {
+    let path = db_path();
+    if !path.exists() {
+        return Err("btmsg database not found".into());
+    }
+    let conn = Connection::open_with_flags(&path, OpenFlags::SQLITE_OPEN_READ_WRITE)
+        .map_err(|e| format!("Failed to open btmsg.db: {e}"))?;
+    conn.query_row("PRAGMA journal_mode=WAL", [], |_| Ok(()))
+        .map_err(|e| format!("Failed to set WAL mode: {e}"))?;
+    conn.pragma_update(None, "busy_timeout", 5000)
+        .map_err(|e| format!("Failed to set busy_timeout: {e}"))?;
+
+    // Migration: add version column if missing
+    let has_version: i64 = conn
+        .query_row(
+            "SELECT COUNT(*) FROM pragma_table_info('tasks') WHERE name='version'",
+            [],
+            |row| row.get(0),
+        )
+        .unwrap_or(0);
+    if has_version == 0 {
+        conn.execute("ALTER TABLE tasks ADD COLUMN version INTEGER DEFAULT 1", [])
+            .map_err(|e| format!("Migration (version column) failed: {e}"))?;
+    }
+
+    Ok(conn)
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Task {
+    pub id: String,
+    pub title: String,
+    pub description: String,
+    pub status: String,
+    pub priority: String,
+    pub assigned_to: Option<String>,
+    pub created_by: String,
+    pub group_id: String,
+    pub parent_task_id: Option<String>,
+    pub sort_order: i32,
+    pub created_at: String,
+    pub updated_at: String,
+    pub version: i64,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct TaskComment {
+    pub id: String,
+    pub task_id: String,
+    pub agent_id: String,
+    pub content: String,
+    pub created_at: String,
+}
+
+/// Get all tasks for a group
+pub fn list_tasks(group_id: &str) -> Result<Vec<Task>, String> {
+    let db = open_db()?;
+    let mut stmt = db
+        .prepare(
+            "SELECT id, title, description, status, priority, assigned_to,
+                    created_by, group_id, parent_task_id, sort_order,
+                    created_at, updated_at, version
+             FROM tasks WHERE group_id = ?1
+             ORDER BY sort_order ASC, created_at DESC",
+        )
+        .map_err(|e| format!("Query error: {e}"))?;
+
+    let rows = stmt
+        .query_map(params![group_id], |row| {
+            Ok(Task {
+                id: row.get("id")?,
+                title: row.get("title")?,
+                description: row.get::<_, String>("description").unwrap_or_default(),
+                status: row.get::<_, String>("status").unwrap_or_else(|_| "todo".into()),
+                priority: row.get::<_, String>("priority").unwrap_or_else(|_| "medium".into()),
+                assigned_to: row.get("assigned_to")?,
+                created_by: row.get("created_by")?,
+                group_id: row.get("group_id")?,
+                parent_task_id: row.get("parent_task_id")?,
+                sort_order: row.get::<_, i32>("sort_order").unwrap_or(0),
+                created_at: row.get::<_, String>("created_at").unwrap_or_default(),
+                updated_at: row.get::<_, String>("updated_at").unwrap_or_default(),
+                version: row.get::<_, i64>("version").unwrap_or(1),
+            })
+        })
+        .map_err(|e| format!("Query error: {e}"))?;
+
+    rows.collect::<Result<Vec<_>, _>>()
+        .map_err(|e| format!("Row error: {e}"))
+}
+
+/// Get comments for a task
+pub fn task_comments(task_id: &str) -> Result<Vec<TaskComment>, String> {
+    let db = open_db()?;
+    let mut stmt = db
+        .prepare(
+            "SELECT id, task_id, agent_id, content, created_at
+             FROM task_comments WHERE task_id = ?1
+             ORDER BY created_at ASC",
+        )
+        .map_err(|e| format!("Query error: {e}"))?;
+
+    let rows = stmt
+        .query_map(params![task_id], |row| {
+            Ok(TaskComment {
+                id: row.get("id")?,
+                task_id: row.get("task_id")?,
+                agent_id: row.get("agent_id")?,
+                content: row.get("content")?,
+                created_at: row.get::<_, String>("created_at").unwrap_or_default(),
+            })
+        })
+        .map_err(|e| format!("Query error: {e}"))?;
+
+    rows.collect::<Result<Vec<_>, _>>()
+        .map_err(|e| format!("Row error: {e}"))
+}
+
+/// Update task status with optimistic locking.
+/// `expected_version` must match the current version in the database.
+/// Returns the new version on success.
+/// When transitioning to 'review', auto-posts to #review-queue channel if it exists.
+pub fn update_task_status(task_id: &str, status: &str, expected_version: i64) -> Result<i64, String> {
+    let valid = ["todo", "progress", "review", "done", "blocked"];
+    if !valid.contains(&status) {
+        return Err(format!("Invalid status '{}'. Valid: {:?}", status, valid));
+    }
+    let db = open_db()?;
+
+    // Fetch task info before update (for channel notification)
+    let task_title: Option<(String, String)> = if status == "review" {
+        db.query_row(
+            "SELECT title, group_id FROM tasks WHERE id = ?1",
+            params![task_id],
+            |row| Ok((row.get::<_, String>("title")?, row.get::<_, String>("group_id")?)),
+        ).ok()
+    } else {
+        None
+    };
+
+    let rows_affected = db.execute(
+        "UPDATE tasks SET status = ?1, version = version + 1, updated_at = datetime('now')
+         WHERE id = ?2 AND version = ?3",
+        params![status, task_id, expected_version],
+    )
+    .map_err(|e| format!("Update error: {e}"))?;
+
+    if rows_affected == 0 {
+        return Err("Task was modified by another agent (version conflict)".into());
+    }
+
+    let new_version = expected_version + 1;
+
+    // Auto-post to #review-queue channel on review transition
+    if let Some((title, group_id)) = task_title {
+        notify_review_channel(&db, &group_id, task_id, &title);
+    }
+
+    Ok(new_version)
+}
+
+/// Post a notification to #review-queue channel (best-effort, never fails the parent operation)
+fn notify_review_channel(db: &Connection, group_id: &str, task_id: &str, title: &str) {
+    // Find #review-queue channel for this group
+    let channel_id: Option<String> = db
+        .query_row(
+            "SELECT id FROM channels WHERE name = 'review-queue' AND group_id = ?1",
+            params![group_id],
+            |row| row.get(0),
+        )
+        .ok();
+
+    let channel_id = match channel_id {
+        Some(id) => id,
+        None => {
+            // Auto-create #review-queue channel
+            match ensure_review_channels(db, group_id) {
+                Some(id) => id,
+                None => return, // Give up silently
+            }
+        }
+    };
+
+    let msg_id = uuid::Uuid::new_v4().to_string();
+    let content = format!("📋 Task ready for review: **{}** (`{}`)", title, task_id);
+    let _ = db.execute(
+        "INSERT INTO channel_messages (id, channel_id, from_agent, content) VALUES (?1, ?2, 'system', ?3)",
+        params![msg_id, channel_id, content],
+    );
+}
+
+/// Ensure #review-queue and #review-log channels exist for a group.
+/// Returns the review-queue channel ID if created/found.
+fn ensure_review_channels(db: &Connection, group_id: &str) -> Option<String> {
+    // Create channels only if they don't already exist
+    for name in &["review-queue", "review-log"] {
+        let exists: bool = db
+            .query_row(
+                "SELECT COUNT(*) > 0 FROM channels WHERE name = ?1 AND group_id = ?2",
+                params![name, group_id],
+                |row| row.get(0),
+            )
+            .unwrap_or(false);
+        if !exists {
+            let id = uuid::Uuid::new_v4().to_string();
+            let _ = db.execute(
+                "INSERT INTO channels (id, name, group_id, created_by) VALUES (?1, ?2, ?3, 'system')",
+                params![id, name, group_id],
+            );
+        }
+    }
+
+    // Return the review-queue channel ID
+    db.query_row(
+        "SELECT id FROM channels WHERE name = 'review-queue' AND group_id = ?1",
+        params![group_id],
+        |row| row.get(0),
+    )
+    .ok()
+}
+
+/// Count tasks in 'review' status for a group
+pub fn review_queue_count(group_id: &str) -> Result<i64, String> {
+    let db = open_db()?;
+    db.query_row(
+        "SELECT COUNT(*) FROM tasks WHERE group_id = ?1 AND status = 'review'",
+        params![group_id],
+        |row| row.get(0),
+    )
+    .map_err(|e| format!("Query error: {e}"))
+}
+
+/// Add a comment to a task
+pub fn add_comment(task_id: &str, agent_id: &str, content: &str) -> Result<String, String> {
+    let db = open_db()?;
+    let id = uuid::Uuid::new_v4().to_string();
+    db.execute(
+        "INSERT INTO task_comments (id, task_id, agent_id, content) VALUES (?1, ?2, ?3, ?4)",
+        params![id, task_id, agent_id, content],
+    )
+    .map_err(|e| format!("Insert error: {e}"))?;
+    Ok(id)
+}
+
+/// Create a new task
+pub fn create_task(
+    title: &str,
+    description: &str,
+    priority: &str,
+    group_id: &str,
+    created_by: &str,
+    assigned_to: Option<&str>,
+) -> Result<String, String> {
+    let db = open_db()?;
+    let id = uuid::Uuid::new_v4().to_string();
+    db.execute(
+        "INSERT INTO tasks (id, title, description, priority, group_id, created_by, assigned_to)
+         VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7)",
+        params![id, title, description, priority, group_id, created_by, assigned_to],
+    )
+    .map_err(|e| format!("Insert error: {e}"))?;
+    Ok(id)
+}
+
+/// Delete a task
+pub fn delete_task(task_id: &str) -> Result<(), String> {
+    let db = open_db()?;
+    db.execute("DELETE FROM task_comments WHERE task_id = ?1", params![task_id])
+        .map_err(|e| format!("Delete comments error: {e}"))?;
+    db.execute("DELETE FROM tasks WHERE id = ?1", params![task_id])
+        .map_err(|e| format!("Delete task error: {e}"))?;
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use rusqlite::Connection;
+
+    fn test_db() -> Connection {
+        let conn = Connection::open_in_memory().unwrap();
+        conn.execute_batch(
+            "CREATE TABLE tasks (
+                id TEXT PRIMARY KEY,
+                title TEXT NOT NULL,
+                description TEXT DEFAULT '',
+                status TEXT DEFAULT 'todo',
+                priority TEXT DEFAULT 'medium',
+                assigned_to TEXT,
+                created_by TEXT NOT NULL,
+                group_id TEXT NOT NULL,
+                parent_task_id TEXT,
+                sort_order INTEGER DEFAULT 0,
+                created_at TEXT DEFAULT (datetime('now')),
+                updated_at TEXT DEFAULT (datetime('now')),
+                version INTEGER DEFAULT 1
+            );
+            CREATE TABLE task_comments (
+                id TEXT PRIMARY KEY,
+                task_id TEXT NOT NULL,
+                agent_id TEXT NOT NULL,
+                content TEXT NOT NULL,
+                created_at TEXT DEFAULT (datetime('now'))
+            );
+            CREATE TABLE channels (
+                id TEXT PRIMARY KEY,
+                name TEXT NOT NULL,
+                group_id TEXT NOT NULL,
+                created_by TEXT NOT NULL,
+                created_at TEXT DEFAULT (datetime('now'))
+            );
+            CREATE TABLE channel_messages (
+                id TEXT PRIMARY KEY,
+                channel_id TEXT NOT NULL,
+                from_agent TEXT NOT NULL,
+                content TEXT NOT NULL,
+                created_at TEXT DEFAULT (datetime('now'))
+            );",
+        )
+        .unwrap();
+        conn
+    }
+
+    // ---- REGRESSION: list_tasks named column access ----
+
+    #[test]
+    fn test_list_tasks_named_column_access() {
+        let conn = test_db();
+        conn.execute(
+            "INSERT INTO tasks (id, title, description, status, priority, assigned_to, created_by, group_id, sort_order)
+             VALUES ('t1', 'Fix bug', 'Critical fix', 'progress', 'high', 'a1', 'admin', 'g1', 1)",
+            [],
+        ).unwrap();
+        conn.execute(
+            "INSERT INTO tasks (id, title, description, status, priority, assigned_to, created_by, group_id, sort_order)
+             VALUES ('t2', 'Add tests', '', 'todo', 'medium', NULL, 'a1', 'g1', 2)",
+            [],
+        ).unwrap();
+
+        let mut stmt = conn.prepare(
+            "SELECT id, title, description, status, priority, assigned_to,
+                    created_by, group_id, parent_task_id, sort_order,
+                    created_at, updated_at, version
+             FROM tasks WHERE group_id = ?1
+             ORDER BY sort_order ASC, created_at DESC",
+        ).unwrap();
+
+        let tasks: Vec<Task> = stmt.query_map(params!["g1"], |row| {
+            Ok(Task {
+                id: row.get("id")?,
+                title: row.get("title")?,
+                description: row.get::<_, String>("description").unwrap_or_default(),
+                status: row.get::<_, String>("status").unwrap_or_else(|_| "todo".into()),
+                priority: row.get::<_, String>("priority").unwrap_or_else(|_| "medium".into()),
+                assigned_to: row.get("assigned_to")?,
+                created_by: row.get("created_by")?,
+                group_id: row.get("group_id")?,
+                parent_task_id: row.get("parent_task_id")?,
+                sort_order: row.get::<_, i32>("sort_order").unwrap_or(0),
+                created_at: row.get::<_, String>("created_at").unwrap_or_default(),
+                updated_at: row.get::<_, String>("updated_at").unwrap_or_default(),
+                version: row.get::<_, i64>("version").unwrap_or(1),
+            })
+        }).unwrap().collect::<Result<Vec<_>, _>>().unwrap();
+
+        assert_eq!(tasks.len(), 2);
+        assert_eq!(tasks[0].id, "t1");
+        assert_eq!(tasks[0].title, "Fix bug");
+        assert_eq!(tasks[0].status, "progress");
+        assert_eq!(tasks[0].priority, "high");
+        assert_eq!(tasks[0].assigned_to, Some("a1".to_string()));
+        assert_eq!(tasks[0].sort_order, 1);
+
+        assert_eq!(tasks[1].id, "t2");
+        assert_eq!(tasks[1].assigned_to, None);
+        assert_eq!(tasks[1].parent_task_id, None);
+    }
+
+    // ---- REGRESSION: task_comments named column access ----
+
+    #[test]
+    fn test_task_comments_named_column_access() {
+        let conn = test_db();
+        conn.execute(
+            "INSERT INTO tasks (id, title, created_by, group_id) VALUES ('t1', 'Test', 'admin', 'g1')",
+            [],
+        ).unwrap();
+        conn.execute(
+            "INSERT INTO task_comments (id, task_id, agent_id, content) VALUES ('c1', 't1', 'a1', 'Working on it')",
+            [],
+        ).unwrap();
+        conn.execute(
+            "INSERT INTO task_comments (id, task_id, agent_id, content) VALUES ('c2', 't1', 'a2', 'Looks good')",
+            [],
+        ).unwrap();
+
+        let mut stmt = conn.prepare(
+            "SELECT id, task_id, agent_id, content, created_at
+             FROM task_comments WHERE task_id = ?1
+             ORDER BY created_at ASC",
+        ).unwrap();
+
+        let comments: Vec<TaskComment> = stmt.query_map(params!["t1"], |row| {
+            Ok(TaskComment {
+                id: row.get("id")?,
+                task_id: row.get("task_id")?,
+                agent_id: row.get("agent_id")?,
+                content: row.get("content")?,
+                created_at: row.get::<_, String>("created_at").unwrap_or_default(),
+            })
+        }).unwrap().collect::<Result<Vec<_>, _>>().unwrap();
+
+        assert_eq!(comments.len(), 2);
+        assert_eq!(comments[0].agent_id, "a1");
+        assert_eq!(comments[0].content, "Working on it");
+        assert_eq!(comments[1].agent_id, "a2");
+    }
+
+    // ---- serde camelCase serialization ----
+
+    #[test]
+    fn test_task_serializes_to_camel_case() {
+        let task = Task {
+            id: "t1".into(),
+            title: "Test".into(),
+            description: "desc".into(),
+            status: "todo".into(),
+            priority: "high".into(),
+            assigned_to: Some("a1".into()),
+            created_by: "admin".into(),
+            group_id: "g1".into(),
+            parent_task_id: None,
+            sort_order: 0,
+            created_at: "2026-01-01".into(),
+            updated_at: "2026-01-01".into(),
+            version: 1,
+        };
+
+        let json = serde_json::to_value(&task).unwrap();
+        assert!(json.get("assignedTo").is_some(), "expected camelCase 'assignedTo'");
+        assert!(json.get("createdBy").is_some(), "expected camelCase 'createdBy'");
+        assert!(json.get("groupId").is_some(), "expected camelCase 'groupId'");
+        assert!(json.get("parentTaskId").is_some(), "expected camelCase 'parentTaskId'");
+        assert!(json.get("sortOrder").is_some(), "expected camelCase 'sortOrder'");
+        assert!(json.get("createdAt").is_some(), "expected camelCase 'createdAt'");
+        assert!(json.get("updatedAt").is_some(), "expected camelCase 'updatedAt'");
+        // Ensure no snake_case leaks
+        assert!(json.get("assigned_to").is_none());
+        assert!(json.get("created_by").is_none());
+        assert!(json.get("group_id").is_none());
+    }
+
+    #[test]
+    fn test_task_comment_serializes_to_camel_case() {
+        let comment = TaskComment {
+            id: "c1".into(),
+            task_id: "t1".into(),
+            agent_id: "a1".into(),
+            content: "note".into(),
+            created_at: "2026-01-01".into(),
+        };
+
+        let json = serde_json::to_value(&comment).unwrap();
+        assert!(json.get("taskId").is_some(), "expected camelCase 'taskId'");
+        assert!(json.get("agentId").is_some(), "expected camelCase 'agentId'");
+        assert!(json.get("createdAt").is_some(), "expected camelCase 'createdAt'");
+        assert!(json.get("task_id").is_none());
+    }
+
+    // ---- update_task_status validation ----
+
+    #[test]
+    fn test_update_task_status_rejects_invalid() {
+        // Can't call update_task_status directly (uses open_db), but we can test the validation logic
+        let valid = ["todo", "progress", "review", "done", "blocked"];
+        assert!(valid.contains(&"todo"));
+        assert!(valid.contains(&"done"));
+        assert!(!valid.contains(&"invalid"));
+        assert!(!valid.contains(&"cancelled"));
+    }
+
+    // ---- Review channel auto-creation ----
+
+    #[test]
+    fn test_ensure_review_channels_creates_both() {
+        let conn = test_db();
+        let result = ensure_review_channels(&conn, "g1");
+        assert!(result.is_some(), "should return review-queue channel ID");
+
+        // Verify both channels exist
+        let queue_count: i64 = conn
+            .query_row(
+                "SELECT COUNT(*) FROM channels WHERE name = 'review-queue' AND group_id = 'g1'",
+                [],
+                |row| row.get(0),
+            )
+            .unwrap();
+        assert_eq!(queue_count, 1);
+
+        let log_count: i64 = conn
+            .query_row(
+                "SELECT COUNT(*) FROM channels WHERE name = 'review-log' AND group_id = 'g1'",
+                [],
+                |row| row.get(0),
+            )
+            .unwrap();
+        assert_eq!(log_count, 1);
+    }
+
+    #[test]
+    fn test_ensure_review_channels_idempotent() {
+        let conn = test_db();
+        let id1 = ensure_review_channels(&conn, "g1").unwrap();
+        let id2 = ensure_review_channels(&conn, "g1").unwrap();
+        assert_eq!(id1, id2, "should return same channel ID on repeated calls");
+
+        // Verify no duplicates
+        let count: i64 = conn
+            .query_row(
+                "SELECT COUNT(*) FROM channels WHERE name = 'review-queue' AND group_id = 'g1'",
+                [],
+                |row| row.get(0),
+            )
+            .unwrap();
+        assert_eq!(count, 1);
+    }
+
+    #[test]
+    fn test_notify_review_channel_posts_message() {
+        let conn = test_db();
+        // Insert a task
+        conn.execute(
+            "INSERT INTO tasks (id, title, created_by, group_id) VALUES ('t1', 'Fix login bug', 'admin', 'g1')",
+            [],
+        ).unwrap();
+
+        // Trigger notification (should auto-create channel)
+        notify_review_channel(&conn, "g1", "t1", "Fix login bug");
+
+        // Verify message was posted
+        let msg_count: i64 = conn
+            .query_row(
+                "SELECT COUNT(*) FROM channel_messages cm
+                 JOIN channels c ON cm.channel_id = c.id
+                 WHERE c.name = 'review-queue' AND c.group_id = 'g1'",
+                [],
+                |row| row.get(0),
+            )
+            .unwrap();
+        assert_eq!(msg_count, 1);
+
+        // Verify message content
+        let content: String = conn
+            .query_row(
+                "SELECT cm.content FROM channel_messages cm
+                 JOIN channels c ON cm.channel_id = c.id
+                 WHERE c.name = 'review-queue'",
+                [],
+                |row| row.get(0),
+            )
+            .unwrap();
+        assert!(content.contains("Fix login bug"));
+        assert!(content.contains("t1"));
+    }
+
+    // ---- Review queue count ----
+
+    #[test]
+    fn test_review_queue_count_via_sql() {
+        let conn = test_db();
+        // Insert tasks with various statuses
+        conn.execute(
+            "INSERT INTO tasks (id, title, status, created_by, group_id) VALUES ('t1', 'A', 'review', 'admin', 'g1')",
+            [],
+        ).unwrap();
+        conn.execute(
+            "INSERT INTO tasks (id, title, status, created_by, group_id) VALUES ('t2', 'B', 'review', 'admin', 'g1')",
+            [],
+        ).unwrap();
+        conn.execute(
+            "INSERT INTO tasks (id, title, status, created_by, group_id) VALUES ('t3', 'C', 'progress', 'admin', 'g1')",
+            [],
+        ).unwrap();
+        conn.execute(
+            "INSERT INTO tasks (id, title, status, created_by, group_id) VALUES ('t4', 'D', 'review', 'admin', 'g2')",
+            [],
+        ).unwrap();
+
+        // Count review tasks for g1
+        let count: i64 = conn
+            .query_row(
+                "SELECT COUNT(*) FROM tasks WHERE group_id = ?1 AND status = 'review'",
+                params!["g1"],
+                |row| row.get(0),
+            )
+            .unwrap();
+        assert_eq!(count, 2, "should count only review tasks in g1");
+
+        // Count review tasks for g2
+        let count_g2: i64 = conn
+            .query_row(
+                "SELECT COUNT(*) FROM tasks WHERE group_id = ?1 AND status = 'review'",
+                params!["g2"],
+                |row| row.get(0),
+            )
+            .unwrap();
+        assert_eq!(count_g2, 1, "should count only review tasks in g2");
+    }
+
+    // ---- Optimistic locking (version column) ----
+
+    #[test]
+    fn test_version_column_defaults_to_1() {
+        let conn = test_db();
+        conn.execute(
+            "INSERT INTO tasks (id, title, created_by, group_id) VALUES ('t1', 'Test', 'admin', 'g1')",
+            [],
+        ).unwrap();
+
+        let version: i64 = conn
+            .query_row("SELECT version FROM tasks WHERE id = 't1'", [], |row| row.get(0))
+            .unwrap();
+        assert_eq!(version, 1);
+    }
+
+    #[test]
+    fn test_optimistic_lock_success() {
+        let conn = test_db();
+        conn.execute(
+            "INSERT INTO tasks (id, title, status, created_by, group_id) VALUES ('t1', 'Test', 'todo', 'admin', 'g1')",
+            [],
+        ).unwrap();
+
+        // Update with correct version (1)
+        let rows = conn.execute(
+            "UPDATE tasks SET status = 'progress', version = version + 1, updated_at = datetime('now')
+             WHERE id = 't1' AND version = 1",
+            [],
+        ).unwrap();
+        assert_eq!(rows, 1, "should affect 1 row");
+
+        let new_version: i64 = conn
+            .query_row("SELECT version FROM tasks WHERE id = 't1'", [], |row| row.get(0))
+            .unwrap();
+        assert_eq!(new_version, 2);
+    }
+
+    #[test]
+    fn test_optimistic_lock_conflict() {
+        let conn = test_db();
+        conn.execute(
+            "INSERT INTO tasks (id, title, status, created_by, group_id) VALUES ('t1', 'Test', 'todo', 'admin', 'g1')",
+            [],
+        ).unwrap();
+
+        // First update succeeds
+        conn.execute(
+            "UPDATE tasks SET status = 'progress', version = version + 1, updated_at = datetime('now')
+             WHERE id = 't1' AND version = 1",
+            [],
+        ).unwrap();
+
+        // Second update with stale version (1) should affect 0 rows
+        let rows = conn.execute(
+            "UPDATE tasks SET status = 'review', version = version + 1, updated_at = datetime('now')
+             WHERE id = 't1' AND version = 1",
+            [],
+        ).unwrap();
+        assert_eq!(rows, 0, "stale version should affect 0 rows");
+
+        // Task should still be in 'progress' state
+        let status: String = conn
+            .query_row("SELECT status FROM tasks WHERE id = 't1'", [], |row| row.get(0))
+            .unwrap();
+        assert_eq!(status, "progress");
+    }
+
+    #[test]
+    fn test_version_in_list_tasks_query() {
+        let conn = test_db();
+        conn.execute(
+            "INSERT INTO tasks (id, title, created_by, group_id, sort_order) VALUES ('t1', 'V1', 'admin', 'g1', 1)",
+            [],
+        ).unwrap();
+        // Bump version to 3
+        conn.execute("UPDATE tasks SET version = 3 WHERE id = 't1'", []).unwrap();
+
+        let mut stmt = conn.prepare(
+            "SELECT id, title, description, status, priority, assigned_to,
+                    created_by, group_id, parent_task_id, sort_order,
+                    created_at, updated_at, version
+             FROM tasks WHERE group_id = ?1",
+        ).unwrap();
+
+        let tasks: Vec<Task> = stmt.query_map(params!["g1"], |row| {
+            Ok(Task {
+                id: row.get("id")?,
+                title: row.get("title")?,
+                description: row.get::<_, String>("description").unwrap_or_default(),
+                status: row.get::<_, String>("status").unwrap_or_else(|_| "todo".into()),
+                priority: row.get::<_, String>("priority").unwrap_or_else(|_| "medium".into()),
+                assigned_to: row.get("assigned_to")?,
+                created_by: row.get("created_by")?,
+                group_id: row.get("group_id")?,
+                parent_task_id: row.get("parent_task_id")?,
+                sort_order: row.get::<_, i32>("sort_order").unwrap_or(0),
+                created_at: row.get::<_, String>("created_at").unwrap_or_default(),
+                updated_at: row.get::<_, String>("updated_at").unwrap_or_default(),
+                version: row.get::<_, i64>("version").unwrap_or(1),
+            })
+        }).unwrap().collect::<Result<Vec<_>, _>>().unwrap();
+
+        assert_eq!(tasks.len(), 1);
+        assert_eq!(tasks[0].version, 3);
+    }
+
+    #[test]
+    fn test_version_serializes_to_camel_case() {
+        let task = Task {
+            id: "t1".into(),
+            title: "Test".into(),
+            description: "".into(),
+            status: "todo".into(),
+            priority: "medium".into(),
+            assigned_to: None,
+            created_by: "admin".into(),
+            group_id: "g1".into(),
+            parent_task_id: None,
+            sort_order: 0,
+            created_at: "2026-01-01".into(),
+            updated_at: "2026-01-01".into(),
+            version: 5,
+        };
+
+        let json = serde_json::to_value(&task).unwrap();
+        assert_eq!(json.get("version").unwrap(), 5);
+    }
+}
diff --git a/v2/src-tauri/src/commands/agent.rs b/v2/src-tauri/src/commands/agent.rs
new file mode 100644
index 0000000..6e17f97
--- /dev/null
+++ b/v2/src-tauri/src/commands/agent.rs
@@ -0,0 +1,58 @@
+use tauri::State;
+use crate::AppState;
+use crate::sidecar::AgentQueryOptions;
+use bterminal_core::sandbox::SandboxConfig;
+
+#[tauri::command]
+#[tracing::instrument(skip(state, options), fields(session_id = %options.session_id))]
+pub fn agent_query(
+    state: State<'_, AppState>,
+    options: AgentQueryOptions,
+) -> Result<(), String> {
+    state.sidecar_manager.query(&options)
+}
+
+#[tauri::command]
+#[tracing::instrument(skip(state))]
+pub fn agent_stop(state: State<'_, AppState>, session_id: String) -> Result<(), String> {
+    state.sidecar_manager.stop_session(&session_id)
+}
+
+#[tauri::command]
+pub fn agent_ready(state: State<'_, AppState>) -> bool {
+    state.sidecar_manager.is_ready()
+}
+
+#[tauri::command]
+#[tracing::instrument(skip(state))]
+pub fn agent_restart(state: State<'_, AppState>) -> Result<(), String> {
+    state.sidecar_manager.restart()
+}
+
+/// Update sidecar sandbox configuration and restart to apply.
+/// `project_cwds` — directories needing read+write access.
+/// `worktree_roots` — optional worktree directories.
+/// `enabled` — whether Landlock sandboxing is active.
+#[tauri::command]
+#[tracing::instrument(skip(state))]
+pub fn agent_set_sandbox(
+    state: State<'_, AppState>,
+    project_cwds: Vec<String>,
+    worktree_roots: Vec<String>,
+    enabled: bool,
+) -> Result<(), String> {
+    let cwd_refs: Vec<&str> = project_cwds.iter().map(|s| s.as_str()).collect();
+    let wt_refs: Vec<&str> = worktree_roots.iter().map(|s| s.as_str()).collect();
+
+    let mut sandbox = SandboxConfig::for_projects(&cwd_refs, &wt_refs);
+    sandbox.enabled = enabled;
+
+    state.sidecar_manager.set_sandbox(sandbox);
+
+    // Restart sidecar so Landlock restrictions take effect on the new process
+    if state.sidecar_manager.is_ready() {
+        state.sidecar_manager.restart()?;
+    }
+
+    Ok(())
+}
diff --git a/v2/src-tauri/src/commands/btmsg.rs b/v2/src-tauri/src/commands/btmsg.rs
new file mode 100644
index 0000000..978535d
--- /dev/null
+++ b/v2/src-tauri/src/commands/btmsg.rs
@@ -0,0 +1,120 @@
+use crate::btmsg;
+use crate::groups;
+
+#[tauri::command]
+pub fn btmsg_get_agents(group_id: String) -> Result<Vec<btmsg::BtmsgAgent>, String> {
+    btmsg::get_agents(&group_id)
+}
+
+#[tauri::command]
+pub fn btmsg_unread_count(agent_id: String) -> Result<i32, String> {
+    btmsg::unread_count(&agent_id)
+}
+
+#[tauri::command]
+pub fn btmsg_unread_messages(agent_id: String) -> Result<Vec<btmsg::BtmsgMessage>, String> {
+    btmsg::unread_messages(&agent_id)
+}
+
+#[tauri::command]
+pub fn btmsg_history(agent_id: String, other_id: String, limit: i32) -> Result<Vec<btmsg::BtmsgMessage>, String> {
+    btmsg::history(&agent_id, &other_id, limit)
+}
+
+#[tauri::command]
+pub fn btmsg_send(from_agent: String, to_agent: String, content: String) -> Result<String, String> {
+    btmsg::send_message(&from_agent, &to_agent, &content)
+}
+
+#[tauri::command]
+pub fn btmsg_set_status(agent_id: String, status: String) -> Result<(), String> {
+    btmsg::set_status(&agent_id, &status)
+}
+
+#[tauri::command]
+pub fn btmsg_ensure_admin(group_id: String) -> Result<(), String> {
+    btmsg::ensure_admin(&group_id)
+}
+
+#[tauri::command]
+pub fn btmsg_all_feed(group_id: String, limit: i32) -> Result<Vec<btmsg::BtmsgFeedMessage>, String> {
+    btmsg::all_feed(&group_id, limit)
+}
+
+#[tauri::command]
+pub fn btmsg_mark_read(reader_id: String, sender_id: String) -> Result<(), String> {
+    btmsg::mark_read_conversation(&reader_id, &sender_id)
+}
+
+#[tauri::command]
+pub fn btmsg_get_channels(group_id: String) -> Result<Vec<btmsg::BtmsgChannel>, String> {
+    btmsg::get_channels(&group_id)
+}
+
+#[tauri::command]
+pub fn btmsg_channel_messages(channel_id: String, limit: i32) -> Result<Vec<btmsg::BtmsgChannelMessage>, String> {
+    btmsg::get_channel_messages(&channel_id, limit)
+}
+
+#[tauri::command]
+pub fn btmsg_channel_send(channel_id: String, from_agent: String, content: String) -> Result<String, String> {
+    btmsg::send_channel_message(&channel_id, &from_agent, &content)
+}
+
+#[tauri::command]
+pub fn btmsg_create_channel(name: String, group_id: String, created_by: String) -> Result<String, String> {
+    btmsg::create_channel(&name, &group_id, &created_by)
+}
+
+#[tauri::command]
+pub fn btmsg_add_channel_member(channel_id: String, agent_id: String) -> Result<(), String> {
+    btmsg::add_channel_member(&channel_id, &agent_id)
+}
+
+/// Register all agents from a GroupsFile into the btmsg database.
+/// Creates/updates agent records, sets up contact permissions, ensures review channels.
+#[tauri::command]
+pub fn btmsg_register_agents(config: groups::GroupsFile) -> Result<(), String> {
+    btmsg::register_agents_from_groups(&config)
+}
+
+// ---- Heartbeat monitoring ----
+
+#[tauri::command]
+pub fn btmsg_record_heartbeat(agent_id: String) -> Result<(), String> {
+    btmsg::record_heartbeat(&agent_id)
+}
+
+#[tauri::command]
+pub fn btmsg_get_stale_agents(group_id: String, threshold_secs: i64) -> Result<Vec<String>, String> {
+    btmsg::get_stale_agents(&group_id, threshold_secs)
+}
+
+// ---- Dead letter queue ----
+
+#[tauri::command]
+pub fn btmsg_get_dead_letters(group_id: String, limit: i32) -> Result<Vec<btmsg::DeadLetter>, String> {
+    btmsg::get_dead_letters(&group_id, limit)
+}
+
+#[tauri::command]
+pub fn btmsg_clear_dead_letters(group_id: String) -> Result<(), String> {
+    btmsg::clear_dead_letters(&group_id)
+}
+
+// ---- Audit log ----
+
+#[tauri::command]
+pub fn audit_log_event(agent_id: String, event_type: String, detail: String) -> Result<(), String> {
+    btmsg::log_audit_event(&agent_id, &event_type, &detail)
+}
+
+#[tauri::command]
+pub fn audit_log_list(group_id: String, limit: i32, offset: i32) -> Result<Vec<btmsg::AuditEntry>, String> {
+    btmsg::get_audit_log(&group_id, limit, offset)
+}
+
+#[tauri::command]
+pub fn audit_log_for_agent(agent_id: String, limit: i32) -> Result<Vec<btmsg::AuditEntry>, String> {
+    btmsg::get_audit_log_for_agent(&agent_id, limit)
+}
diff --git a/v2/src-tauri/src/commands/bttask.rs b/v2/src-tauri/src/commands/bttask.rs
new file mode 100644
index 0000000..b64b574
--- /dev/null
+++ b/v2/src-tauri/src/commands/bttask.rs
@@ -0,0 +1,43 @@
+use crate::bttask;
+
+#[tauri::command]
+pub fn bttask_list(group_id: String) -> Result<Vec<bttask::Task>, String> {
+    bttask::list_tasks(&group_id)
+}
+
+#[tauri::command]
+pub fn bttask_comments(task_id: String) -> Result<Vec<bttask::TaskComment>, String> {
+    bttask::task_comments(&task_id)
+}
+
+#[tauri::command]
+pub fn bttask_update_status(task_id: String, status: String, version: i64) -> Result<i64, String> {
+    bttask::update_task_status(&task_id, &status, version)
+}
+
+#[tauri::command]
+pub fn bttask_add_comment(task_id: String, agent_id: String, content: String) -> Result<String, String> {
+    bttask::add_comment(&task_id, &agent_id, &content)
+}
+
+#[tauri::command]
+pub fn bttask_create(
+    title: String,
+    description: String,
+    priority: String,
+    group_id: String,
+    created_by: String,
+    assigned_to: Option<String>,
+) -> Result<String, String> {
+    bttask::create_task(&title, &description, &priority, &group_id, &created_by, assigned_to.as_deref())
+}
+
+#[tauri::command]
+pub fn bttask_delete(task_id: String) -> Result<(), String> {
+    bttask::delete_task(&task_id)
+}
+
+#[tauri::command]
+pub fn bttask_review_queue_count(group_id: String) -> Result<i64, String> {
+    bttask::review_queue_count(&group_id)
+}
diff --git a/v2/src-tauri/src/commands/claude.rs b/v2/src-tauri/src/commands/claude.rs
new file mode 100644
index 0000000..f6ece52
--- /dev/null
+++ b/v2/src-tauri/src/commands/claude.rs
@@ -0,0 +1,158 @@
+// Claude profile and skill discovery commands
+
+#[derive(serde::Serialize)]
+pub struct ClaudeProfile {
+    pub name: String,
+    pub email: Option<String>,
+    pub subscription_type: Option<String>,
+    pub display_name: Option<String>,
+    pub config_dir: String,
+}
+
+#[derive(serde::Serialize)]
+pub struct ClaudeSkill {
+    pub name: String,
+    pub description: String,
+    pub source_path: String,
+}
+
+#[tauri::command]
+pub fn claude_list_profiles() -> Vec<ClaudeProfile> {
+    let mut profiles = Vec::new();
+
+    let config_dir = dirs::config_dir().unwrap_or_default();
+    let profiles_dir = config_dir.join("switcher").join("profiles");
+    let alt_dir_root = config_dir.join("switcher-claude");
+
+    if let Ok(entries) = std::fs::read_dir(&profiles_dir) {
+        for entry in entries.flatten() {
+            if !entry.path().is_dir() { continue; }
+            let name = entry.file_name().to_string_lossy().to_string();
+
+            let toml_path = entry.path().join("profile.toml");
+            let (email, subscription_type, display_name) = if toml_path.exists() {
+                let content = std::fs::read_to_string(&toml_path).unwrap_or_else(|e| {
+                    log::warn!("Failed to read {}: {e}", toml_path.display());
+                    String::new()
+                });
+                (
+                    extract_toml_value(&content, "email"),
+                    extract_toml_value(&content, "subscription_type"),
+                    extract_toml_value(&content, "display_name"),
+                )
+            } else {
+                (None, None, None)
+            };
+
+            let alt_path = alt_dir_root.join(&name);
+            let config_dir_str = if alt_path.exists() {
+                alt_path.to_string_lossy().to_string()
+            } else {
+                dirs::home_dir()
+                    .unwrap_or_default()
+                    .join(".claude")
+                    .to_string_lossy()
+                    .to_string()
+            };
+
+            profiles.push(ClaudeProfile {
+                name,
+                email,
+                subscription_type,
+                display_name,
+                config_dir: config_dir_str,
+            });
+        }
+    }
+
+    if profiles.is_empty() {
+        let home = dirs::home_dir().unwrap_or_default();
+        profiles.push(ClaudeProfile {
+            name: "default".to_string(),
+            email: None,
+            subscription_type: None,
+            display_name: None,
+            config_dir: home.join(".claude").to_string_lossy().to_string(),
+        });
+    }
+
+    profiles
+}
+
+fn extract_toml_value(content: &str, key: &str) -> Option<String> {
+    for line in content.lines() {
+        let trimmed = line.trim();
+        if let Some(rest) = trimmed.strip_prefix(key) {
+            if let Some(rest) = rest.trim().strip_prefix('=') {
+                let val = rest.trim().trim_matches('"');
+                if !val.is_empty() {
+                    return Some(val.to_string());
+                }
+            }
+        }
+    }
+    None
+}
+
+#[tauri::command]
+pub fn claude_list_skills() -> Vec<ClaudeSkill> {
+    let mut skills = Vec::new();
+    let home = dirs::home_dir().unwrap_or_default();
+
+    let skills_dir = home.join(".claude").join("skills");
+    if let Ok(entries) = std::fs::read_dir(&skills_dir) {
+        for entry in entries.flatten() {
+            let path = entry.path();
+            let (name, skill_file) = if path.is_dir() {
+                let skill_md = path.join("SKILL.md");
+                if skill_md.exists() {
+                    (entry.file_name().to_string_lossy().to_string(), skill_md)
+                } else {
+                    continue;
+                }
+            } else if path.extension().map_or(false, |e| e == "md") {
+                let stem = path.file_stem().unwrap_or_default().to_string_lossy().to_string();
+                (stem, path.clone())
+            } else {
+                continue;
+            };
+
+            let description = if let Ok(content) = std::fs::read_to_string(&skill_file) {
+                content.lines()
+                    .filter(|l| !l.trim().is_empty() && !l.starts_with('#'))
+                    .next()
+                    .unwrap_or("")
+                    .trim()
+                    .chars()
+                    .take(120)
+                    .collect()
+            } else {
+                String::new()
+            };
+
+            skills.push(ClaudeSkill {
+                name,
+                description,
+                source_path: skill_file.to_string_lossy().to_string(),
+            });
+        }
+    }
+
+    skills
+}
+
+#[tauri::command]
+pub fn claude_read_skill(path: String) -> Result<String, String> {
+    let skills_dir = dirs::home_dir()
+        .ok_or("Cannot determine home directory")?
+        .join(".claude")
+        .join("skills");
+    let canonical_skills = skills_dir.canonicalize()
+        .map_err(|_| "Skills directory does not exist".to_string())?;
+    let canonical_path = std::path::Path::new(&path).canonicalize()
+        .map_err(|e| format!("Invalid skill path: {e}"))?;
+    if !canonical_path.starts_with(&canonical_skills) {
+        return Err("Access denied: path is outside skills directory".to_string());
+    }
+    std::fs::read_to_string(&canonical_path).map_err(|e| format!("Failed to read skill: {e}"))
+}
diff --git a/v2/src-tauri/src/commands/files.rs b/v2/src-tauri/src/commands/files.rs
new file mode 100644
index 0000000..157526d
--- /dev/null
+++ b/v2/src-tauri/src/commands/files.rs
@@ -0,0 +1,130 @@
+// File browser commands (Files tab)
+
+#[derive(serde::Serialize)]
+pub struct DirEntry {
+    pub name: String,
+    pub path: String,
+    pub is_dir: bool,
+    pub size: u64,
+    pub ext: String,
+}
+
+/// Content types for file viewer routing
+#[derive(serde::Serialize)]
+#[serde(tag = "type")]
+pub enum FileContent {
+    Text { content: String, lang: String },
+    Binary { message: String },
+    TooLarge { size: u64 },
+}
+
+#[tauri::command]
+pub fn list_directory_children(path: String) -> Result<Vec<DirEntry>, String> {
+    let dir = std::path::Path::new(&path);
+    if !dir.is_dir() {
+        return Err(format!("Not a directory: {path}"));
+    }
+    let mut entries = Vec::new();
+    let read_dir = std::fs::read_dir(dir).map_err(|e| format!("Failed to read directory: {e}"))?;
+    for entry in read_dir {
+        let entry = entry.map_err(|e| format!("Failed to read entry: {e}"))?;
+        let metadata = entry.metadata().map_err(|e| format!("Failed to read metadata: {e}"))?;
+        let name = entry.file_name().to_string_lossy().into_owned();
+        if name.starts_with('.') {
+            continue;
+        }
+        let is_dir = metadata.is_dir();
+        let ext = if is_dir {
+            String::new()
+        } else {
+            std::path::Path::new(&name)
+                .extension()
+                .map(|e| e.to_string_lossy().to_lowercase())
+                .unwrap_or_default()
+        };
+        entries.push(DirEntry {
+            name,
+            path: entry.path().to_string_lossy().into_owned(),
+            is_dir,
+            size: metadata.len(),
+            ext,
+        });
+    }
+    entries.sort_by(|a, b| {
+        b.is_dir.cmp(&a.is_dir).then_with(|| a.name.to_lowercase().cmp(&b.name.to_lowercase()))
+    });
+    Ok(entries)
+}
+
+#[tauri::command]
+pub fn read_file_content(path: String) -> Result<FileContent, String> {
+    let file_path = std::path::Path::new(&path);
+    if !file_path.is_file() {
+        return Err(format!("Not a file: {path}"));
+    }
+    let metadata = std::fs::metadata(&path).map_err(|e| format!("Failed to read metadata: {e}"))?;
+    let size = metadata.len();
+
+    if size > 10 * 1024 * 1024 {
+        return Ok(FileContent::TooLarge { size });
+    }
+
+    let ext = file_path
+        .extension()
+        .map(|e| e.to_string_lossy().to_lowercase())
+        .unwrap_or_default();
+
+    let binary_exts = ["png", "jpg", "jpeg", "gif", "webp", "svg", "ico", "bmp",
+                       "pdf", "zip", "tar", "gz", "7z", "rar",
+                       "mp3", "mp4", "wav", "ogg", "webm", "avi",
+                       "woff", "woff2", "ttf", "otf", "eot",
+                       "exe", "dll", "so", "dylib", "wasm"];
+    if binary_exts.contains(&ext.as_str()) {
+        return Ok(FileContent::Binary { message: format!("Binary file ({ext}), {size} bytes") });
+    }
+
+    let content = std::fs::read_to_string(&path)
+        .map_err(|_| format!("Binary or non-UTF-8 file"))?;
+
+    let lang = match ext.as_str() {
+        "rs" => "rust",
+        "ts" | "tsx" => "typescript",
+        "js" | "jsx" | "mjs" | "cjs" => "javascript",
+        "py" => "python",
+        "svelte" => "svelte",
+        "html" | "htm" => "html",
+        "css" | "scss" | "less" => "css",
+        "json" => "json",
+        "toml" => "toml",
+        "yaml" | "yml" => "yaml",
+        "md" | "markdown" => "markdown",
+        "sh" | "bash" | "zsh" => "bash",
+        "sql" => "sql",
+        "xml" => "xml",
+        "csv" => "csv",
+        "dockerfile" => "dockerfile",
+        "lock" => "text",
+        _ => "text",
+    }.to_string();
+
+    Ok(FileContent::Text { content, lang })
+}
+
+#[tauri::command]
+pub fn write_file_content(path: String, content: String) -> Result<(), String> {
+    let file_path = std::path::Path::new(&path);
+    if !file_path.is_file() {
+        return Err(format!("Not an existing file: {path}"));
+    }
+    std::fs::write(&path, content.as_bytes())
+        .map_err(|e| format!("Failed to write file: {e}"))
+}
+
+#[tauri::command]
+pub async fn pick_directory(window: tauri::Window) -> Result<Option<String>, String> {
+    let dialog = rfd::AsyncFileDialog::new()
+        .set_title("Select Directory")
+        .set_parent(&window);
+    let folder = dialog.pick_folder().await;
+    Ok(folder.map(|f| f.path().to_string_lossy().into_owned()))
+}
diff --git a/v2/src-tauri/src/commands/groups.rs b/v2/src-tauri/src/commands/groups.rs
new file mode 100644
index 0000000..b05185a
--- /dev/null
+++ b/v2/src-tauri/src/commands/groups.rs
@@ -0,0 +1,16 @@
+use crate::groups::{GroupsFile, MdFileEntry};
+
+#[tauri::command]
+pub fn groups_load() -> Result<GroupsFile, String> {
+    crate::groups::load_groups()
+}
+
+#[tauri::command]
+pub fn groups_save(config: GroupsFile) -> Result<(), String> {
+    crate::groups::save_groups(&config)
+}
+
+#[tauri::command]
+pub fn discover_markdown_files(cwd: String) -> Result<Vec<MdFileEntry>, String> {
+    crate::groups::discover_markdown_files(&cwd)
+}
diff --git a/v2/src-tauri/src/commands/knowledge.rs b/v2/src-tauri/src/commands/knowledge.rs
new file mode 100644
index 0000000..f0e1296
--- /dev/null
+++ b/v2/src-tauri/src/commands/knowledge.rs
@@ -0,0 +1,67 @@
+use tauri::State;
+use crate::AppState;
+use crate::{ctx, memora};
+
+// --- ctx commands ---
+
+#[tauri::command]
+pub fn ctx_init_db(state: State<'_, AppState>) -> Result<(), String> {
+    state.ctx_db.init_db()
+}
+
+#[tauri::command]
+pub fn ctx_register_project(state: State<'_, AppState>, name: String, description: String, work_dir: Option<String>) -> Result<(), String> {
+    state.ctx_db.register_project(&name, &description, work_dir.as_deref())
+}
+
+#[tauri::command]
+pub fn ctx_get_context(state: State<'_, AppState>, project: String) -> Result<Vec<ctx::CtxEntry>, String> {
+    state.ctx_db.get_context(&project)
+}
+
+#[tauri::command]
+pub fn ctx_get_shared(state: State<'_, AppState>) -> Result<Vec<ctx::CtxEntry>, String> {
+    state.ctx_db.get_shared()
+}
+
+#[tauri::command]
+pub fn ctx_get_summaries(state: State<'_, AppState>, project: String, limit: i64) -> Result<Vec<ctx::CtxSummary>, String> {
+    state.ctx_db.get_summaries(&project, limit)
+}
+
+#[tauri::command]
+pub fn ctx_search(state: State<'_, AppState>, query: String) -> Result<Vec<ctx::CtxEntry>, String> {
+    state.ctx_db.search(&query)
+}
+
+// --- Memora commands (read-only) ---
+
+#[tauri::command]
+pub fn memora_available(state: State<'_, AppState>) -> bool {
+    state.memora_db.is_available()
+}
+
+#[tauri::command]
+pub fn memora_list(
+    state: State<'_, AppState>,
+    tags: Option<Vec<String>>,
+    limit: Option<i64>,
+    offset: Option<i64>,
+) -> Result<memora::MemoraSearchResult, String> {
+    state.memora_db.list(tags, limit.unwrap_or(50), offset.unwrap_or(0))
+}
+
+#[tauri::command]
+pub fn memora_search(
+    state: State<'_, AppState>,
+    query: String,
+    tags: Option<Vec<String>>,
+    limit: Option<i64>,
+) -> Result<memora::MemoraSearchResult, String> {
+    state.memora_db.search(&query, tags, limit.unwrap_or(50))
+}
+
+#[tauri::command]
+pub fn memora_get(state: State<'_, AppState>, id: i64) -> Result<Option<memora::MemoraNode>, String> {
+    state.memora_db.get(id)
+}
diff --git a/v2/src-tauri/src/commands/misc.rs b/v2/src-tauri/src/commands/misc.rs
new file mode 100644
index 0000000..85dab07
--- /dev/null
+++ b/v2/src-tauri/src/commands/misc.rs
@@ -0,0 +1,46 @@
+// Miscellaneous commands — CLI args, URL opening, frontend telemetry
+
+#[tauri::command]
+pub fn cli_get_group() -> Option<String> {
+    let args: Vec<String> = std::env::args().collect();
+    let mut i = 1;
+    while i < args.len() {
+        if args[i] == "--group" {
+            if i + 1 < args.len() {
+                return Some(args[i + 1].clone());
+            }
+        } else if let Some(val) = args[i].strip_prefix("--group=") {
+            return Some(val.to_string());
+        }
+        i += 1;
+    }
+    None
+}
+
+#[tauri::command]
+pub fn open_url(url: String) -> Result<(), String> {
+    if !url.starts_with("http://") && !url.starts_with("https://") {
+        return Err("Only http/https URLs are allowed".into());
+    }
+    std::process::Command::new("xdg-open")
+        .arg(&url)
+        .spawn()
+        .map_err(|e| format!("Failed to open URL: {e}"))?;
+    Ok(())
+}
+
+#[tauri::command]
+pub fn is_test_mode() -> bool {
+    std::env::var("BTERMINAL_TEST").map_or(false, |v| v == "1")
+}
+
+#[tauri::command]
+pub fn frontend_log(level: String, message: String, context: Option<serde_json::Value>) {
+    match level.as_str() {
+        "error" => tracing::error!(source = "frontend", ?context, "{message}"),
+        "warn" => tracing::warn!(source = "frontend", ?context, "{message}"),
+        "info" => tracing::info!(source = "frontend", ?context, "{message}"),
+        "debug" => tracing::debug!(source = "frontend", ?context, "{message}"),
+        _ => tracing::trace!(source = "frontend", ?context, "{message}"),
+    }
+}
diff --git a/v2/src-tauri/src/commands/mod.rs b/v2/src-tauri/src/commands/mod.rs
new file mode 100644
index 0000000..27c796c
--- /dev/null
+++ b/v2/src-tauri/src/commands/mod.rs
@@ -0,0 +1,17 @@
+pub mod pty;
+pub mod agent;
+pub mod watcher;
+pub mod session;
+pub mod persistence;
+pub mod knowledge;
+pub mod claude;
+pub mod groups;
+pub mod files;
+pub mod remote;
+pub mod misc;
+pub mod btmsg;
+pub mod bttask;
+pub mod notifications;
+pub mod search;
+pub mod plugins;
+pub mod secrets;
diff --git a/v2/src-tauri/src/commands/notifications.rs b/v2/src-tauri/src/commands/notifications.rs
new file mode 100644
index 0000000..0e7173f
--- /dev/null
+++ b/v2/src-tauri/src/commands/notifications.rs
@@ -0,0 +1,8 @@
+// Notification commands — desktop notification via notify-rust
+
+use crate::notifications;
+
+#[tauri::command]
+pub fn notify_desktop(title: String, body: String, urgency: String) -> Result<(), String> {
+    notifications::send_desktop_notification(&title, &body, &urgency)
+}
diff --git a/v2/src-tauri/src/commands/persistence.rs b/v2/src-tauri/src/commands/persistence.rs
new file mode 100644
index 0000000..c8c5c39
--- /dev/null
+++ b/v2/src-tauri/src/commands/persistence.rs
@@ -0,0 +1,109 @@
+use tauri::State;
+use crate::AppState;
+use crate::session::{AgentMessageRecord, ProjectAgentState, SessionMetric, SessionAnchorRecord};
+
+// --- Agent message persistence ---
+
+#[tauri::command]
+pub fn agent_messages_save(
+    state: State<'_, AppState>,
+    session_id: String,
+    project_id: String,
+    sdk_session_id: Option<String>,
+    messages: Vec<AgentMessageRecord>,
+) -> Result<(), String> {
+    state.session_db.save_agent_messages(
+        &session_id,
+        &project_id,
+        sdk_session_id.as_deref(),
+        &messages,
+    )
+}
+
+#[tauri::command]
+pub fn agent_messages_load(
+    state: State<'_, AppState>,
+    project_id: String,
+) -> Result<Vec<AgentMessageRecord>, String> {
+    state.session_db.load_agent_messages(&project_id)
+}
+
+// --- Project agent state ---
+
+#[tauri::command]
+pub fn project_agent_state_save(
+    state: State<'_, AppState>,
+    agent_state: ProjectAgentState,
+) -> Result<(), String> {
+    state.session_db.save_project_agent_state(&agent_state)
+}
+
+#[tauri::command]
+pub fn project_agent_state_load(
+    state: State<'_, AppState>,
+    project_id: String,
+) -> Result<Option<ProjectAgentState>, String> {
+    state.session_db.load_project_agent_state(&project_id)
+}
+
+// --- Session metrics ---
+
+#[tauri::command]
+pub fn session_metric_save(
+    state: State<'_, AppState>,
+    metric: SessionMetric,
+) -> Result<(), String> {
+    state.session_db.save_session_metric(&metric)
+}
+
+#[tauri::command]
+pub fn session_metrics_load(
+    state: State<'_, AppState>,
+    project_id: String,
+    limit: i64,
+) -> Result<Vec<SessionMetric>, String> {
+    state.session_db.load_session_metrics(&project_id, limit)
+}
+
+// --- Session anchors ---
+
+#[tauri::command]
+pub fn session_anchors_save(
+    state: State<'_, AppState>,
+    anchors: Vec<SessionAnchorRecord>,
+) -> Result<(), String> {
+    state.session_db.save_session_anchors(&anchors)
+}
+
+#[tauri::command]
+pub fn session_anchors_load(
+    state: State<'_, AppState>,
+    project_id: String,
+) -> Result<Vec<SessionAnchorRecord>, String> {
+    state.session_db.load_session_anchors(&project_id)
+}
+
+#[tauri::command]
+pub fn session_anchor_delete(
+    state: State<'_, AppState>,
+    id: String,
+) -> Result<(), String> {
+    state.session_db.delete_session_anchor(&id)
+}
+
+#[tauri::command]
+pub fn session_anchors_clear(
+    state: State<'_, AppState>,
+    project_id: String,
+) -> Result<(), String> {
+    state.session_db.delete_project_anchors(&project_id)
+}
+
+#[tauri::command]
+pub fn session_anchor_update_type(
+    state: State<'_, AppState>,
+    id: String,
+    anchor_type: String,
+) -> Result<(), String> {
+    state.session_db.update_anchor_type(&id, &anchor_type)
+}
diff --git a/v2/src-tauri/src/commands/plugins.rs b/v2/src-tauri/src/commands/plugins.rs
new file mode 100644
index 0000000..1c50743
--- /dev/null
+++ b/v2/src-tauri/src/commands/plugins.rs
@@ -0,0 +1,20 @@
+// Plugin discovery and file access commands
+
+use crate::AppState;
+use crate::plugins;
+
+#[tauri::command]
+pub fn plugins_discover(state: tauri::State<'_, AppState>) -> Vec<plugins::PluginMeta> {
+    let plugins_dir = state.app_config.plugins_dir();
+    plugins::discover_plugins(&plugins_dir)
+}
+
+#[tauri::command]
+pub fn plugin_read_file(
+    state: tauri::State<'_, AppState>,
+    plugin_id: String,
+    filename: String,
+) -> Result<String, String> {
+    let plugins_dir = state.app_config.plugins_dir();
+    plugins::read_plugin_file(&plugins_dir, &plugin_id, &filename)
+}
diff --git a/v2/src-tauri/src/commands/pty.rs b/v2/src-tauri/src/commands/pty.rs
new file mode 100644
index 0000000..f4aa5cc
--- /dev/null
+++ b/v2/src-tauri/src/commands/pty.rs
@@ -0,0 +1,33 @@
+use tauri::State;
+use crate::AppState;
+use crate::pty::PtyOptions;
+
+#[tauri::command]
+#[tracing::instrument(skip(state), fields(shell = ?options.shell))]
+pub fn pty_spawn(
+    state: State<'_, AppState>,
+    options: PtyOptions,
+) -> Result<String, String> {
+    state.pty_manager.spawn(options)
+}
+
+#[tauri::command]
+pub fn pty_write(state: State<'_, AppState>, id: String, data: String) -> Result<(), String> {
+    state.pty_manager.write(&id, &data)
+}
+
+#[tauri::command]
+pub fn pty_resize(
+    state: State<'_, AppState>,
+    id: String,
+    cols: u16,
+    rows: u16,
+) -> Result<(), String> {
+    state.pty_manager.resize(&id, cols, rows)
+}
+
+#[tauri::command]
+#[tracing::instrument(skip(state))]
+pub fn pty_kill(state: State<'_, AppState>, id: String) -> Result<(), String> {
+    state.pty_manager.kill(&id)
+}
diff --git a/v2/src-tauri/src/commands/remote.rs b/v2/src-tauri/src/commands/remote.rs
new file mode 100644
index 0000000..5f7d3a6
--- /dev/null
+++ b/v2/src-tauri/src/commands/remote.rs
@@ -0,0 +1,65 @@
+use tauri::State;
+use crate::AppState;
+use crate::remote::{RemoteMachineConfig, RemoteMachineInfo};
+use crate::pty::PtyOptions;
+use crate::sidecar::AgentQueryOptions;
+
+#[tauri::command]
+pub async fn remote_list(state: State<'_, AppState>) -> Result<Vec<RemoteMachineInfo>, String> {
+    Ok(state.remote_manager.list_machines().await)
+}
+
+#[tauri::command]
+pub async fn remote_add(state: State<'_, AppState>, config: RemoteMachineConfig) -> Result<String, String> {
+    Ok(state.remote_manager.add_machine(config).await)
+}
+
+#[tauri::command]
+pub async fn remote_remove(state: State<'_, AppState>, machine_id: String) -> Result<(), String> {
+    state.remote_manager.remove_machine(&machine_id).await
+}
+
+#[tauri::command]
+#[tracing::instrument(skip(app, state))]
+pub async fn remote_connect(app: tauri::AppHandle, state: State<'_, AppState>, machine_id: String) -> Result<(), String> {
+    state.remote_manager.connect(&app, &machine_id).await
+}
+
+#[tauri::command]
+#[tracing::instrument(skip(state))]
+pub async fn remote_disconnect(state: State<'_, AppState>, machine_id: String) -> Result<(), String> {
+    state.remote_manager.disconnect(&machine_id).await
+}
+
+#[tauri::command]
+#[tracing::instrument(skip(state, options), fields(session_id = %options.session_id))]
+pub async fn remote_agent_query(state: State<'_, AppState>, machine_id: String, options: AgentQueryOptions) -> Result<(), String> {
+    state.remote_manager.agent_query(&machine_id, &options).await
+}
+
+#[tauri::command]
+#[tracing::instrument(skip(state))]
+pub async fn remote_agent_stop(state: State<'_, AppState>, machine_id: String, session_id: String) -> Result<(), String> {
+    state.remote_manager.agent_stop(&machine_id, &session_id).await
+}
+
+#[tauri::command]
+#[tracing::instrument(skip(state), fields(shell = ?options.shell))]
+pub async fn remote_pty_spawn(state: State<'_, AppState>, machine_id: String, options: PtyOptions) -> Result<String, String> {
+    state.remote_manager.pty_spawn(&machine_id, &options).await
+}
+
+#[tauri::command]
+pub async fn remote_pty_write(state: State<'_, AppState>, machine_id: String, id: String, data: String) -> Result<(), String> {
+    state.remote_manager.pty_write(&machine_id, &id, &data).await
+}
+
+#[tauri::command]
+pub async fn remote_pty_resize(state: State<'_, AppState>, machine_id: String, id: String, cols: u16, rows: u16) -> Result<(), String> {
+    state.remote_manager.pty_resize(&machine_id, &id, cols, rows).await
+}
+
+#[tauri::command]
+pub async fn remote_pty_kill(state: State<'_, AppState>, machine_id: String, id: String) -> Result<(), String> {
+    state.remote_manager.pty_kill(&machine_id, &id).await
+}
diff --git a/v2/src-tauri/src/commands/search.rs b/v2/src-tauri/src/commands/search.rs
new file mode 100644
index 0000000..8ca6e33
--- /dev/null
+++ b/v2/src-tauri/src/commands/search.rs
@@ -0,0 +1,35 @@
+use crate::AppState;
+use crate::search::SearchResult;
+use tauri::State;
+
+#[tauri::command]
+pub fn search_init(state: State<'_, AppState>) -> Result<(), String> {
+    // SearchDb is already initialized during app setup; this is a no-op
+    // but allows the frontend to confirm readiness.
+    let _db = &state.search_db;
+    Ok(())
+}
+
+#[tauri::command]
+pub fn search_query(
+    state: State<'_, AppState>,
+    query: String,
+    limit: Option<i32>,
+) -> Result<Vec<SearchResult>, String> {
+    state.search_db.search_all(&query, limit.unwrap_or(20))
+}
+
+#[tauri::command]
+pub fn search_rebuild(state: State<'_, AppState>) -> Result<(), String> {
+    state.search_db.rebuild_index()
+}
+
+#[tauri::command]
+pub fn search_index_message(
+    state: State<'_, AppState>,
+    session_id: String,
+    role: String,
+    content: String,
+) -> Result<(), String> {
+    state.search_db.index_message(&session_id, &role, &content)
+}
diff --git a/v2/src-tauri/src/commands/secrets.rs b/v2/src-tauri/src/commands/secrets.rs
new file mode 100644
index 0000000..1e35387
--- /dev/null
+++ b/v2/src-tauri/src/commands/secrets.rs
@@ -0,0 +1,34 @@
+use crate::secrets::SecretsManager;
+
+#[tauri::command]
+pub fn secrets_store(key: String, value: String) -> Result<(), String> {
+    SecretsManager::store_secret(&key, &value)
+}
+
+#[tauri::command]
+pub fn secrets_get(key: String) -> Result<Option<String>, String> {
+    SecretsManager::get_secret(&key)
+}
+
+#[tauri::command]
+pub fn secrets_delete(key: String) -> Result<(), String> {
+    SecretsManager::delete_secret(&key)
+}
+
+#[tauri::command]
+pub fn secrets_list() -> Result<Vec<String>, String> {
+    SecretsManager::list_keys()
+}
+
+#[tauri::command]
+pub fn secrets_has_keyring() -> bool {
+    SecretsManager::has_keyring()
+}
+
+#[tauri::command]
+pub fn secrets_known_keys() -> Vec<String> {
+    crate::secrets::KNOWN_KEYS
+        .iter()
+        .map(|s| s.to_string())
+        .collect()
+}
diff --git a/v2/src-tauri/src/commands/session.rs b/v2/src-tauri/src/commands/session.rs
new file mode 100644
index 0000000..bbfd6d6
--- /dev/null
+++ b/v2/src-tauri/src/commands/session.rs
@@ -0,0 +1,81 @@
+use tauri::State;
+use crate::AppState;
+use crate::session::{Session, LayoutState, SshSession};
+
+// --- Session persistence ---
+
+#[tauri::command]
+pub fn session_list(state: State<'_, AppState>) -> Result<Vec<Session>, String> {
+    state.session_db.list_sessions()
+}
+
+#[tauri::command]
+pub fn session_save(state: State<'_, AppState>, session: Session) -> Result<(), String> {
+    state.session_db.save_session(&session)
+}
+
+#[tauri::command]
+pub fn session_delete(state: State<'_, AppState>, id: String) -> Result<(), String> {
+    state.session_db.delete_session(&id)
+}
+
+#[tauri::command]
+pub fn session_update_title(state: State<'_, AppState>, id: String, title: String) -> Result<(), String> {
+    state.session_db.update_title(&id, &title)
+}
+
+#[tauri::command]
+pub fn session_touch(state: State<'_, AppState>, id: String) -> Result<(), String> {
+    state.session_db.touch_session(&id)
+}
+
+#[tauri::command]
+pub fn session_update_group(state: State<'_, AppState>, id: String, group_name: String) -> Result<(), String> {
+    state.session_db.update_group(&id, &group_name)
+}
+
+// --- Layout ---
+
+#[tauri::command]
+pub fn layout_save(state: State<'_, AppState>, layout: LayoutState) -> Result<(), String> {
+    state.session_db.save_layout(&layout)
+}
+
+#[tauri::command]
+pub fn layout_load(state: State<'_, AppState>) -> Result<LayoutState, String> {
+    state.session_db.load_layout()
+}
+
+// --- Settings ---
+
+#[tauri::command]
+pub fn settings_get(state: State<'_, AppState>, key: String) -> Result<Option<String>, String> {
+    state.session_db.get_setting(&key)
+}
+
+#[tauri::command]
+pub fn settings_set(state: State<'_, AppState>, key: String, value: String) -> Result<(), String> {
+    state.session_db.set_setting(&key, &value)
+}
+
+#[tauri::command]
+pub fn settings_list(state: State<'_, AppState>) -> Result<Vec<(String, String)>, String> {
+    state.session_db.get_all_settings()
+}
+
+// --- SSH sessions ---
+
+#[tauri::command]
+pub fn ssh_session_list(state: State<'_, AppState>) -> Result<Vec<SshSession>, String> {
+    state.session_db.list_ssh_sessions()
+}
+
+#[tauri::command]
+pub fn ssh_session_save(state: State<'_, AppState>, session: SshSession) -> Result<(), String> {
+    state.session_db.save_ssh_session(&session)
+}
+
+#[tauri::command]
+pub fn ssh_session_delete(state: State<'_, AppState>, id: String) -> Result<(), String> {
+    state.session_db.delete_ssh_session(&id)
+}
diff --git a/v2/src-tauri/src/commands/watcher.rs b/v2/src-tauri/src/commands/watcher.rs
new file mode 100644
index 0000000..ebacbae
--- /dev/null
+++ b/v2/src-tauri/src/commands/watcher.rs
@@ -0,0 +1,43 @@
+use tauri::State;
+use crate::AppState;
+use crate::fs_watcher::FsWatcherStatus;
+
+#[tauri::command]
+pub fn file_watch(
+    app: tauri::AppHandle,
+    state: State<'_, AppState>,
+    pane_id: String,
+    path: String,
+) -> Result<String, String> {
+    state.file_watcher.watch(&app, &pane_id, &path)
+}
+
+#[tauri::command]
+pub fn file_unwatch(state: State<'_, AppState>, pane_id: String) {
+    state.file_watcher.unwatch(&pane_id);
+}
+
+#[tauri::command]
+pub fn file_read(state: State<'_, AppState>, path: String) -> Result<String, String> {
+    state.file_watcher.read_file(&path)
+}
+
+#[tauri::command]
+pub fn fs_watch_project(
+    app: tauri::AppHandle,
+    state: State<'_, AppState>,
+    project_id: String,
+    cwd: String,
+) -> Result<(), String> {
+    state.fs_watcher.watch_project(&app, &project_id, &cwd)
+}
+
+#[tauri::command]
+pub fn fs_unwatch_project(state: State<'_, AppState>, project_id: String) {
+    state.fs_watcher.unwatch_project(&project_id);
+}
+
+#[tauri::command]
+pub fn fs_watcher_status(state: State<'_, AppState>) -> FsWatcherStatus {
+    state.fs_watcher.status()
+}
diff --git a/v2/src-tauri/src/ctx.rs b/v2/src-tauri/src/ctx.rs
new file mode 100644
index 0000000..5aa725e
--- /dev/null
+++ b/v2/src-tauri/src/ctx.rs
@@ -0,0 +1,315 @@
+// ctx — Read-only access to the Claude Code context manager database
+// Database: ~/.claude-context/context.db (managed by ctx CLI tool)
+// Path configurable via new_with_path() for test isolation.
+
+use rusqlite::{Connection, params};
+use serde::Serialize;
+use std::path::PathBuf;
+use std::sync::Mutex;
+
+#[derive(Debug, Clone, Serialize)]
+pub struct CtxEntry {
+    pub project: String,
+    pub key: String,
+    pub value: String,
+    pub updated_at: String,
+}
+
+#[derive(Debug, Clone, Serialize)]
+pub struct CtxSummary {
+    pub project: String,
+    pub summary: String,
+    pub created_at: String,
+}
+
+pub struct CtxDb {
+    conn: Mutex<Option<Connection>>,
+    path: PathBuf,
+}
+
+impl CtxDb {
+    fn default_db_path() -> PathBuf {
+        dirs::home_dir()
+            .unwrap_or_default()
+            .join(".claude-context")
+            .join("context.db")
+    }
+
+    pub fn new() -> Self {
+        Self::new_with_path(Self::default_db_path())
+    }
+
+    /// Create a CtxDb with a custom database path (for test isolation).
+    pub fn new_with_path(db_path: PathBuf) -> Self {
+        let conn = if db_path.exists() {
+            Connection::open_with_flags(
+                &db_path,
+                rusqlite::OpenFlags::SQLITE_OPEN_READ_ONLY | rusqlite::OpenFlags::SQLITE_OPEN_NO_MUTEX,
+            ).ok()
+        } else {
+            None
+        };
+
+        Self { conn: Mutex::new(conn), path: db_path }
+    }
+
+    /// Create the context database directory and schema, then open a read-only connection.
+    pub fn init_db(&self) -> Result<(), String> {
+        let db_path = &self.path;
+
+        // Create parent directory
+        if let Some(parent) = db_path.parent() {
+            std::fs::create_dir_all(parent)
+                .map_err(|e| format!("Failed to create directory: {e}"))?;
+        }
+
+        // Open read-write to create schema
+        let conn = Connection::open(&db_path)
+            .map_err(|e| format!("Failed to create database: {e}"))?;
+
+        conn.execute_batch("PRAGMA journal_mode=WAL;").map_err(|e| format!("WAL mode failed: {e}"))?;
+
+        conn.execute_batch(
+            "CREATE TABLE IF NOT EXISTS sessions (
+                name TEXT PRIMARY KEY,
+                description TEXT,
+                work_dir TEXT,
+                created_at TEXT DEFAULT (datetime('now'))
+            );
+
+            CREATE TABLE IF NOT EXISTS contexts (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                project TEXT NOT NULL,
+                key TEXT NOT NULL,
+                value TEXT NOT NULL,
+                updated_at TEXT DEFAULT (datetime('now')),
+                UNIQUE(project, key)
+            );
+
+            CREATE TABLE IF NOT EXISTS shared (
+                key TEXT PRIMARY KEY,
+                value TEXT NOT NULL,
+                updated_at TEXT DEFAULT (datetime('now'))
+            );
+
+            CREATE TABLE IF NOT EXISTS summaries (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                project TEXT NOT NULL,
+                summary TEXT NOT NULL,
+                created_at TEXT DEFAULT (datetime('now'))
+            );
+
+            CREATE VIRTUAL TABLE IF NOT EXISTS contexts_fts USING fts5(
+                project, key, value, content=contexts, content_rowid=id
+            );
+
+            CREATE VIRTUAL TABLE IF NOT EXISTS shared_fts USING fts5(
+                key, value, content=shared
+            );
+
+            CREATE TRIGGER IF NOT EXISTS contexts_ai AFTER INSERT ON contexts BEGIN
+                INSERT INTO contexts_fts(rowid, project, key, value)
+                VALUES (new.id, new.project, new.key, new.value);
+            END;
+
+            CREATE TRIGGER IF NOT EXISTS contexts_ad AFTER DELETE ON contexts BEGIN
+                INSERT INTO contexts_fts(contexts_fts, rowid, project, key, value)
+                VALUES ('delete', old.id, old.project, old.key, old.value);
+            END;
+
+            CREATE TRIGGER IF NOT EXISTS contexts_au AFTER UPDATE ON contexts BEGIN
+                INSERT INTO contexts_fts(contexts_fts, rowid, project, key, value)
+                VALUES ('delete', old.id, old.project, old.key, old.value);
+                INSERT INTO contexts_fts(rowid, project, key, value)
+                VALUES (new.id, new.project, new.key, new.value);
+            END;"
+        ).map_err(|e| format!("Schema creation failed: {e}"))?;
+
+        drop(conn);
+
+        // Re-open as read-only for normal operation
+        let ro_conn = Connection::open_with_flags(
+            &db_path,
+            rusqlite::OpenFlags::SQLITE_OPEN_READ_ONLY | rusqlite::OpenFlags::SQLITE_OPEN_NO_MUTEX,
+        ).map_err(|e| format!("Failed to reopen database: {e}"))?;
+
+        let mut lock = self.conn.lock().map_err(|_| "ctx database lock poisoned".to_string())?;
+        *lock = Some(ro_conn);
+
+        Ok(())
+    }
+
+    /// Register a project in the ctx database (creates if not exists).
+    /// Opens a brief read-write connection; the main self.conn stays read-only.
+    pub fn register_project(&self, name: &str, description: &str, work_dir: Option<&str>) -> Result<(), String> {
+        let db_path = &self.path;
+        let conn = Connection::open(&db_path)
+            .map_err(|e| format!("ctx database not found: {e}"))?;
+
+        conn.execute(
+            "INSERT OR IGNORE INTO sessions (name, description, work_dir) VALUES (?1, ?2, ?3)",
+            rusqlite::params![name, description, work_dir],
+        ).map_err(|e| format!("Failed to register project: {e}"))?;
+
+        Ok(())
+    }
+
+    pub fn get_context(&self, project: &str) -> Result<Vec<CtxEntry>, String> {
+        let lock = self.conn.lock().map_err(|_| "ctx database lock poisoned".to_string())?;
+        let conn = lock.as_ref().ok_or("ctx database not found")?;
+
+        let mut stmt = conn
+            .prepare("SELECT project, key, value, updated_at FROM contexts WHERE project = ?1 ORDER BY key")
+            .map_err(|e| format!("ctx query failed: {e}"))?;
+
+        let entries = stmt
+            .query_map(params![project], |row| {
+                Ok(CtxEntry {
+                    project: row.get(0)?,
+                    key: row.get(1)?,
+                    value: row.get(2)?,
+                    updated_at: row.get(3)?,
+                })
+            })
+            .map_err(|e| format!("ctx query failed: {e}"))?
+            .collect::<Result<Vec<_>, _>>()
+            .map_err(|e| format!("ctx row read failed: {e}"))?;
+
+        Ok(entries)
+    }
+
+    pub fn get_shared(&self) -> Result<Vec<CtxEntry>, String> {
+        let lock = self.conn.lock().map_err(|_| "ctx database lock poisoned".to_string())?;
+        let conn = lock.as_ref().ok_or("ctx database not found")?;
+
+        let mut stmt = conn
+            .prepare("SELECT key, value, updated_at FROM shared ORDER BY key")
+            .map_err(|e| format!("ctx query failed: {e}"))?;
+
+        let entries = stmt
+            .query_map([], |row| {
+                Ok(CtxEntry {
+                    project: "shared".to_string(),
+                    key: row.get(0)?,
+                    value: row.get(1)?,
+                    updated_at: row.get(2)?,
+                })
+            })
+            .map_err(|e| format!("ctx query failed: {e}"))?
+            .collect::<Result<Vec<_>, _>>()
+            .map_err(|e| format!("ctx row read failed: {e}"))?;
+
+        Ok(entries)
+    }
+
+    pub fn get_summaries(&self, project: &str, limit: i64) -> Result<Vec<CtxSummary>, String> {
+        let lock = self.conn.lock().map_err(|_| "ctx database lock poisoned".to_string())?;
+        let conn = lock.as_ref().ok_or("ctx database not found")?;
+
+        let mut stmt = conn
+            .prepare("SELECT project, summary, created_at FROM summaries WHERE project = ?1 ORDER BY created_at DESC LIMIT ?2")
+            .map_err(|e| format!("ctx query failed: {e}"))?;
+
+        let summaries = stmt
+            .query_map(params![project, limit], |row| {
+                Ok(CtxSummary {
+                    project: row.get(0)?,
+                    summary: row.get(1)?,
+                    created_at: row.get(2)?,
+                })
+            })
+            .map_err(|e| format!("ctx query failed: {e}"))?
+            .collect::<Result<Vec<_>, _>>()
+            .map_err(|e| format!("ctx row read failed: {e}"))?;
+
+        Ok(summaries)
+    }
+
+    pub fn search(&self, query: &str) -> Result<Vec<CtxEntry>, String> {
+        let lock = self.conn.lock().map_err(|_| "ctx database lock poisoned".to_string())?;
+        let conn = lock.as_ref().ok_or("ctx database not found")?;
+
+        let mut stmt = conn
+            .prepare("SELECT project, key, value FROM contexts_fts WHERE contexts_fts MATCH ?1 LIMIT 50")
+            .map_err(|e| format!("ctx search failed: {e}"))?;
+
+        let entries = stmt
+            .query_map(params![query], |row| {
+                Ok(CtxEntry {
+                    project: row.get(0)?,
+                    key: row.get(1)?,
+                    value: row.get(2)?,
+                    updated_at: String::new(), // FTS5 virtual table doesn't store updated_at
+                })
+            })
+            .map_err(|e| {
+                let msg = e.to_string();
+                if msg.contains("fts5") || msg.contains("syntax") {
+                    format!("Invalid search query syntax: {e}")
+                } else {
+                    format!("ctx search failed: {e}")
+                }
+            })?
+            .collect::<Result<Vec<_>, _>>()
+            .map_err(|e| format!("ctx row read failed: {e}"))?;
+
+        Ok(entries)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    /// Create a CtxDb with conn set to None, simulating a missing database.
+    fn make_missing_db() -> CtxDb {
+        CtxDb { conn: Mutex::new(None), path: PathBuf::from("/nonexistent/context.db") }
+    }
+
+    #[test]
+    fn test_new_does_not_panic() {
+        // CtxDb::new() should never panic even if ~/.claude-context/context.db
+        // doesn't exist — it just stores None for the connection.
+        let _db = CtxDb::new();
+    }
+
+    #[test]
+    fn test_get_context_missing_db_returns_error() {
+        let db = make_missing_db();
+        let result = db.get_context("any-project");
+        assert!(result.is_err());
+        assert_eq!(result.unwrap_err(), "ctx database not found");
+    }
+
+    #[test]
+    fn test_get_shared_missing_db_returns_error() {
+        let db = make_missing_db();
+        let result = db.get_shared();
+        assert!(result.is_err());
+        assert_eq!(result.unwrap_err(), "ctx database not found");
+    }
+
+    #[test]
+    fn test_get_summaries_missing_db_returns_error() {
+        let db = make_missing_db();
+        let result = db.get_summaries("any-project", 10);
+        assert!(result.is_err());
+        assert_eq!(result.unwrap_err(), "ctx database not found");
+    }
+
+    #[test]
+    fn test_search_missing_db_returns_error() {
+        let db = make_missing_db();
+        let result = db.search("anything");
+        assert!(result.is_err());
+        assert_eq!(result.unwrap_err(), "ctx database not found");
+    }
+
+    #[test]
+    fn test_search_empty_query_missing_db_returns_error() {
+        let db = make_missing_db();
+        let result = db.search("");
+        assert!(result.is_err());
+        assert_eq!(result.unwrap_err(), "ctx database not found");
+    }
+}
diff --git a/v2/src-tauri/src/event_sink.rs b/v2/src-tauri/src/event_sink.rs
new file mode 100644
index 0000000..e8d2378
--- /dev/null
+++ b/v2/src-tauri/src/event_sink.rs
@@ -0,0 +1,11 @@
+use bterminal_core::event::EventSink;
+use tauri::{AppHandle, Emitter};
+
+/// Bridges bterminal-core's EventSink trait to Tauri's event system.
+pub struct TauriEventSink(pub AppHandle);
+
+impl EventSink for TauriEventSink {
+    fn emit(&self, event: &str, payload: serde_json::Value) {
+        let _ = self.0.emit(event, &payload);
+    }
+}
diff --git a/v2/src-tauri/src/fs_watcher.rs b/v2/src-tauri/src/fs_watcher.rs
new file mode 100644
index 0000000..10409f4
--- /dev/null
+++ b/v2/src-tauri/src/fs_watcher.rs
@@ -0,0 +1,357 @@
+// Filesystem write detection for project directories
+// Uses notify crate (inotify on Linux) to detect file modifications.
+// Emits Tauri events so frontend can detect external writes vs agent-managed writes.
+
+use notify::{Config, Event, EventKind, RecommendedWatcher, RecursiveMode, Watcher};
+use serde::Serialize;
+use std::collections::HashMap;
+use std::path::Path;
+use std::sync::Mutex;
+use std::time::{Duration, Instant};
+use tauri::Emitter;
+
+/// Payload emitted on fs-write-detected events
+#[derive(Clone, Serialize)]
+pub struct FsWritePayload {
+    pub project_id: String,
+    pub file_path: String,
+    pub timestamp_ms: u64,
+}
+
+/// Directories to skip when watching recursively
+const IGNORED_DIRS: &[&str] = &[
+    ".git",
+    "node_modules",
+    "target",
+    ".svelte-kit",
+    "dist",
+    "__pycache__",
+    ".next",
+    ".nuxt",
+    ".cache",
+    "build",
+];
+
+/// Status of inotify watch capacity
+#[derive(Clone, Serialize)]
+pub struct FsWatcherStatus {
+    /// Kernel limit from /proc/sys/fs/inotify/max_user_watches
+    pub max_watches: u64,
+    /// Estimated directories being watched across all projects
+    pub estimated_watches: u64,
+    /// Usage ratio (0.0 - 1.0)
+    pub usage_ratio: f64,
+    /// Number of actively watched projects
+    pub active_projects: usize,
+    /// Warning message if approaching limit, null otherwise
+    pub warning: Option<String>,
+}
+
+struct ProjectWatch {
+    _watcher: RecommendedWatcher,
+    _cwd: String,
+    /// Estimated number of directories (inotify watches) for this project
+    dir_count: u64,
+}
+
+pub struct ProjectFsWatcher {
+    watches: Mutex<HashMap<String, ProjectWatch>>,
+}
+
+impl ProjectFsWatcher {
+    pub fn new() -> Self {
+        Self {
+            watches: Mutex::new(HashMap::new()),
+        }
+    }
+
+    /// Start watching a project's CWD for file writes (Create, Modify, Rename).
+    /// Debounces events per-file (100ms) to avoid flooding on rapid writes.
+    pub fn watch_project(
+        &self,
+        app: &tauri::AppHandle,
+        project_id: &str,
+        cwd: &str,
+    ) -> Result<(), String> {
+        // In test mode, skip inotify watchers to avoid resource contention and flaky events
+        if std::env::var("BTERMINAL_TEST").map_or(false, |v| v == "1") {
+            log::info!("Test mode: skipping fs watcher for project {project_id}");
+            return Ok(());
+        }
+
+        let cwd_path = Path::new(cwd);
+        if !cwd_path.is_dir() {
+            return Err(format!("Not a directory: {cwd}"));
+        }
+
+        let mut watches = self.watches.lock().unwrap();
+
+        // Don't duplicate — unwatch first if already watching
+        if watches.contains_key(project_id) {
+            drop(watches);
+            self.unwatch_project(project_id);
+            watches = self.watches.lock().unwrap();
+        }
+
+        let app_handle = app.clone();
+        let project_id_owned = project_id.to_string();
+        let cwd_owned = cwd.to_string();
+
+        // Per-file debounce state
+        let debounce: std::sync::Arc<Mutex<HashMap<String, Instant>>> =
+            std::sync::Arc::new(Mutex::new(HashMap::new()));
+        let debounce_duration = Duration::from_millis(100);
+
+        let mut watcher = RecommendedWatcher::new(
+            move |res: Result<Event, notify::Error>| {
+                let event = match res {
+                    Ok(e) => e,
+                    Err(_) => return,
+                };
+
+                // Only care about file writes (create, modify, rename-to)
+                let is_write = matches!(
+                    event.kind,
+                    EventKind::Create(_) | EventKind::Modify(_)
+                );
+                if !is_write {
+                    return;
+                }
+
+                for path in &event.paths {
+                    // Skip directories
+                    if path.is_dir() {
+                        continue;
+                    }
+
+                    let path_str = path.to_string_lossy().to_string();
+
+                    // Skip ignored directories
+                    if should_ignore_path(&path_str) {
+                        continue;
+                    }
+
+                    // Debounce: skip if same file was emitted within debounce window
+                    let now = Instant::now();
+                    let mut db = debounce.lock().unwrap();
+                    if let Some(last) = db.get(&path_str) {
+                        if now.duration_since(*last) < debounce_duration {
+                            continue;
+                        }
+                    }
+                    db.insert(path_str.clone(), now);
+                    // Prune old debounce entries (keep map from growing unbounded)
+                    if db.len() > 1000 {
+                        let max_age = debounce_duration * 10;
+                        db.retain(|_, v| now.duration_since(*v) < max_age);
+                    }
+                    drop(db);
+
+                    let timestamp_ms = std::time::SystemTime::now()
+                        .duration_since(std::time::UNIX_EPOCH)
+                        .unwrap_or_default()
+                        .as_millis() as u64;
+
+                    let _ = app_handle.emit(
+                        "fs-write-detected",
+                        FsWritePayload {
+                            project_id: project_id_owned.clone(),
+                            file_path: path_str,
+                            timestamp_ms,
+                        },
+                    );
+                }
+            },
+            Config::default(),
+        )
+        .map_err(|e| format!("Failed to create fs watcher: {e}"))?;
+
+        watcher
+            .watch(cwd_path, RecursiveMode::Recursive)
+            .map_err(|e| format!("Failed to watch directory: {e}"))?;
+
+        let dir_count = count_watched_dirs(cwd_path);
+        log::info!("Started fs watcher for project {project_id} at {cwd} (~{dir_count} directories)");
+
+        watches.insert(
+            project_id.to_string(),
+            ProjectWatch {
+                _watcher: watcher,
+                _cwd: cwd_owned,
+                dir_count,
+            },
+        );
+
+        Ok(())
+    }
+
+    /// Stop watching a project's CWD
+    pub fn unwatch_project(&self, project_id: &str) {
+        let mut watches = self.watches.lock().unwrap();
+        if watches.remove(project_id).is_some() {
+            log::info!("Stopped fs watcher for project {project_id}");
+        }
+    }
+
+    /// Get current watcher status including inotify limit check
+    pub fn status(&self) -> FsWatcherStatus {
+        let max_watches = read_inotify_max_watches();
+        let watches = self.watches.lock().unwrap();
+        let active_projects = watches.len();
+        let estimated_watches: u64 = watches.values().map(|w| w.dir_count).sum();
+        let usage_ratio = if max_watches > 0 {
+            estimated_watches as f64 / max_watches as f64
+        } else {
+            0.0
+        };
+
+        let warning = if usage_ratio > 0.90 {
+            Some(format!(
+                "inotify watch limit critical: using ~{estimated_watches}/{max_watches} watches ({:.0}%). \
+                 Increase with: echo {} | sudo tee /proc/sys/fs/inotify/max_user_watches",
+                usage_ratio * 100.0,
+                max_watches * 2
+            ))
+        } else if usage_ratio > 0.75 {
+            Some(format!(
+                "inotify watch limit warning: using ~{estimated_watches}/{max_watches} watches ({:.0}%). \
+                 Consider increasing with: echo {} | sudo tee /proc/sys/fs/inotify/max_user_watches",
+                usage_ratio * 100.0,
+                max_watches * 2
+            ))
+        } else {
+            None
+        };
+
+        FsWatcherStatus {
+            max_watches,
+            estimated_watches,
+            usage_ratio,
+            active_projects,
+            warning,
+        }
+    }
+}
+
+/// Check if a path contains any ignored directory component
+fn should_ignore_path(path: &str) -> bool {
+    for component in Path::new(path).components() {
+        if let std::path::Component::Normal(name) = component {
+            let name_str = name.to_string_lossy();
+            if IGNORED_DIRS.contains(&name_str.as_ref()) {
+                return true;
+            }
+        }
+    }
+    false
+}
+
+/// Read the kernel inotify watch limit from /proc/sys/fs/inotify/max_user_watches.
+/// Returns 0 on non-Linux or if the file can't be read.
+fn read_inotify_max_watches() -> u64 {
+    std::fs::read_to_string("/proc/sys/fs/inotify/max_user_watches")
+        .ok()
+        .and_then(|s| s.trim().parse::<u64>().ok())
+        .unwrap_or(0)
+}
+
+/// Count directories under a path that would become inotify watches.
+/// Skips ignored directories. Caps the walk at 30,000 to avoid blocking on huge monorepos.
+fn count_watched_dirs(root: &Path) -> u64 {
+    const MAX_WALK: u64 = 30_000;
+    let mut count: u64 = 1; // root itself
+
+    fn walk_dir(dir: &Path, count: &mut u64, max: u64) {
+        if *count >= max {
+            return;
+        }
+        let entries = match std::fs::read_dir(dir) {
+            Ok(e) => e,
+            Err(_) => return,
+        };
+        for entry in entries.flatten() {
+            if *count >= max {
+                return;
+            }
+            let path = entry.path();
+            if !path.is_dir() {
+                continue;
+            }
+            let name = entry.file_name();
+            let name_str = name.to_string_lossy();
+            if IGNORED_DIRS.contains(&name_str.as_ref()) {
+                continue;
+            }
+            *count += 1;
+            walk_dir(&path, count, max);
+        }
+    }
+
+    walk_dir(root, &mut count, MAX_WALK);
+    count
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_should_ignore_git() {
+        assert!(should_ignore_path("/home/user/project/.git/objects/abc"));
+        assert!(should_ignore_path("/home/user/project/.git/HEAD"));
+    }
+
+    #[test]
+    fn test_should_ignore_node_modules() {
+        assert!(should_ignore_path("/project/node_modules/pkg/index.js"));
+    }
+
+    #[test]
+    fn test_should_ignore_target() {
+        assert!(should_ignore_path("/project/target/debug/build/foo"));
+    }
+
+    #[test]
+    fn test_should_not_ignore_src() {
+        assert!(!should_ignore_path("/project/src/main.rs"));
+        assert!(!should_ignore_path("/project/src/lib/stores/health.svelte.ts"));
+    }
+
+    #[test]
+    fn test_should_not_ignore_root_file() {
+        assert!(!should_ignore_path("/project/Cargo.toml"));
+    }
+
+    #[test]
+    fn test_read_inotify_max_watches() {
+        // On Linux this should return a positive number
+        let max = read_inotify_max_watches();
+        if cfg!(target_os = "linux") {
+            assert!(max > 0, "Expected positive inotify limit on Linux, got {max}");
+        }
+    }
+
+    #[test]
+    fn test_count_watched_dirs_tempdir() {
+        let tmp = std::env::temp_dir().join("bterminal_test_count_dirs");
+        let _ = std::fs::remove_dir_all(&tmp);
+        std::fs::create_dir_all(tmp.join("src/lib")).unwrap();
+        std::fs::create_dir_all(tmp.join("node_modules/pkg")).unwrap(); // should be skipped
+        std::fs::create_dir_all(tmp.join(".git/objects")).unwrap(); // should be skipped
+
+        let count = count_watched_dirs(&tmp);
+        // root + src + src/lib = 3 (node_modules and .git skipped)
+        assert_eq!(count, 3, "Expected 3 watched dirs, got {count}");
+
+        let _ = std::fs::remove_dir_all(&tmp);
+    }
+
+    #[test]
+    fn test_watcher_status_no_projects() {
+        let watcher = ProjectFsWatcher::new();
+        let status = watcher.status();
+        assert_eq!(status.active_projects, 0);
+        assert_eq!(status.estimated_watches, 0);
+        assert!(status.warning.is_none());
+    }
+}
diff --git a/v2/src-tauri/src/groups.rs b/v2/src-tauri/src/groups.rs
new file mode 100644
index 0000000..d714022
--- /dev/null
+++ b/v2/src-tauri/src/groups.rs
@@ -0,0 +1,281 @@
+// Project group configuration
+// Reads/writes ~/.config/bterminal/groups.json
+// Path configurable via init() for test isolation.
+
+use serde::{Deserialize, Serialize};
+use std::path::PathBuf;
+use std::sync::OnceLock;
+
+static CONFIG_PATH: OnceLock<PathBuf> = OnceLock::new();
+
+/// Set the groups.json path. Must be called before any config access.
+/// Called from lib.rs setup with AppConfig-resolved path.
+pub fn init(path: PathBuf) {
+    let _ = CONFIG_PATH.set(path);
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ProjectConfig {
+    pub id: String,
+    pub name: String,
+    pub identifier: String,
+    pub description: String,
+    pub icon: String,
+    pub cwd: String,
+    pub profile: String,
+    pub enabled: bool,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct GroupAgentConfig {
+    pub id: String,
+    pub name: String,
+    pub role: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub model: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub cwd: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub system_prompt: Option<String>,
+    pub enabled: bool,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub wake_interval_min: Option<u32>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct GroupConfig {
+    pub id: String,
+    pub name: String,
+    pub projects: Vec<ProjectConfig>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub agents: Vec<GroupAgentConfig>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct GroupsFile {
+    pub version: u32,
+    pub groups: Vec<GroupConfig>,
+    pub active_group_id: String,
+}
+
+impl Default for GroupsFile {
+    fn default() -> Self {
+        Self {
+            version: 1,
+            groups: Vec::new(),
+            active_group_id: String::new(),
+        }
+    }
+}
+
+fn config_path() -> PathBuf {
+    CONFIG_PATH.get().cloned().unwrap_or_else(|| {
+        dirs::config_dir()
+            .unwrap_or_else(|| PathBuf::from("."))
+            .join("bterminal")
+            .join("groups.json")
+    })
+}
+
+pub fn load_groups() -> Result<GroupsFile, String> {
+    let path = config_path();
+    if !path.exists() {
+        return Ok(GroupsFile::default());
+    }
+    let content = std::fs::read_to_string(&path)
+        .map_err(|e| format!("Failed to read groups.json: {e}"))?;
+    serde_json::from_str(&content)
+        .map_err(|e| format!("Invalid groups.json: {e}"))
+}
+
+pub fn save_groups(config: &GroupsFile) -> Result<(), String> {
+    let path = config_path();
+    if let Some(parent) = path.parent() {
+        std::fs::create_dir_all(parent)
+            .map_err(|e| format!("Failed to create config dir: {e}"))?;
+    }
+    let json = serde_json::to_string_pretty(config)
+        .map_err(|e| format!("JSON serialize error: {e}"))?;
+    std::fs::write(&path, json)
+        .map_err(|e| format!("Failed to write groups.json: {e}"))
+}
+
+/// Discover markdown files in a project directory for the Docs tab.
+/// Returns paths relative to cwd, prioritized: CLAUDE.md, README.md, docs/*.md
+pub fn discover_markdown_files(cwd: &str) -> Result<Vec<MdFileEntry>, String> {
+    let root = PathBuf::from(cwd);
+    if !root.is_dir() {
+        return Err(format!("Directory not found: {cwd}"));
+    }
+
+    let mut entries = Vec::new();
+
+    // Priority files at root
+    for name in &["CLAUDE.md", "README.md", "CHANGELOG.md", "TODO.md", "SETUP.md"] {
+        let path = root.join(name);
+        if path.is_file() {
+            entries.push(MdFileEntry {
+                name: name.to_string(),
+                path: path.to_string_lossy().to_string(),
+                priority: true,
+            });
+        }
+    }
+
+    // docs/ or doc/ directory (max 20 entries, depth 2)
+    for dir_name in &["docs", "doc"] {
+        let docs_dir = root.join(dir_name);
+        if docs_dir.is_dir() {
+            scan_md_dir(&docs_dir, &mut entries, 2, 20);
+        }
+    }
+
+    Ok(entries)
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct MdFileEntry {
+    pub name: String,
+    pub path: String,
+    pub priority: bool,
+}
+
+fn scan_md_dir(dir: &PathBuf, entries: &mut Vec<MdFileEntry>, max_depth: u32, max_count: usize) {
+    if max_depth == 0 || entries.len() >= max_count {
+        return;
+    }
+    let Ok(read_dir) = std::fs::read_dir(dir) else { return };
+    for entry in read_dir.flatten() {
+        if entries.len() >= max_count {
+            break;
+        }
+        let path = entry.path();
+        if path.is_file() {
+            if let Some(ext) = path.extension() {
+                if ext == "md" || ext == "markdown" {
+                    let name = path.file_name().unwrap_or_default().to_string_lossy().to_string();
+                    entries.push(MdFileEntry {
+                        name,
+                        path: path.to_string_lossy().to_string(),
+                        priority: false,
+                    });
+                }
+            }
+        } else if path.is_dir() {
+            // Skip common non-doc directories
+            let dir_name = path.file_name().unwrap_or_default().to_string_lossy().to_string();
+            if !matches!(dir_name.as_str(), "node_modules" | ".git" | "target" | "dist" | "build" | ".next" | "__pycache__") {
+                scan_md_dir(&path, entries, max_depth - 1, max_count);
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_default_groups_file() {
+        let g = GroupsFile::default();
+        assert_eq!(g.version, 1);
+        assert!(g.groups.is_empty());
+        assert!(g.active_group_id.is_empty());
+    }
+
+    #[test]
+    fn test_groups_roundtrip() {
+        let config = GroupsFile {
+            version: 1,
+            groups: vec![GroupConfig {
+                id: "test".to_string(),
+                name: "Test Group".to_string(),
+                projects: vec![ProjectConfig {
+                    id: "p1".to_string(),
+                    name: "Project One".to_string(),
+                    identifier: "project-one".to_string(),
+                    description: "A test project".to_string(),
+                    icon: "\u{f120}".to_string(),
+                    cwd: "/tmp/test".to_string(),
+                    profile: "default".to_string(),
+                    enabled: true,
+                }],
+                agents: vec![],
+            }],
+            active_group_id: "test".to_string(),
+        };
+        let json = serde_json::to_string(&config).unwrap();
+        let parsed: GroupsFile = serde_json::from_str(&json).unwrap();
+        assert_eq!(parsed.groups.len(), 1);
+        assert_eq!(parsed.groups[0].projects.len(), 1);
+        assert_eq!(parsed.groups[0].projects[0].identifier, "project-one");
+    }
+
+    #[test]
+    fn test_load_missing_file_returns_default() {
+        // config_path() will point to a non-existent file in test
+        // We test the default case directly
+        let g = GroupsFile::default();
+        assert_eq!(g.version, 1);
+    }
+
+    #[test]
+    fn test_discover_nonexistent_dir() {
+        let result = discover_markdown_files("/nonexistent/path/12345");
+        assert!(result.is_err());
+    }
+
+    #[test]
+    fn test_discover_empty_dir() {
+        let dir = tempfile::tempdir().unwrap();
+        let result = discover_markdown_files(dir.path().to_str().unwrap()).unwrap();
+        assert!(result.is_empty());
+    }
+
+    #[test]
+    fn test_discover_finds_readme() {
+        let dir = tempfile::tempdir().unwrap();
+        std::fs::write(dir.path().join("README.md"), "# Hello").unwrap();
+        let result = discover_markdown_files(dir.path().to_str().unwrap()).unwrap();
+        assert_eq!(result.len(), 1);
+        assert_eq!(result[0].name, "README.md");
+        assert!(result[0].priority);
+    }
+
+    #[test]
+    fn test_discover_finds_docs() {
+        let dir = tempfile::tempdir().unwrap();
+        let docs = dir.path().join("docs");
+        std::fs::create_dir(&docs).unwrap();
+        std::fs::write(docs.join("guide.md"), "# Guide").unwrap();
+        std::fs::write(docs.join("api.md"), "# API").unwrap();
+        let result = discover_markdown_files(dir.path().to_str().unwrap()).unwrap();
+        assert_eq!(result.len(), 2);
+        assert!(result.iter().all(|e| !e.priority));
+    }
+
+    #[test]
+    fn test_discover_finds_doc_dir() {
+        let dir = tempfile::tempdir().unwrap();
+        let doc = dir.path().join("doc");
+        std::fs::create_dir(&doc).unwrap();
+        std::fs::write(doc.join("requirements.md"), "# Req").unwrap();
+        let result = discover_markdown_files(dir.path().to_str().unwrap()).unwrap();
+        assert_eq!(result.len(), 1);
+        assert_eq!(result[0].name, "requirements.md");
+        assert!(!result[0].priority);
+    }
+
+    #[test]
+    fn test_discover_finds_setup_md() {
+        let dir = tempfile::tempdir().unwrap();
+        std::fs::write(dir.path().join("SETUP.md"), "# Setup").unwrap();
+        let result = discover_markdown_files(dir.path().to_str().unwrap()).unwrap();
+        assert_eq!(result.len(), 1);
+        assert_eq!(result[0].name, "SETUP.md");
+        assert!(result[0].priority);
+    }
+}
diff --git a/v2/src-tauri/src/lib.rs b/v2/src-tauri/src/lib.rs
new file mode 100644
index 0000000..057ecd3
--- /dev/null
+++ b/v2/src-tauri/src/lib.rs
@@ -0,0 +1,409 @@
+mod btmsg;
+mod bttask;
+mod commands;
+mod ctx;
+mod event_sink;
+mod fs_watcher;
+mod groups;
+mod memora;
+mod notifications;
+mod plugins;
+mod pty;
+mod secrets;
+mod remote;
+mod search;
+mod sidecar;
+mod session;
+mod telemetry;
+mod watcher;
+
+use bterminal_core::config::AppConfig;
+use event_sink::TauriEventSink;
+use pty::PtyManager;
+use remote::RemoteManager;
+use session::SessionDb;
+use sidecar::{SidecarConfig, SidecarManager};
+use fs_watcher::ProjectFsWatcher;
+use watcher::FileWatcherManager;
+use std::path::{Path, PathBuf};
+use std::sync::Arc;
+use tauri::Manager;
+
+pub(crate) struct AppState {
+    pub pty_manager: Arc<PtyManager>,
+    pub sidecar_manager: Arc<SidecarManager>,
+    pub session_db: Arc<SessionDb>,
+    pub file_watcher: Arc<FileWatcherManager>,
+    pub fs_watcher: Arc<ProjectFsWatcher>,
+    pub ctx_db: Arc<ctx::CtxDb>,
+    pub memora_db: Arc<memora::MemoraDb>,
+    pub remote_manager: Arc<RemoteManager>,
+    pub search_db: Arc<search::SearchDb>,
+    pub app_config: Arc<AppConfig>,
+    _telemetry: telemetry::TelemetryGuard,
+}
+
+/// Install btmsg/bttask CLI tools to ~/.local/bin/ so agent subprocesses can find them.
+/// Sources: bundled resources (production) or repo root (development).
+/// Only overwrites if the source is newer or the destination doesn't exist.
+fn install_cli_tools(resource_dir: &Path, dev_root: &Path) {
+    let bin_dir = dirs::home_dir()
+        .unwrap_or_default()
+        .join(".local")
+        .join("bin");
+    if let Err(e) = std::fs::create_dir_all(&bin_dir) {
+        log::warn!("Failed to create ~/.local/bin: {e}");
+        return;
+    }
+
+    for tool_name in &["btmsg", "bttask"] {
+        // Try resource dir first (production bundle), then dev repo root
+        let source = [
+            resource_dir.join(tool_name),
+            dev_root.join(tool_name),
+        ]
+        .into_iter()
+        .find(|p| p.is_file());
+
+        let source = match source {
+            Some(p) => p,
+            None => {
+                log::warn!("CLI tool '{tool_name}' not found in resources or dev root");
+                continue;
+            }
+        };
+
+        let dest = bin_dir.join(tool_name);
+        let should_install = if dest.exists() {
+            // Compare modification times — install if source is newer
+            match (source.metadata(), dest.metadata()) {
+                (Ok(sm), Ok(dm)) => {
+                    sm.modified().unwrap_or(std::time::SystemTime::UNIX_EPOCH)
+                        > dm.modified().unwrap_or(std::time::SystemTime::UNIX_EPOCH)
+                }
+                _ => true,
+            }
+        } else {
+            true
+        };
+
+        if should_install {
+            match std::fs::copy(&source, &dest) {
+                Ok(_) => {
+                    // Ensure executable permission on Unix
+                    #[cfg(unix)]
+                    {
+                        use std::os::unix::fs::PermissionsExt;
+                        let _ = std::fs::set_permissions(&dest, std::fs::Permissions::from_mode(0o755));
+                    }
+                    log::info!("Installed {tool_name} to {}", dest.display());
+                }
+                Err(e) => log::warn!("Failed to install {tool_name}: {e}"),
+            }
+        }
+    }
+}
+
+/// Run `PRAGMA wal_checkpoint(TRUNCATE)` on a SQLite database to reclaim WAL file space.
+/// Returns Ok(()) on success or Err with a diagnostic message.
+pub(crate) fn checkpoint_wal(path: &Path) -> Result<(), String> {
+    use rusqlite::{Connection, OpenFlags};
+
+    if !path.exists() {
+        return Ok(()); // DB doesn't exist yet — nothing to checkpoint
+    }
+
+    let conn = Connection::open_with_flags(path, OpenFlags::SQLITE_OPEN_READ_WRITE)
+        .map_err(|e| format!("WAL checkpoint: failed to open {}: {e}", path.display()))?;
+    conn.query_row("PRAGMA busy_timeout = 5000", [], |_| Ok(()))
+        .map_err(|e| format!("WAL checkpoint: failed to set busy_timeout: {e}"))?;
+    conn.query_row("PRAGMA wal_checkpoint(TRUNCATE)", [], |_| Ok(()))
+        .map_err(|e| format!("WAL checkpoint failed on {}: {e}", path.display()))?;
+    Ok(())
+}
+
+/// Spawn a background task that checkpoints WAL on both databases every 5 minutes.
+/// Uses `tauri::async_runtime::spawn` instead of `tokio::spawn` because this runs
+/// during Tauri setup where the Tokio runtime may not be directly accessible.
+fn spawn_wal_checkpoint_task(sessions_db_path: PathBuf, btmsg_db_path: PathBuf) {
+    tauri::async_runtime::spawn(async move {
+        let interval = std::time::Duration::from_secs(300);
+        loop {
+            tokio::time::sleep(interval).await;
+            for (label, path) in [("sessions.db", &sessions_db_path), ("btmsg.db", &btmsg_db_path)] {
+                match checkpoint_wal(path) {
+                    Ok(()) => tracing::info!("WAL checkpoint completed for {label}"),
+                    Err(e) => tracing::warn!("WAL checkpoint error for {label}: {e}"),
+                }
+            }
+        }
+    });
+}
+
+#[cfg_attr(mobile, tauri::mobile_entry_point)]
+pub fn run() {
+    // Force dark GTK theme for native dialogs (file chooser, etc.)
+    std::env::set_var("GTK_THEME", "Adwaita:dark");
+
+    // Resolve all paths via AppConfig (respects BTERMINAL_TEST_* env vars)
+    let app_config = AppConfig::from_env();
+    if app_config.is_test_mode() {
+        log::info!(
+            "Test mode enabled: data_dir={}, config_dir={}",
+            app_config.data_dir.display(),
+            app_config.config_dir.display()
+        );
+    }
+
+    // Initialize subsystem paths from AppConfig (before any db access)
+    btmsg::init(app_config.btmsg_db_path());
+    bttask::init(app_config.btmsg_db_path());
+    groups::init(app_config.groups_json_path());
+
+    // Initialize tracing + optional OTLP export (before any tracing macros)
+    let telemetry_guard = telemetry::init();
+
+    let app_config_arc = Arc::new(app_config);
+
+    tauri::Builder::default()
+        .invoke_handler(tauri::generate_handler![
+            // PTY
+            commands::pty::pty_spawn,
+            commands::pty::pty_write,
+            commands::pty::pty_resize,
+            commands::pty::pty_kill,
+            // Agent/sidecar
+            commands::agent::agent_query,
+            commands::agent::agent_stop,
+            commands::agent::agent_ready,
+            commands::agent::agent_restart,
+            commands::agent::agent_set_sandbox,
+            // File watcher
+            commands::watcher::file_watch,
+            commands::watcher::file_unwatch,
+            commands::watcher::file_read,
+            commands::watcher::fs_watch_project,
+            commands::watcher::fs_unwatch_project,
+            commands::watcher::fs_watcher_status,
+            // Session/layout/settings/SSH
+            commands::session::session_list,
+            commands::session::session_save,
+            commands::session::session_delete,
+            commands::session::session_update_title,
+            commands::session::session_touch,
+            commands::session::session_update_group,
+            commands::session::layout_save,
+            commands::session::layout_load,
+            commands::session::settings_get,
+            commands::session::settings_set,
+            commands::session::settings_list,
+            commands::session::ssh_session_list,
+            commands::session::ssh_session_save,
+            commands::session::ssh_session_delete,
+            // Agent persistence (messages, state, metrics, anchors)
+            commands::persistence::agent_messages_save,
+            commands::persistence::agent_messages_load,
+            commands::persistence::project_agent_state_save,
+            commands::persistence::project_agent_state_load,
+            commands::persistence::session_metric_save,
+            commands::persistence::session_metrics_load,
+            commands::persistence::session_anchors_save,
+            commands::persistence::session_anchors_load,
+            commands::persistence::session_anchor_delete,
+            commands::persistence::session_anchors_clear,
+            commands::persistence::session_anchor_update_type,
+            // ctx + Memora
+            commands::knowledge::ctx_init_db,
+            commands::knowledge::ctx_register_project,
+            commands::knowledge::ctx_get_context,
+            commands::knowledge::ctx_get_shared,
+            commands::knowledge::ctx_get_summaries,
+            commands::knowledge::ctx_search,
+            commands::knowledge::memora_available,
+            commands::knowledge::memora_list,
+            commands::knowledge::memora_search,
+            commands::knowledge::memora_get,
+            // Claude profiles/skills
+            commands::claude::claude_list_profiles,
+            commands::claude::claude_list_skills,
+            commands::claude::claude_read_skill,
+            // Groups
+            commands::groups::groups_load,
+            commands::groups::groups_save,
+            commands::groups::discover_markdown_files,
+            // File browser
+            commands::files::list_directory_children,
+            commands::files::read_file_content,
+            commands::files::write_file_content,
+            commands::files::pick_directory,
+            // Remote machines
+            commands::remote::remote_list,
+            commands::remote::remote_add,
+            commands::remote::remote_remove,
+            commands::remote::remote_connect,
+            commands::remote::remote_disconnect,
+            commands::remote::remote_agent_query,
+            commands::remote::remote_agent_stop,
+            commands::remote::remote_pty_spawn,
+            commands::remote::remote_pty_write,
+            commands::remote::remote_pty_resize,
+            commands::remote::remote_pty_kill,
+            // btmsg (agent messenger)
+            commands::btmsg::btmsg_get_agents,
+            commands::btmsg::btmsg_unread_count,
+            commands::btmsg::btmsg_unread_messages,
+            commands::btmsg::btmsg_history,
+            commands::btmsg::btmsg_send,
+            commands::btmsg::btmsg_set_status,
+            commands::btmsg::btmsg_ensure_admin,
+            commands::btmsg::btmsg_all_feed,
+            commands::btmsg::btmsg_mark_read,
+            commands::btmsg::btmsg_get_channels,
+            commands::btmsg::btmsg_channel_messages,
+            commands::btmsg::btmsg_channel_send,
+            commands::btmsg::btmsg_create_channel,
+            commands::btmsg::btmsg_add_channel_member,
+            commands::btmsg::btmsg_register_agents,
+            // btmsg health monitoring
+            commands::btmsg::btmsg_record_heartbeat,
+            commands::btmsg::btmsg_get_stale_agents,
+            commands::btmsg::btmsg_get_dead_letters,
+            commands::btmsg::btmsg_clear_dead_letters,
+            // Audit log
+            commands::btmsg::audit_log_event,
+            commands::btmsg::audit_log_list,
+            commands::btmsg::audit_log_for_agent,
+            // bttask (task board)
+            commands::bttask::bttask_list,
+            commands::bttask::bttask_comments,
+            commands::bttask::bttask_update_status,
+            commands::bttask::bttask_add_comment,
+            commands::bttask::bttask_create,
+            commands::bttask::bttask_delete,
+            commands::bttask::bttask_review_queue_count,
+            // Search (FTS5)
+            commands::search::search_init,
+            commands::search::search_query,
+            commands::search::search_rebuild,
+            commands::search::search_index_message,
+            // Notifications
+            commands::notifications::notify_desktop,
+            // Secrets (system keyring)
+            commands::secrets::secrets_store,
+            commands::secrets::secrets_get,
+            commands::secrets::secrets_delete,
+            commands::secrets::secrets_list,
+            commands::secrets::secrets_has_keyring,
+            commands::secrets::secrets_known_keys,
+            // Plugins
+            commands::plugins::plugins_discover,
+            commands::plugins::plugin_read_file,
+            // Misc
+            commands::misc::cli_get_group,
+            commands::misc::open_url,
+            commands::misc::is_test_mode,
+            commands::misc::frontend_log,
+        ])
+        .plugin(tauri_plugin_updater::Builder::new().build())
+        .plugin(tauri_plugin_dialog::init())
+        .setup(move |app| {
+            // Note: tauri-plugin-log is NOT initialized here because telemetry::init()
+            // already sets up tracing-subscriber (which bridges the `log` crate via
+            // tracing's compatibility layer). Adding plugin-log would panic with
+            // "attempted to set a logger after the logging system was already initialized".
+
+            let config = app_config_arc.clone();
+
+            // Create TauriEventSink for core managers
+            let sink: Arc<dyn bterminal_core::event::EventSink> =
+                Arc::new(TauriEventSink(app.handle().clone()));
+
+            // Build sidecar config from Tauri paths
+            let resource_dir = app
+                .handle()
+                .path()
+                .resource_dir()
+                .unwrap_or_else(|e| {
+                    log::warn!("Failed to resolve resource_dir: {e}");
+                    std::path::PathBuf::new()
+                });
+            let dev_root = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR"))
+                .parent()
+                .unwrap()
+                .to_path_buf();
+            // Install btmsg/bttask CLI tools to ~/.local/bin/
+            if !config.is_test_mode() {
+                install_cli_tools(&resource_dir, &dev_root);
+            }
+
+            // Forward test mode env vars to sidecar processes
+            let mut env_overrides = std::collections::HashMap::new();
+            if config.is_test_mode() {
+                env_overrides.insert("BTERMINAL_TEST".into(), "1".into());
+                if let Ok(v) = std::env::var("BTERMINAL_TEST_DATA_DIR") {
+                    env_overrides.insert("BTERMINAL_TEST_DATA_DIR".into(), v);
+                }
+                if let Ok(v) = std::env::var("BTERMINAL_TEST_CONFIG_DIR") {
+                    env_overrides.insert("BTERMINAL_TEST_CONFIG_DIR".into(), v);
+                }
+            }
+
+            let sidecar_config = SidecarConfig {
+                search_paths: vec![
+                    resource_dir.join("sidecar"),
+                    dev_root.join("sidecar"),
+                ],
+                env_overrides,
+                sandbox: bterminal_core::sandbox::SandboxConfig::default(),
+            };
+
+            let pty_manager = Arc::new(PtyManager::new(sink.clone()));
+            let sidecar_manager = Arc::new(SidecarManager::new(sink, sidecar_config));
+
+            // Initialize session database using AppConfig data_dir
+            let session_db = Arc::new(
+                SessionDb::open(config.sessions_db_dir()).expect("Failed to open session database"),
+            );
+
+            let file_watcher = Arc::new(FileWatcherManager::new());
+            let fs_watcher = Arc::new(ProjectFsWatcher::new());
+            let ctx_db = Arc::new(ctx::CtxDb::new_with_path(config.ctx_db_path.clone()));
+            let memora_db = Arc::new(memora::MemoraDb::new_with_path(config.memora_db_path.clone()));
+            let remote_manager = Arc::new(RemoteManager::new());
+
+            // Initialize FTS5 search database
+            let search_db_path = config.data_dir.join("bterminal").join("search.db");
+            let search_db = Arc::new(
+                search::SearchDb::open(&search_db_path).expect("Failed to open search database"),
+            );
+
+            // Start local sidecar
+            match sidecar_manager.start() {
+                Ok(()) => log::info!("Sidecar startup initiated"),
+                Err(e) => log::warn!("Sidecar startup failed (agent features unavailable): {e}"),
+            }
+
+            // Start periodic WAL checkpoint task (every 5 minutes)
+            let sessions_db_path = config.data_dir.join("sessions.db");
+            let btmsg_db_path = config.btmsg_db_path();
+            spawn_wal_checkpoint_task(sessions_db_path, btmsg_db_path);
+
+            app.manage(AppState {
+                pty_manager,
+                sidecar_manager,
+                session_db,
+                file_watcher,
+                fs_watcher,
+                ctx_db,
+                memora_db,
+                remote_manager,
+                search_db,
+                app_config: config,
+                _telemetry: telemetry_guard,
+            });
+
+            Ok(())
+        })
+        .run(tauri::generate_context!())
+        .expect("error while running tauri application");
+}
diff --git a/v2/src-tauri/src/main.rs b/v2/src-tauri/src/main.rs
new file mode 100644
index 0000000..82ee8eb
--- /dev/null
+++ b/v2/src-tauri/src/main.rs
@@ -0,0 +1,6 @@
+// Prevents additional console window on Windows in release, DO NOT REMOVE!!
+#![cfg_attr(not(debug_assertions), windows_subsystem = "windows")]
+
+fn main() {
+  bterminal_lib::run();
+}
diff --git a/v2/src-tauri/src/memora.rs b/v2/src-tauri/src/memora.rs
new file mode 100644
index 0000000..5297c90
--- /dev/null
+++ b/v2/src-tauri/src/memora.rs
@@ -0,0 +1,336 @@
+// memora — Read-only access to the Memora memory database
+// Database: ~/.local/share/memora/memories.db (managed by Memora MCP server)
+
+use rusqlite::{Connection, params};
+use serde::Serialize;
+use std::sync::Mutex;
+
+#[derive(Debug, Clone, Serialize)]
+pub struct MemoraNode {
+    pub id: i64,
+    pub content: String,
+    pub tags: Vec<String>,
+    pub metadata: Option<serde_json::Value>,
+    pub created_at: Option<String>,
+    pub updated_at: Option<String>,
+}
+
+#[derive(Debug, Clone, Serialize)]
+pub struct MemoraSearchResult {
+    pub nodes: Vec<MemoraNode>,
+    pub total: i64,
+}
+
+pub struct MemoraDb {
+    conn: Mutex<Option<Connection>>,
+}
+
+impl MemoraDb {
+    fn default_db_path() -> std::path::PathBuf {
+        dirs::data_dir()
+            .unwrap_or_else(|| dirs::home_dir().unwrap_or_default().join(".local/share"))
+            .join("memora")
+            .join("memories.db")
+    }
+
+    pub fn new() -> Self {
+        Self::new_with_path(Self::default_db_path())
+    }
+
+    /// Create a MemoraDb with a custom database path (for test isolation).
+    pub fn new_with_path(db_path: std::path::PathBuf) -> Self {
+        let conn = if db_path.exists() {
+            Connection::open_with_flags(
+                &db_path,
+                rusqlite::OpenFlags::SQLITE_OPEN_READ_ONLY | rusqlite::OpenFlags::SQLITE_OPEN_NO_MUTEX,
+            ).ok()
+        } else {
+            None
+        };
+
+        Self { conn: Mutex::new(conn) }
+    }
+
+    /// Check if the database connection is available.
+    pub fn is_available(&self) -> bool {
+        let lock = self.conn.lock().unwrap_or_else(|e| e.into_inner());
+        lock.is_some()
+    }
+
+    fn parse_row(row: &rusqlite::Row) -> rusqlite::Result<MemoraNode> {
+        let tags_raw: String = row.get(2)?;
+        let tags: Vec<String> = serde_json::from_str(&tags_raw).unwrap_or_default();
+
+        let meta_raw: Option<String> = row.get(3)?;
+        let metadata = meta_raw.and_then(|m| serde_json::from_str(&m).ok());
+
+        Ok(MemoraNode {
+            id: row.get(0)?,
+            content: row.get(1)?,
+            tags,
+            metadata,
+            created_at: row.get(4)?,
+            updated_at: row.get(5)?,
+        })
+    }
+
+    pub fn list(
+        &self,
+        tags: Option<Vec<String>>,
+        limit: i64,
+        offset: i64,
+    ) -> Result<MemoraSearchResult, String> {
+        let lock = self.conn.lock().map_err(|_| "memora database lock poisoned".to_string())?;
+        let conn = lock.as_ref().ok_or("memora database not found")?;
+
+        if let Some(ref tag_list) = tags {
+            if !tag_list.is_empty() {
+                return self.list_by_tags(conn, tag_list, limit, offset);
+            }
+        }
+
+        let total: i64 = conn
+            .query_row("SELECT COUNT(*) FROM memories", [], |r| r.get(0))
+            .map_err(|e| format!("memora count failed: {e}"))?;
+
+        let mut stmt = conn
+            .prepare(
+                "SELECT id, content, tags, metadata, created_at, updated_at
+                 FROM memories ORDER BY id DESC LIMIT ?1 OFFSET ?2",
+            )
+            .map_err(|e| format!("memora query failed: {e}"))?;
+
+        let nodes = stmt
+            .query_map(params![limit, offset], Self::parse_row)
+            .map_err(|e| format!("memora query failed: {e}"))?
+            .collect::<Result<Vec<_>, _>>()
+            .map_err(|e| format!("memora row read failed: {e}"))?;
+
+        Ok(MemoraSearchResult { nodes, total })
+    }
+
+    fn list_by_tags(
+        &self,
+        conn: &Connection,
+        tags: &[String],
+        limit: i64,
+        offset: i64,
+    ) -> Result<MemoraSearchResult, String> {
+        // Filter memories whose JSON tags array contains ANY of the given tags.
+        // Uses json_each() to expand the tags array and match against the filter list.
+        let placeholders: Vec<String> = tags.iter().enumerate().map(|(i, _)| format!("?{}", i + 1)).collect();
+        let in_clause = placeholders.join(", ");
+
+        let count_sql = format!(
+            "SELECT COUNT(DISTINCT m.id) FROM memories m, json_each(m.tags) j WHERE j.value IN ({in_clause})"
+        );
+        let query_sql = format!(
+            "SELECT DISTINCT m.id, m.content, m.tags, m.metadata, m.created_at, m.updated_at
+             FROM memories m, json_each(m.tags) j
+             WHERE j.value IN ({in_clause})
+             ORDER BY m.id DESC LIMIT ?{} OFFSET ?{}",
+            tags.len() + 1,
+            tags.len() + 2,
+        );
+
+        let tag_params: Vec<&dyn rusqlite::ToSql> = tags.iter().map(|t| t as &dyn rusqlite::ToSql).collect();
+
+        let count_params = tag_params.clone();
+        let total: i64 = conn
+            .query_row(&count_sql, count_params.as_slice(), |r| r.get(0))
+            .map_err(|e| format!("memora count failed: {e}"))?;
+
+        let mut query_params = tag_params;
+        query_params.push(&limit);
+        query_params.push(&offset);
+
+        let mut stmt = conn
+            .prepare(&query_sql)
+            .map_err(|e| format!("memora query failed: {e}"))?;
+
+        let nodes = stmt
+            .query_map(query_params.as_slice(), Self::parse_row)
+            .map_err(|e| format!("memora query failed: {e}"))?
+            .collect::<Result<Vec<_>, _>>()
+            .map_err(|e| format!("memora row read failed: {e}"))?;
+
+        Ok(MemoraSearchResult { nodes, total })
+    }
+
+    pub fn search(
+        &self,
+        query: &str,
+        tags: Option<Vec<String>>,
+        limit: i64,
+    ) -> Result<MemoraSearchResult, String> {
+        let lock = self.conn.lock().map_err(|_| "memora database lock poisoned".to_string())?;
+        let conn = lock.as_ref().ok_or("memora database not found")?;
+
+        // Use FTS5 for text search with optional tag filter
+        let fts_query = query.to_string();
+
+        if let Some(ref tag_list) = tags {
+            if !tag_list.is_empty() {
+                return self.search_with_tags(conn, &fts_query, tag_list, limit);
+            }
+        }
+
+        let mut stmt = conn
+            .prepare(
+                "SELECT m.id, m.content, m.tags, m.metadata, m.created_at, m.updated_at
+                 FROM memories_fts f
+                 JOIN memories m ON m.id = f.rowid
+                 WHERE memories_fts MATCH ?1
+                 ORDER BY rank
+                 LIMIT ?2",
+            )
+            .map_err(|e| format!("memora search failed: {e}"))?;
+
+        let nodes = stmt
+            .query_map(params![fts_query, limit], Self::parse_row)
+            .map_err(|e| {
+                let msg = e.to_string();
+                if msg.contains("fts5") || msg.contains("syntax") {
+                    format!("Invalid search query: {e}")
+                } else {
+                    format!("memora search failed: {e}")
+                }
+            })?
+            .collect::<Result<Vec<_>, _>>()
+            .map_err(|e| format!("memora row read failed: {e}"))?;
+
+        let total = nodes.len() as i64;
+        Ok(MemoraSearchResult { nodes, total })
+    }
+
+    fn search_with_tags(
+        &self,
+        conn: &Connection,
+        query: &str,
+        tags: &[String],
+        limit: i64,
+    ) -> Result<MemoraSearchResult, String> {
+        let placeholders: Vec<String> = tags.iter().enumerate().map(|(i, _)| format!("?{}", i + 3)).collect();
+        let in_clause = placeholders.join(", ");
+
+        let sql = format!(
+            "SELECT DISTINCT m.id, m.content, m.tags, m.metadata, m.created_at, m.updated_at
+             FROM memories_fts f
+             JOIN memories m ON m.id = f.rowid
+             JOIN json_each(m.tags) j ON j.value IN ({in_clause})
+             WHERE memories_fts MATCH ?1
+             ORDER BY rank
+             LIMIT ?2"
+        );
+
+        let mut params: Vec<Box<dyn rusqlite::ToSql>> = Vec::new();
+        params.push(Box::new(query.to_string()));
+        params.push(Box::new(limit));
+        for tag in tags {
+            params.push(Box::new(tag.clone()));
+        }
+        let param_refs: Vec<&dyn rusqlite::ToSql> = params.iter().map(|p| p.as_ref()).collect();
+
+        let mut stmt = conn
+            .prepare(&sql)
+            .map_err(|e| format!("memora search failed: {e}"))?;
+
+        let nodes = stmt
+            .query_map(param_refs.as_slice(), Self::parse_row)
+            .map_err(|e| {
+                let msg = e.to_string();
+                if msg.contains("fts5") || msg.contains("syntax") {
+                    format!("Invalid search query: {e}")
+                } else {
+                    format!("memora search failed: {e}")
+                }
+            })?
+            .collect::<Result<Vec<_>, _>>()
+            .map_err(|e| format!("memora row read failed: {e}"))?;
+
+        let total = nodes.len() as i64;
+        Ok(MemoraSearchResult { nodes, total })
+    }
+
+    pub fn get(&self, id: i64) -> Result<Option<MemoraNode>, String> {
+        let lock = self.conn.lock().map_err(|_| "memora database lock poisoned".to_string())?;
+        let conn = lock.as_ref().ok_or("memora database not found")?;
+
+        let mut stmt = conn
+            .prepare(
+                "SELECT id, content, tags, metadata, created_at, updated_at
+                 FROM memories WHERE id = ?1",
+            )
+            .map_err(|e| format!("memora query failed: {e}"))?;
+
+        let mut rows = stmt
+            .query_map(params![id], Self::parse_row)
+            .map_err(|e| format!("memora query failed: {e}"))?;
+
+        match rows.next() {
+            Some(Ok(node)) => Ok(Some(node)),
+            Some(Err(e)) => Err(format!("memora row read failed: {e}")),
+            None => Ok(None),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn make_missing_db() -> MemoraDb {
+        MemoraDb { conn: Mutex::new(None) }
+    }
+
+    #[test]
+    fn test_new_does_not_panic() {
+        let _db = MemoraDb::new();
+    }
+
+    #[test]
+    fn test_missing_db_not_available() {
+        let db = make_missing_db();
+        assert!(!db.is_available());
+    }
+
+    #[test]
+    fn test_list_missing_db_returns_error() {
+        let db = make_missing_db();
+        let result = db.list(None, 50, 0);
+        assert!(result.is_err());
+        assert_eq!(result.unwrap_err(), "memora database not found");
+    }
+
+    #[test]
+    fn test_search_missing_db_returns_error() {
+        let db = make_missing_db();
+        let result = db.search("test", None, 50);
+        assert!(result.is_err());
+        assert_eq!(result.unwrap_err(), "memora database not found");
+    }
+
+    #[test]
+    fn test_get_missing_db_returns_error() {
+        let db = make_missing_db();
+        let result = db.get(1);
+        assert!(result.is_err());
+        assert_eq!(result.unwrap_err(), "memora database not found");
+    }
+
+    #[test]
+    fn test_list_with_tags_missing_db_returns_error() {
+        let db = make_missing_db();
+        let result = db.list(Some(vec!["bterminal".to_string()]), 50, 0);
+        assert!(result.is_err());
+        assert_eq!(result.unwrap_err(), "memora database not found");
+    }
+
+    #[test]
+    fn test_search_with_tags_missing_db_returns_error() {
+        let db = make_missing_db();
+        let result = db.search("test", Some(vec!["bterminal".to_string()]), 50);
+        assert!(result.is_err());
+        assert_eq!(result.unwrap_err(), "memora database not found");
+    }
+}
diff --git a/v2/src-tauri/src/notifications.rs b/v2/src-tauri/src/notifications.rs
new file mode 100644
index 0000000..9f9b4e6
--- /dev/null
+++ b/v2/src-tauri/src/notifications.rs
@@ -0,0 +1,31 @@
+// Desktop notification support via notify-rust
+
+use notify_rust::{Notification, Urgency};
+
+/// Send an OS desktop notification.
+/// Fails gracefully if the notification daemon is unavailable.
+pub fn send_desktop_notification(
+    title: &str,
+    body: &str,
+    urgency: &str,
+) -> Result<(), String> {
+    let urgency_level = match urgency {
+        "critical" => Urgency::Critical,
+        "low" => Urgency::Low,
+        _ => Urgency::Normal,
+    };
+
+    match Notification::new()
+        .summary(title)
+        .body(body)
+        .appname("BTerminal")
+        .urgency(urgency_level)
+        .show()
+    {
+        Ok(_) => Ok(()),
+        Err(e) => {
+            tracing::warn!("Desktop notification failed (daemon unavailable?): {e}");
+            Ok(()) // Graceful — don't propagate to frontend
+        }
+    }
+}
diff --git a/v2/src-tauri/src/plugins.rs b/v2/src-tauri/src/plugins.rs
new file mode 100644
index 0000000..488abae
--- /dev/null
+++ b/v2/src-tauri/src/plugins.rs
@@ -0,0 +1,265 @@
+// Plugin discovery and file reading.
+// Scans ~/.config/bterminal/plugins/ for plugin.json manifest files.
+// Each plugin lives in its own subdirectory with a plugin.json manifest.
+
+use serde::{Deserialize, Serialize};
+use std::path::{Path, PathBuf};
+
+/// Plugin manifest — parsed from plugin.json
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct PluginMeta {
+    pub id: String,
+    pub name: String,
+    pub version: String,
+    #[serde(default)]
+    pub description: String,
+    /// Entry JS file relative to plugin directory
+    pub main: String,
+    /// Permission strings: "palette", "btmsg:read", "bttask:read", "events"
+    #[serde(default)]
+    pub permissions: Vec<String>,
+}
+
+const VALID_PERMISSIONS: &[&str] = &["palette", "btmsg:read", "bttask:read", "events"];
+
+/// Validate plugin ID: alphanumeric + hyphens only, 1-64 chars
+fn is_valid_plugin_id(id: &str) -> bool {
+    !id.is_empty()
+        && id.len() <= 64
+        && id
+            .chars()
+            .all(|c| c.is_ascii_alphanumeric() || c == '-')
+}
+
+/// Discover all plugins in the given plugins directory.
+/// Each plugin must have a plugin.json manifest file.
+pub fn discover_plugins(plugins_dir: &Path) -> Vec<PluginMeta> {
+    let mut plugins = Vec::new();
+
+    let entries = match std::fs::read_dir(plugins_dir) {
+        Ok(e) => e,
+        Err(_) => return plugins,
+    };
+
+    for entry in entries.flatten() {
+        let path = entry.path();
+        if !path.is_dir() {
+            continue;
+        }
+
+        let manifest_path = path.join("plugin.json");
+        if !manifest_path.exists() {
+            continue;
+        }
+
+        let content = match std::fs::read_to_string(&manifest_path) {
+            Ok(c) => c,
+            Err(e) => {
+                log::warn!(
+                    "Failed to read plugin manifest {}: {e}",
+                    manifest_path.display()
+                );
+                continue;
+            }
+        };
+
+        let meta: PluginMeta = match serde_json::from_str(&content) {
+            Ok(m) => m,
+            Err(e) => {
+                log::warn!(
+                    "Invalid plugin manifest {}: {e}",
+                    manifest_path.display()
+                );
+                continue;
+            }
+        };
+
+        // Validate plugin ID
+        if !is_valid_plugin_id(&meta.id) {
+            log::warn!(
+                "Plugin at {} has invalid ID '{}' — skipping",
+                path.display(),
+                meta.id
+            );
+            continue;
+        }
+
+        // Validate permissions
+        for perm in &meta.permissions {
+            if !VALID_PERMISSIONS.contains(&perm.as_str()) {
+                log::warn!(
+                    "Plugin '{}' requests unknown permission '{}' — skipping",
+                    meta.id,
+                    perm
+                );
+                continue;
+            }
+        }
+
+        plugins.push(meta);
+    }
+
+    plugins
+}
+
+/// Read a file from a plugin directory, with path traversal prevention.
+/// Only files within the plugin's own directory are accessible.
+pub fn read_plugin_file(
+    plugins_dir: &Path,
+    plugin_id: &str,
+    filename: &str,
+) -> Result<String, String> {
+    if !is_valid_plugin_id(plugin_id) {
+        return Err("Invalid plugin ID".to_string());
+    }
+
+    let plugin_dir = plugins_dir.join(plugin_id);
+    if !plugin_dir.is_dir() {
+        return Err(format!("Plugin directory not found: {}", plugin_id));
+    }
+
+    // Canonicalize the plugin directory to resolve symlinks
+    let canonical_plugin_dir = plugin_dir
+        .canonicalize()
+        .map_err(|e| format!("Failed to resolve plugin directory: {e}"))?;
+
+    let target = plugin_dir.join(filename);
+    let canonical_target = target
+        .canonicalize()
+        .map_err(|e| format!("Failed to resolve file path: {e}"))?;
+
+    // Path traversal prevention: target must be within plugin directory
+    if !canonical_target.starts_with(&canonical_plugin_dir) {
+        return Err("Access denied: path is outside plugin directory".to_string());
+    }
+
+    std::fs::read_to_string(&canonical_target)
+        .map_err(|e| format!("Failed to read plugin file: {e}"))
+}
+
+/// Get the plugins directory path from a config directory
+pub fn plugins_dir(config_dir: &Path) -> PathBuf {
+    config_dir.join("plugins")
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::fs;
+
+    #[test]
+    fn test_valid_plugin_ids() {
+        assert!(is_valid_plugin_id("my-plugin"));
+        assert!(is_valid_plugin_id("hello123"));
+        assert!(is_valid_plugin_id("a"));
+        assert!(!is_valid_plugin_id(""));
+        assert!(!is_valid_plugin_id("my_plugin")); // underscore not allowed
+        assert!(!is_valid_plugin_id("my plugin")); // space not allowed
+        assert!(!is_valid_plugin_id("../evil"));   // path traversal chars
+        assert!(!is_valid_plugin_id(&"a".repeat(65))); // too long
+    }
+
+    #[test]
+    fn test_discover_plugins_empty_dir() {
+        let dir = tempfile::tempdir().unwrap();
+        let plugins = discover_plugins(dir.path());
+        assert!(plugins.is_empty());
+    }
+
+    #[test]
+    fn test_discover_plugins_nonexistent_dir() {
+        let plugins = discover_plugins(Path::new("/nonexistent/path"));
+        assert!(plugins.is_empty());
+    }
+
+    #[test]
+    fn test_discover_plugins_valid_manifest() {
+        let dir = tempfile::tempdir().unwrap();
+        let plugin_dir = dir.path().join("test-plugin");
+        fs::create_dir(&plugin_dir).unwrap();
+        fs::write(
+            plugin_dir.join("plugin.json"),
+            r#"{
+                "id": "test-plugin",
+                "name": "Test Plugin",
+                "version": "1.0.0",
+                "description": "A test plugin",
+                "main": "index.js",
+                "permissions": ["palette"]
+            }"#,
+        )
+        .unwrap();
+        fs::write(plugin_dir.join("index.js"), "// test").unwrap();
+
+        let plugins = discover_plugins(dir.path());
+        assert_eq!(plugins.len(), 1);
+        assert_eq!(plugins[0].id, "test-plugin");
+        assert_eq!(plugins[0].name, "Test Plugin");
+        assert_eq!(plugins[0].permissions, vec!["palette"]);
+    }
+
+    #[test]
+    fn test_discover_plugins_invalid_id_skipped() {
+        let dir = tempfile::tempdir().unwrap();
+        let plugin_dir = dir.path().join("bad_plugin");
+        fs::create_dir(&plugin_dir).unwrap();
+        fs::write(
+            plugin_dir.join("plugin.json"),
+            r#"{
+                "id": "bad_plugin",
+                "name": "Bad",
+                "version": "1.0.0",
+                "main": "index.js"
+            }"#,
+        )
+        .unwrap();
+
+        let plugins = discover_plugins(dir.path());
+        assert!(plugins.is_empty());
+    }
+
+    #[test]
+    fn test_read_plugin_file_success() {
+        let dir = tempfile::tempdir().unwrap();
+        let plugin_dir = dir.path().join("my-plugin");
+        fs::create_dir(&plugin_dir).unwrap();
+        fs::write(plugin_dir.join("index.js"), "console.log('hello');").unwrap();
+
+        let result = read_plugin_file(dir.path(), "my-plugin", "index.js");
+        assert_eq!(result.unwrap(), "console.log('hello');");
+    }
+
+    #[test]
+    fn test_read_plugin_file_path_traversal_blocked() {
+        let dir = tempfile::tempdir().unwrap();
+        let plugin_dir = dir.path().join("my-plugin");
+        fs::create_dir(&plugin_dir).unwrap();
+        fs::write(plugin_dir.join("index.js"), "ok").unwrap();
+
+        let result = read_plugin_file(dir.path(), "my-plugin", "../../../etc/passwd");
+        assert!(result.is_err());
+        let err = result.unwrap_err();
+        assert!(err.contains("outside plugin directory") || err.contains("Failed to resolve"));
+    }
+
+    #[test]
+    fn test_read_plugin_file_invalid_id() {
+        let dir = tempfile::tempdir().unwrap();
+        let result = read_plugin_file(dir.path(), "../evil", "index.js");
+        assert!(result.is_err());
+        assert!(result.unwrap_err().contains("Invalid plugin ID"));
+    }
+
+    #[test]
+    fn test_read_plugin_file_nonexistent_plugin() {
+        let dir = tempfile::tempdir().unwrap();
+        let result = read_plugin_file(dir.path(), "nonexistent", "index.js");
+        assert!(result.is_err());
+    }
+
+    #[test]
+    fn test_plugins_dir_path() {
+        let config = Path::new("/home/user/.config/bterminal");
+        assert_eq!(plugins_dir(config), PathBuf::from("/home/user/.config/bterminal/plugins"));
+    }
+}
diff --git a/v2/src-tauri/src/pty.rs b/v2/src-tauri/src/pty.rs
new file mode 100644
index 0000000..c0d8c25
--- /dev/null
+++ b/v2/src-tauri/src/pty.rs
@@ -0,0 +1,4 @@
+// Thin wrapper — re-exports bterminal_core::pty types.
+// PtyManager is now in bterminal-core; this module only re-exports for lib.rs.
+
+pub use bterminal_core::pty::{PtyManager, PtyOptions};
diff --git a/v2/src-tauri/src/remote.rs b/v2/src-tauri/src/remote.rs
new file mode 100644
index 0000000..f5aa668
--- /dev/null
+++ b/v2/src-tauri/src/remote.rs
@@ -0,0 +1,461 @@
+// Remote machine management — WebSocket client connections to bterminal-relay instances
+
+use bterminal_core::pty::PtyOptions;
+use bterminal_core::sidecar::AgentQueryOptions;
+use futures_util::{SinkExt, StreamExt};
+use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
+use std::sync::Arc;
+use tauri::{AppHandle, Emitter};
+use tokio::sync::{Mutex, mpsc};
+use tokio_tungstenite::tungstenite::Message;
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct RemoteMachineConfig {
+    pub label: String,
+    pub url: String,
+    pub token: String,
+    pub auto_connect: bool,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct RemoteMachineInfo {
+    pub id: String,
+    pub label: String,
+    pub url: String,
+    pub status: String,
+    pub auto_connect: bool,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+struct RelayCommand {
+    id: String,
+    #[serde(rename = "type")]
+    type_: String,
+    payload: serde_json::Value,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+struct RelayEvent {
+    #[serde(rename = "type")]
+    type_: String,
+    #[serde(rename = "sessionId")]
+    session_id: Option<String>,
+    #[serde(rename = "machineId")]
+    machine_id: Option<String>,
+    payload: Option<serde_json::Value>,
+}
+
+struct WsConnection {
+    tx: mpsc::UnboundedSender<String>,
+    _handle: tokio::task::JoinHandle<()>,
+}
+
+struct RemoteMachine {
+    id: String,
+    config: RemoteMachineConfig,
+    status: String,
+    connection: Option<WsConnection>,
+    /// Cancellation signal — set to true to stop reconnect loops for this machine
+    cancelled: Arc<std::sync::atomic::AtomicBool>,
+}
+
+pub struct RemoteManager {
+    machines: Arc<Mutex<HashMap<String, RemoteMachine>>>,
+}
+
+impl RemoteManager {
+    pub fn new() -> Self {
+        Self {
+            machines: Arc::new(Mutex::new(HashMap::new())),
+        }
+    }
+
+    pub async fn list_machines(&self) -> Vec<RemoteMachineInfo> {
+        let machines = self.machines.lock().await;
+        machines.values().map(|m| RemoteMachineInfo {
+            id: m.id.clone(),
+            label: m.config.label.clone(),
+            url: m.config.url.clone(),
+            status: m.status.clone(),
+            auto_connect: m.config.auto_connect,
+        }).collect()
+    }
+
+    pub async fn add_machine(&self, config: RemoteMachineConfig) -> String {
+        let id = uuid::Uuid::new_v4().to_string();
+        let machine = RemoteMachine {
+            id: id.clone(),
+            config,
+            status: "disconnected".to_string(),
+            connection: None,
+            cancelled: Arc::new(std::sync::atomic::AtomicBool::new(false)),
+        };
+        self.machines.lock().await.insert(id.clone(), machine);
+        id
+    }
+
+    pub async fn remove_machine(&self, machine_id: &str) -> Result<(), String> {
+        let mut machines = self.machines.lock().await;
+        if let Some(machine) = machines.get_mut(machine_id) {
+            // Signal cancellation to stop any reconnect loops
+            machine.cancelled.store(true, std::sync::atomic::Ordering::Relaxed);
+            // Abort connection tasks before removing to prevent resource leaks
+            if let Some(conn) = machine.connection.take() {
+                conn._handle.abort();
+            }
+        }
+        machines.remove(machine_id)
+            .ok_or_else(|| format!("Machine {machine_id} not found"))?;
+        Ok(())
+    }
+
+    pub async fn connect(&self, app: &AppHandle, machine_id: &str) -> Result<(), String> {
+        let (url, token) = {
+            let mut machines = self.machines.lock().await;
+            let machine = machines.get_mut(machine_id)
+                .ok_or_else(|| format!("Machine {machine_id} not found"))?;
+            if machine.connection.is_some() {
+                return Err("Already connected".to_string());
+            }
+            machine.status = "connecting".to_string();
+            // Reset cancellation flag for new connection
+            machine.cancelled.store(false, std::sync::atomic::Ordering::Relaxed);
+            (machine.config.url.clone(), machine.config.token.clone())
+        };
+
+        // Build WebSocket request with auth header
+        let request = tokio_tungstenite::tungstenite::http::Request::builder()
+            .uri(&url)
+            .header("Authorization", format!("Bearer {token}"))
+            .header("Sec-WebSocket-Key", tokio_tungstenite::tungstenite::handshake::client::generate_key())
+            .header("Sec-WebSocket-Version", "13")
+            .header("Connection", "Upgrade")
+            .header("Upgrade", "websocket")
+            .header("Host", extract_host(&url).unwrap_or_default())
+            .body(())
+            .map_err(|e| format!("Failed to build request: {e}"))?;
+
+        let (ws_stream, _) = tokio_tungstenite::connect_async(request)
+            .await
+            .map_err(|e| format!("WebSocket connect failed: {e}"))?;
+
+        let (mut ws_tx, mut ws_rx) = ws_stream.split();
+
+        // Channel for sending messages to the WebSocket
+        let (send_tx, mut send_rx) = mpsc::unbounded_channel::<String>();
+
+        // Writer task — forwards channel messages to WebSocket
+        let writer_handle = tokio::spawn(async move {
+            while let Some(msg) = send_rx.recv().await {
+                if ws_tx.send(Message::Text(msg)).await.is_err() {
+                    break;
+                }
+            }
+        });
+
+        // Reader task — forwards WebSocket messages to Tauri events
+        let app_handle = app.clone();
+        let mid = machine_id.to_string();
+        let machines_ref = self.machines.clone();
+        let cancelled_flag = {
+            let machines = self.machines.lock().await;
+            machines.get(machine_id).map(|m| m.cancelled.clone())
+                .unwrap_or_else(|| Arc::new(std::sync::atomic::AtomicBool::new(false)))
+        };
+        let reader_handle = tokio::spawn(async move {
+            while let Some(msg) = ws_rx.next().await {
+                match msg {
+                    Ok(Message::Text(text)) => {
+                        if let Ok(mut event) = serde_json::from_str::<RelayEvent>(&text) {
+                            event.machine_id = Some(mid.clone());
+                            // Route relay events to Tauri events
+                            match event.type_.as_str() {
+                                "sidecar_message" => {
+                                    if let Some(payload) = &event.payload {
+                                        let _ = app_handle.emit("remote-sidecar-message", &serde_json::json!({
+                                            "machineId": mid,
+                                            "sessionId": event.session_id,
+                                            "event": payload,
+                                        }));
+                                    }
+                                }
+                                "pty_data" => {
+                                    if let Some(payload) = &event.payload {
+                                        let _ = app_handle.emit("remote-pty-data", &serde_json::json!({
+                                            "machineId": mid,
+                                            "sessionId": event.session_id,
+                                            "data": payload,
+                                        }));
+                                    }
+                                }
+                                "pty_exit" => {
+                                    let _ = app_handle.emit("remote-pty-exit", &serde_json::json!({
+                                        "machineId": mid,
+                                        "sessionId": event.session_id,
+                                    }));
+                                }
+                                "ready" => {
+                                    let _ = app_handle.emit("remote-machine-ready", &serde_json::json!({
+                                        "machineId": mid,
+                                    }));
+                                }
+                                "state_sync" => {
+                                    let _ = app_handle.emit("remote-state-sync", &serde_json::json!({
+                                        "machineId": mid,
+                                        "payload": event.payload,
+                                    }));
+                                }
+                                "pty_created" => {
+                                    // Relay confirmed PTY spawn — emit with real PTY ID
+                                    let _ = app_handle.emit("remote-pty-created", &serde_json::json!({
+                                        "machineId": mid,
+                                        "ptyId": event.session_id,
+                                        "commandId": event.payload.as_ref().and_then(|p| p.get("commandId")).and_then(|v| v.as_str()),
+                                    }));
+                                }
+                                "pong" => {} // heartbeat response, ignore
+                                "error" => {
+                                    let _ = app_handle.emit("remote-error", &serde_json::json!({
+                                        "machineId": mid,
+                                        "error": event.payload,
+                                    }));
+                                }
+                                _ => {
+                                    log::warn!("Unknown relay event type: {}", event.type_);
+                                }
+                            }
+                        }
+                    }
+                    Ok(Message::Close(_)) => break,
+                    Err(e) => {
+                        log::error!("WebSocket read error for machine {mid}: {e}");
+                        break;
+                    }
+                    _ => {}
+                }
+            }
+
+            // Mark disconnected and clear connection
+            {
+                let mut machines = machines_ref.lock().await;
+                if let Some(machine) = machines.get_mut(&mid) {
+                    machine.status = "disconnected".to_string();
+                    machine.connection = None;
+                }
+            }
+            let _ = app_handle.emit("remote-machine-disconnected", &serde_json::json!({
+                "machineId": mid,
+            }));
+
+            // Exponential backoff reconnection (1s, 2s, 4s, 8s, 16s, 30s cap)
+            let reconnect_machines = machines_ref.clone();
+            let reconnect_app = app_handle.clone();
+            let reconnect_mid = mid.clone();
+            let reconnect_cancelled = cancelled_flag.clone();
+            tokio::spawn(async move {
+                let mut delay = std::time::Duration::from_secs(1);
+                let max_delay = std::time::Duration::from_secs(30);
+
+                loop {
+                    tokio::time::sleep(delay).await;
+
+                    // Check cancellation flag first (set by remove_machine/disconnect)
+                    if reconnect_cancelled.load(std::sync::atomic::Ordering::Relaxed) {
+                        log::info!("Reconnection cancelled (machine removed) for {reconnect_mid}");
+                        break;
+                    }
+
+                    // Check if machine still exists and wants reconnection
+                    let should_reconnect = {
+                        let machines = reconnect_machines.lock().await;
+                        machines.get(&reconnect_mid)
+                            .map(|m| m.status == "disconnected" && m.connection.is_none())
+                            .unwrap_or(false)
+                    };
+
+                    if !should_reconnect {
+                        log::info!("Reconnection cancelled for machine {reconnect_mid}");
+                        break;
+                    }
+
+                    log::info!("Attempting reconnection to {reconnect_mid} (backoff: {}s)", delay.as_secs());
+                    let _ = reconnect_app.emit("remote-machine-reconnecting", &serde_json::json!({
+                        "machineId": reconnect_mid,
+                        "backoffSecs": delay.as_secs(),
+                    }));
+
+                    // Try to get URL for TCP probe
+                    let url = {
+                        let machines = reconnect_machines.lock().await;
+                        machines.get(&reconnect_mid).map(|m| m.config.url.clone())
+                    };
+
+                    if let Some(url) = url {
+                        if attempt_tcp_probe(&url).await.is_ok() {
+                            log::info!("Reconnection probe succeeded for {reconnect_mid}");
+                            // Mark as ready for reconnection — frontend should call connect()
+                            let _ = reconnect_app.emit("remote-machine-reconnect-ready", &serde_json::json!({
+                                "machineId": reconnect_mid,
+                            }));
+                            break;
+                        }
+                    } else {
+                        break; // Machine removed
+                    }
+
+                    delay = std::cmp::min(delay * 2, max_delay);
+                }
+            });
+        });
+
+        // Combine reader + writer into one handle
+        let combined_handle = tokio::spawn(async move {
+            tokio::select! {
+                _ = reader_handle => {}
+                _ = writer_handle => {}
+            }
+        });
+
+        // Store connection
+        let mut machines = self.machines.lock().await;
+        if let Some(machine) = machines.get_mut(machine_id) {
+            machine.status = "connected".to_string();
+            machine.connection = Some(WsConnection {
+                tx: send_tx,
+                _handle: combined_handle,
+            });
+        }
+
+        // Start heartbeat
+        let ping_tx = {
+            let machines = self.machines.lock().await;
+            machines.get(machine_id).and_then(|m| m.connection.as_ref().map(|c| c.tx.clone()))
+        };
+        if let Some(tx) = ping_tx {
+            let mid = machine_id.to_string();
+            tokio::spawn(async move {
+                let mut interval = tokio::time::interval(std::time::Duration::from_secs(15));
+                loop {
+                    interval.tick().await;
+                    let ping = serde_json::json!({"id": "", "type": "ping", "payload": {}});
+                    if tx.send(ping.to_string()).is_err() {
+                        log::info!("Heartbeat stopped for machine {mid}");
+                        break;
+                    }
+                }
+            });
+        }
+
+        Ok(())
+    }
+
+    pub async fn disconnect(&self, machine_id: &str) -> Result<(), String> {
+        let mut machines = self.machines.lock().await;
+        let machine = machines.get_mut(machine_id)
+            .ok_or_else(|| format!("Machine {machine_id} not found"))?;
+        // Signal cancellation to stop any reconnect loops
+        machine.cancelled.store(true, std::sync::atomic::Ordering::Relaxed);
+        if let Some(conn) = machine.connection.take() {
+            conn._handle.abort();
+        }
+        machine.status = "disconnected".to_string();
+        Ok(())
+    }
+
+    // --- Remote command helpers ---
+
+    async fn send_command(&self, machine_id: &str, cmd: RelayCommand) -> Result<(), String> {
+        let machines = self.machines.lock().await;
+        let machine = machines.get(machine_id)
+            .ok_or_else(|| format!("Machine {machine_id} not found"))?;
+        let conn = machine.connection.as_ref()
+            .ok_or_else(|| format!("Machine {machine_id} not connected"))?;
+        let json = serde_json::to_string(&cmd)
+            .map_err(|e| format!("Serialize error: {e}"))?;
+        conn.tx.send(json)
+            .map_err(|_| format!("Send channel closed for machine {machine_id}"))
+    }
+
+    pub async fn agent_query(&self, machine_id: &str, options: &AgentQueryOptions) -> Result<(), String> {
+        self.send_command(machine_id, RelayCommand {
+            id: uuid::Uuid::new_v4().to_string(),
+            type_: "agent_query".to_string(),
+            payload: serde_json::to_value(options).unwrap_or_default(),
+        }).await
+    }
+
+    pub async fn agent_stop(&self, machine_id: &str, session_id: &str) -> Result<(), String> {
+        self.send_command(machine_id, RelayCommand {
+            id: uuid::Uuid::new_v4().to_string(),
+            type_: "agent_stop".to_string(),
+            payload: serde_json::json!({ "sessionId": session_id }),
+        }).await
+    }
+
+    pub async fn pty_spawn(&self, machine_id: &str, options: &PtyOptions) -> Result<String, String> {
+        // Send spawn command; the relay will respond with the PTY ID via a relay event
+        let cmd_id = uuid::Uuid::new_v4().to_string();
+        self.send_command(machine_id, RelayCommand {
+            id: cmd_id.clone(),
+            type_: "pty_create".to_string(),
+            payload: serde_json::to_value(options).unwrap_or_default(),
+        }).await?;
+        // Return the command ID as a placeholder; the real PTY ID comes via event
+        Ok(cmd_id)
+    }
+
+    pub async fn pty_write(&self, machine_id: &str, id: &str, data: &str) -> Result<(), String> {
+        self.send_command(machine_id, RelayCommand {
+            id: uuid::Uuid::new_v4().to_string(),
+            type_: "pty_write".to_string(),
+            payload: serde_json::json!({ "id": id, "data": data }),
+        }).await
+    }
+
+    pub async fn pty_resize(&self, machine_id: &str, id: &str, cols: u16, rows: u16) -> Result<(), String> {
+        self.send_command(machine_id, RelayCommand {
+            id: uuid::Uuid::new_v4().to_string(),
+            type_: "pty_resize".to_string(),
+            payload: serde_json::json!({ "id": id, "cols": cols, "rows": rows }),
+        }).await
+    }
+
+    pub async fn pty_kill(&self, machine_id: &str, id: &str) -> Result<(), String> {
+        self.send_command(machine_id, RelayCommand {
+            id: uuid::Uuid::new_v4().to_string(),
+            type_: "pty_close".to_string(),
+            payload: serde_json::json!({ "id": id }),
+        }).await
+    }
+}
+
+/// Probe whether a relay is reachable via TCP connect only (no WS upgrade).
+/// This avoids allocating per-connection resources (PtyManager, SidecarManager) on the relay.
+async fn attempt_tcp_probe(url: &str) -> Result<(), String> {
+    let host = extract_host(url).ok_or_else(|| "Invalid URL".to_string())?;
+    // Parse host:port, default to 9750 if no port
+    let addr = if host.contains(':') {
+        host.clone()
+    } else {
+        format!("{host}:9750")
+    };
+
+    tokio::time::timeout(
+        std::time::Duration::from_secs(5),
+        tokio::net::TcpStream::connect(&addr),
+    )
+    .await
+    .map_err(|_| "Connection timeout".to_string())?
+    .map_err(|e| format!("TCP connect failed: {e}"))?;
+
+    Ok(())
+}
+
+fn extract_host(url: &str) -> Option<String> {
+    url.replace("wss://", "")
+        .replace("ws://", "")
+        .split('/')
+        .next()
+        .map(|s| s.to_string())
+}
diff --git a/v2/src-tauri/src/search.rs b/v2/src-tauri/src/search.rs
new file mode 100644
index 0000000..f4116cd
--- /dev/null
+++ b/v2/src-tauri/src/search.rs
@@ -0,0 +1,403 @@
+// search — FTS5 full-text search across messages, tasks, and btmsg
+// Uses sessions.db for search index (separate from btmsg.db source tables).
+// Index populated via explicit index_* calls; rebuild re-reads from source tables.
+
+use rusqlite::{params, Connection};
+use serde::{Deserialize, Serialize};
+use std::path::PathBuf;
+use std::sync::Mutex;
+
+pub struct SearchDb {
+    conn: Mutex<Connection>,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct SearchResult {
+    pub result_type: String,
+    pub id: String,
+    pub title: String,
+    pub snippet: String,
+    pub score: f64,
+}
+
+impl SearchDb {
+    /// Open (or create) the search database and initialize FTS5 tables.
+    pub fn open(db_path: &PathBuf) -> Result<Self, String> {
+        if let Some(parent) = db_path.parent() {
+            std::fs::create_dir_all(parent)
+                .map_err(|e| format!("Failed to create search db dir: {e}"))?;
+        }
+        let conn = Connection::open(db_path)
+            .map_err(|e| format!("Failed to open search db: {e}"))?;
+        conn.query_row("PRAGMA journal_mode=WAL", [], |_| Ok(()))
+            .map_err(|e| format!("Failed to set WAL mode: {e}"))?;
+
+        let db = Self {
+            conn: Mutex::new(conn),
+        };
+        db.create_tables()?;
+        Ok(db)
+    }
+
+    /// Create FTS5 virtual tables if they don't already exist.
+    fn create_tables(&self) -> Result<(), String> {
+        let conn = self.conn.lock().unwrap();
+        conn.execute_batch(
+            "CREATE VIRTUAL TABLE IF NOT EXISTS search_messages USING fts5(
+                session_id,
+                role,
+                content,
+                timestamp
+            );
+
+            CREATE VIRTUAL TABLE IF NOT EXISTS search_tasks USING fts5(
+                task_id,
+                title,
+                description,
+                status,
+                assigned_to
+            );
+
+            CREATE VIRTUAL TABLE IF NOT EXISTS search_btmsg USING fts5(
+                message_id,
+                from_agent,
+                to_agent,
+                content,
+                channel_name
+            );"
+        )
+        .map_err(|e| format!("Failed to create FTS5 tables: {e}"))
+    }
+
+    /// Index an agent message into the search_messages FTS5 table.
+    pub fn index_message(
+        &self,
+        session_id: &str,
+        role: &str,
+        content: &str,
+    ) -> Result<(), String> {
+        let conn = self.conn.lock().unwrap();
+        let timestamp = chrono_now();
+        conn.execute(
+            "INSERT INTO search_messages (session_id, role, content, timestamp)
+             VALUES (?1, ?2, ?3, ?4)",
+            params![session_id, role, content, timestamp],
+        )
+        .map_err(|e| format!("Index message error: {e}"))?;
+        Ok(())
+    }
+
+    /// Index a task into the search_tasks FTS5 table.
+    pub fn index_task(
+        &self,
+        task_id: &str,
+        title: &str,
+        description: &str,
+        status: &str,
+        assigned_to: &str,
+    ) -> Result<(), String> {
+        let conn = self.conn.lock().unwrap();
+        conn.execute(
+            "INSERT INTO search_tasks (task_id, title, description, status, assigned_to)
+             VALUES (?1, ?2, ?3, ?4, ?5)",
+            params![task_id, title, description, status, assigned_to],
+        )
+        .map_err(|e| format!("Index task error: {e}"))?;
+        Ok(())
+    }
+
+    /// Index a btmsg message into the search_btmsg FTS5 table.
+    pub fn index_btmsg(
+        &self,
+        msg_id: &str,
+        from_agent: &str,
+        to_agent: &str,
+        content: &str,
+        channel: &str,
+    ) -> Result<(), String> {
+        let conn = self.conn.lock().unwrap();
+        conn.execute(
+            "INSERT INTO search_btmsg (message_id, from_agent, to_agent, content, channel_name)
+             VALUES (?1, ?2, ?3, ?4, ?5)",
+            params![msg_id, from_agent, to_agent, content, channel],
+        )
+        .map_err(|e| format!("Index btmsg error: {e}"))?;
+        Ok(())
+    }
+
+    /// Search across all FTS5 tables using MATCH, returning results sorted by relevance.
+    pub fn search_all(&self, query: &str, limit: i32) -> Result<Vec<SearchResult>, String> {
+        if query.trim().is_empty() {
+            return Ok(Vec::new());
+        }
+
+        let conn = self.conn.lock().unwrap();
+        let mut results = Vec::new();
+
+        // Search messages
+        {
+            let mut stmt = conn
+                .prepare(
+                    "SELECT session_id, role, snippet(search_messages, 2, '<b>', '</b>', '...', 32) as snip,
+                            rank
+                     FROM search_messages
+                     WHERE search_messages MATCH ?1
+                     ORDER BY rank
+                     LIMIT ?2",
+                )
+                .map_err(|e| format!("Search messages query error: {e}"))?;
+
+            let rows = stmt
+                .query_map(params![query, limit], |row| {
+                    Ok(SearchResult {
+                        result_type: "message".into(),
+                        id: row.get::<_, String>("session_id")?,
+                        title: row.get::<_, String>("role")?,
+                        snippet: row.get::<_, String>("snip").unwrap_or_default(),
+                        score: row.get::<_, f64>("rank").unwrap_or(0.0).abs(),
+                    })
+                })
+                .map_err(|e| format!("Search messages error: {e}"))?;
+
+            for row in rows {
+                if let Ok(r) = row {
+                    results.push(r);
+                }
+            }
+        }
+
+        // Search tasks
+        {
+            let mut stmt = conn
+                .prepare(
+                    "SELECT task_id, title, snippet(search_tasks, 2, '<b>', '</b>', '...', 32) as snip,
+                            rank
+                     FROM search_tasks
+                     WHERE search_tasks MATCH ?1
+                     ORDER BY rank
+                     LIMIT ?2",
+                )
+                .map_err(|e| format!("Search tasks query error: {e}"))?;
+
+            let rows = stmt
+                .query_map(params![query, limit], |row| {
+                    Ok(SearchResult {
+                        result_type: "task".into(),
+                        id: row.get::<_, String>("task_id")?,
+                        title: row.get::<_, String>("title")?,
+                        snippet: row.get::<_, String>("snip").unwrap_or_default(),
+                        score: row.get::<_, f64>("rank").unwrap_or(0.0).abs(),
+                    })
+                })
+                .map_err(|e| format!("Search tasks error: {e}"))?;
+
+            for row in rows {
+                if let Ok(r) = row {
+                    results.push(r);
+                }
+            }
+        }
+
+        // Search btmsg
+        {
+            let mut stmt = conn
+                .prepare(
+                    "SELECT message_id, from_agent, snippet(search_btmsg, 3, '<b>', '</b>', '...', 32) as snip,
+                            rank
+                     FROM search_btmsg
+                     WHERE search_btmsg MATCH ?1
+                     ORDER BY rank
+                     LIMIT ?2",
+                )
+                .map_err(|e| format!("Search btmsg query error: {e}"))?;
+
+            let rows = stmt
+                .query_map(params![query, limit], |row| {
+                    Ok(SearchResult {
+                        result_type: "btmsg".into(),
+                        id: row.get::<_, String>("message_id")?,
+                        title: row.get::<_, String>("from_agent")?,
+                        snippet: row.get::<_, String>("snip").unwrap_or_default(),
+                        score: row.get::<_, f64>("rank").unwrap_or(0.0).abs(),
+                    })
+                })
+                .map_err(|e| format!("Search btmsg error: {e}"))?;
+
+            for row in rows {
+                if let Ok(r) = row {
+                    results.push(r);
+                }
+            }
+        }
+
+        // Sort by score ascending (FTS5 rank is negative, abs() makes lower = more relevant)
+        results.sort_by(|a, b| a.score.partial_cmp(&b.score).unwrap_or(std::cmp::Ordering::Equal));
+        results.truncate(limit as usize);
+
+        Ok(results)
+    }
+
+    /// Drop and recreate all FTS5 tables (clears the index).
+    pub fn rebuild_index(&self) -> Result<(), String> {
+        let conn = self.conn.lock().unwrap();
+        conn.execute_batch(
+            "DROP TABLE IF EXISTS search_messages;
+             DROP TABLE IF EXISTS search_tasks;
+             DROP TABLE IF EXISTS search_btmsg;"
+        )
+        .map_err(|e| format!("Failed to drop FTS5 tables: {e}"))?;
+        drop(conn);
+
+        self.create_tables()?;
+        Ok(())
+    }
+}
+
+/// Simple timestamp helper (avoids adding chrono dependency).
+fn chrono_now() -> String {
+    // Use SQLite's datetime('now') equivalent via a simple format
+    // We return empty string; actual timestamp can be added by caller if needed
+    String::new()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::path::PathBuf;
+
+    fn temp_search_db() -> (SearchDb, tempfile::TempDir) {
+        let dir = tempfile::tempdir().unwrap();
+        let db_path = dir.path().join("search.db");
+        let db = SearchDb::open(&db_path).unwrap();
+        (db, dir)
+    }
+
+    #[test]
+    fn test_create_tables_idempotent() {
+        let (db, _dir) = temp_search_db();
+        // Second call should not fail
+        db.create_tables().unwrap();
+    }
+
+    #[test]
+    fn test_index_and_search_message() {
+        let (db, _dir) = temp_search_db();
+        db.index_message("s1", "assistant", "The quick brown fox jumps over the lazy dog")
+            .unwrap();
+        db.index_message("s2", "user", "Hello world from the user")
+            .unwrap();
+
+        let results = db.search_all("quick brown", 10).unwrap();
+        assert_eq!(results.len(), 1);
+        assert_eq!(results[0].result_type, "message");
+        assert_eq!(results[0].id, "s1");
+    }
+
+    #[test]
+    fn test_index_and_search_task() {
+        let (db, _dir) = temp_search_db();
+        db.index_task("t1", "Fix login bug", "Users cannot log in with SSO", "progress", "agent-1")
+            .unwrap();
+        db.index_task("t2", "Add dark mode", "Theme support", "todo", "agent-2")
+            .unwrap();
+
+        let results = db.search_all("login SSO", 10).unwrap();
+        assert_eq!(results.len(), 1);
+        assert_eq!(results[0].result_type, "task");
+        assert_eq!(results[0].id, "t1");
+        assert_eq!(results[0].title, "Fix login bug");
+    }
+
+    #[test]
+    fn test_index_and_search_btmsg() {
+        let (db, _dir) = temp_search_db();
+        db.index_btmsg("m1", "manager", "architect", "Please review the API design", "general")
+            .unwrap();
+        db.index_btmsg("m2", "tester", "manager", "All tests passing", "review-queue")
+            .unwrap();
+
+        let results = db.search_all("API design", 10).unwrap();
+        assert_eq!(results.len(), 1);
+        assert_eq!(results[0].result_type, "btmsg");
+        assert_eq!(results[0].id, "m1");
+    }
+
+    #[test]
+    fn test_search_across_all_tables() {
+        let (db, _dir) = temp_search_db();
+        db.index_message("s1", "assistant", "Please deploy the auth service now")
+            .unwrap();
+        db.index_task("t1", "Deploy auth service", "Deploy to production", "todo", "ops")
+            .unwrap();
+        db.index_btmsg("m1", "manager", "ops", "Please deploy the auth service ASAP", "ops-channel")
+            .unwrap();
+
+        let results = db.search_all("deploy auth", 10).unwrap();
+        assert_eq!(results.len(), 3, "should find results across all 3 tables");
+
+        let types: Vec<&str> = results.iter().map(|r| r.result_type.as_str()).collect();
+        assert!(types.contains(&"message"));
+        assert!(types.contains(&"task"));
+        assert!(types.contains(&"btmsg"));
+    }
+
+    #[test]
+    fn test_search_empty_query() {
+        let (db, _dir) = temp_search_db();
+        db.index_message("s1", "user", "some content").unwrap();
+
+        let results = db.search_all("", 10).unwrap();
+        assert!(results.is_empty());
+    }
+
+    #[test]
+    fn test_search_no_results() {
+        let (db, _dir) = temp_search_db();
+        db.index_message("s1", "user", "hello world").unwrap();
+
+        let results = db.search_all("nonexistent", 10).unwrap();
+        assert!(results.is_empty());
+    }
+
+    #[test]
+    fn test_search_limit() {
+        let (db, _dir) = temp_search_db();
+        for i in 0..20 {
+            db.index_message(&format!("s{i}"), "user", &format!("test message number {i}"))
+                .unwrap();
+        }
+
+        let results = db.search_all("test message", 5).unwrap();
+        assert!(results.len() <= 5);
+    }
+
+    #[test]
+    fn test_rebuild_index() {
+        let (db, _dir) = temp_search_db();
+        db.index_message("s1", "user", "important data").unwrap();
+
+        let before = db.search_all("important", 10).unwrap();
+        assert_eq!(before.len(), 1);
+
+        db.rebuild_index().unwrap();
+
+        let after = db.search_all("important", 10).unwrap();
+        assert!(after.is_empty(), "index should be empty after rebuild");
+    }
+
+    #[test]
+    fn test_search_result_serializes_to_camel_case() {
+        let result = SearchResult {
+            result_type: "message".into(),
+            id: "s1".into(),
+            title: "user".into(),
+            snippet: "test".into(),
+            score: 0.5,
+        };
+
+        let json = serde_json::to_value(&result).unwrap();
+        assert!(json.get("resultType").is_some(), "expected camelCase 'resultType'");
+        assert!(json.get("result_type").is_none(), "should not have snake_case");
+    }
+}
diff --git a/v2/src-tauri/src/secrets.rs b/v2/src-tauri/src/secrets.rs
new file mode 100644
index 0000000..1ad1cbe
--- /dev/null
+++ b/v2/src-tauri/src/secrets.rs
@@ -0,0 +1,129 @@
+//! Secrets management via system keyring (libsecret on Linux).
+//!
+//! Stores secrets in the OS keyring (GNOME Keyring / KDE Wallet).
+//! A metadata entry "__bterminal_keys__" tracks known key names.
+//! If the keyring is unavailable, operations return explicit errors
+//! rather than falling back to plaintext storage.
+
+use keyring::Entry;
+
+const SERVICE: &str = "bterminal";
+const KEYS_META: &str = "__bterminal_keys__";
+
+/// Known secret key identifiers.
+pub const KNOWN_KEYS: &[&str] = &[
+    "anthropic_api_key",
+    "openai_api_key",
+    "github_token",
+    "relay_token",
+];
+
+pub struct SecretsManager;
+
+impl SecretsManager {
+    /// Store a secret value in the system keyring.
+    pub fn store_secret(key: &str, value: &str) -> Result<(), String> {
+        let entry = Entry::new(SERVICE, key).map_err(|e| format!("keyring init error: {e}"))?;
+        entry
+            .set_password(value)
+            .map_err(|e| format!("failed to store secret '{key}': {e}"))?;
+
+        // Track the key in metadata
+        Self::add_key_to_meta(key)?;
+        Ok(())
+    }
+
+    /// Retrieve a secret value from the system keyring.
+    /// Returns Ok(None) if the key does not exist.
+    pub fn get_secret(key: &str) -> Result<Option<String>, String> {
+        let entry = Entry::new(SERVICE, key).map_err(|e| format!("keyring init error: {e}"))?;
+        match entry.get_password() {
+            Ok(pw) => Ok(Some(pw)),
+            Err(keyring::Error::NoEntry) => Ok(None),
+            Err(e) => Err(format!("failed to get secret '{key}': {e}")),
+        }
+    }
+
+    /// Delete a secret from the system keyring.
+    pub fn delete_secret(key: &str) -> Result<(), String> {
+        let entry = Entry::new(SERVICE, key).map_err(|e| format!("keyring init error: {e}"))?;
+        match entry.delete_credential() {
+            Ok(()) => {}
+            Err(keyring::Error::NoEntry) => {} // already absent, not an error
+            Err(e) => return Err(format!("failed to delete secret '{key}': {e}")),
+        }
+
+        Self::remove_key_from_meta(key)?;
+        Ok(())
+    }
+
+    /// List keys that have been stored (read from metadata entry).
+    pub fn list_keys() -> Result<Vec<String>, String> {
+        let entry =
+            Entry::new(SERVICE, KEYS_META).map_err(|e| format!("keyring init error: {e}"))?;
+        match entry.get_password() {
+            Ok(raw) => {
+                let keys: Vec<String> = raw
+                    .split('\n')
+                    .filter(|s| !s.is_empty())
+                    .map(String::from)
+                    .collect();
+                Ok(keys)
+            }
+            Err(keyring::Error::NoEntry) => Ok(Vec::new()),
+            Err(e) => Err(format!("failed to list secret keys: {e}")),
+        }
+    }
+
+    /// Check whether the system keyring is available.
+    pub fn has_keyring() -> bool {
+        // Attempt to create an entry — this is the cheapest probe.
+        Entry::new(SERVICE, "__probe__").is_ok()
+    }
+
+    // --- internal helpers ---
+
+    fn add_key_to_meta(key: &str) -> Result<(), String> {
+        let mut keys = Self::list_keys().unwrap_or_default();
+        if !keys.iter().any(|k| k == key) {
+            keys.push(key.to_string());
+            Self::save_meta(&keys)?;
+        }
+        Ok(())
+    }
+
+    fn remove_key_from_meta(key: &str) -> Result<(), String> {
+        let mut keys = Self::list_keys().unwrap_or_default();
+        keys.retain(|k| k != key);
+        Self::save_meta(&keys)?;
+        Ok(())
+    }
+
+    fn save_meta(keys: &[String]) -> Result<(), String> {
+        let entry =
+            Entry::new(SERVICE, KEYS_META).map_err(|e| format!("keyring init error: {e}"))?;
+        let data = keys.join("\n");
+        entry
+            .set_password(&data)
+            .map_err(|e| format!("failed to save key metadata: {e}"))?;
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn known_keys_are_not_empty() {
+        assert!(!KNOWN_KEYS.is_empty());
+    }
+
+    #[test]
+    fn known_keys_contains_expected() {
+        assert!(KNOWN_KEYS.contains(&"anthropic_api_key"));
+        assert!(KNOWN_KEYS.contains(&"openai_api_key"));
+        assert!(KNOWN_KEYS.contains(&"github_token"));
+        assert!(KNOWN_KEYS.contains(&"relay_token"));
+    }
+}
diff --git a/v2/src-tauri/src/session/agents.rs b/v2/src-tauri/src/session/agents.rs
new file mode 100644
index 0000000..8ffd7fd
--- /dev/null
+++ b/v2/src-tauri/src/session/agents.rs
@@ -0,0 +1,144 @@
+// Agent message and project state persistence (agent_messages + project_agent_state tables)
+
+use rusqlite::params;
+use serde::{Deserialize, Serialize};
+use super::SessionDb;
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct AgentMessageRecord {
+    #[serde(default)]
+    pub id: i64,
+    pub session_id: String,
+    pub project_id: String,
+    pub sdk_session_id: Option<String>,
+    pub message_type: String,
+    pub content: String,
+    pub parent_id: Option<String>,
+    pub created_at: i64,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ProjectAgentState {
+    pub project_id: String,
+    pub last_session_id: String,
+    pub sdk_session_id: Option<String>,
+    pub status: String,
+    pub cost_usd: f64,
+    pub input_tokens: i64,
+    pub output_tokens: i64,
+    pub last_prompt: Option<String>,
+    pub updated_at: i64,
+}
+
+impl SessionDb {
+    pub fn save_agent_messages(
+        &self,
+        session_id: &str,
+        project_id: &str,
+        sdk_session_id: Option<&str>,
+        messages: &[AgentMessageRecord],
+    ) -> Result<(), String> {
+        let conn = self.conn.lock().unwrap();
+        // Wrap DELETE+INSERTs in a transaction to prevent partial writes on crash
+        let tx = conn.unchecked_transaction()
+            .map_err(|e| format!("Begin transaction failed: {e}"))?;
+
+        // Clear previous messages for this session
+        tx.execute(
+            "DELETE FROM agent_messages WHERE session_id = ?1",
+            params![session_id],
+        ).map_err(|e| format!("Delete old messages failed: {e}"))?;
+
+        let mut stmt = tx.prepare(
+            "INSERT INTO agent_messages (session_id, project_id, sdk_session_id, message_type, content, parent_id, created_at) VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7)"
+        ).map_err(|e| format!("Prepare insert failed: {e}"))?;
+
+        for msg in messages {
+            stmt.execute(params![
+                session_id,
+                project_id,
+                sdk_session_id,
+                msg.message_type,
+                msg.content,
+                msg.parent_id,
+                msg.created_at,
+            ]).map_err(|e| format!("Insert message failed: {e}"))?;
+        }
+        drop(stmt);
+        tx.commit().map_err(|e| format!("Commit failed: {e}"))?;
+        Ok(())
+    }
+
+    pub fn load_agent_messages(&self, project_id: &str) -> Result<Vec<AgentMessageRecord>, String> {
+        let conn = self.conn.lock().unwrap();
+        let mut stmt = conn.prepare(
+            "SELECT id, session_id, project_id, sdk_session_id, message_type, content, parent_id, created_at
+             FROM agent_messages
+             WHERE project_id = ?1
+             ORDER BY created_at ASC"
+        ).map_err(|e| format!("Query prepare failed: {e}"))?;
+
+        let messages = stmt.query_map(params![project_id], |row| {
+            Ok(AgentMessageRecord {
+                id: row.get(0)?,
+                session_id: row.get(1)?,
+                project_id: row.get(2)?,
+                sdk_session_id: row.get(3)?,
+                message_type: row.get(4)?,
+                content: row.get(5)?,
+                parent_id: row.get(6)?,
+                created_at: row.get(7)?,
+            })
+        }).map_err(|e| format!("Query failed: {e}"))?
+        .collect::<Result<Vec<_>, _>>()
+        .map_err(|e| format!("Row read failed: {e}"))?;
+
+        Ok(messages)
+    }
+
+    pub fn save_project_agent_state(&self, state: &ProjectAgentState) -> Result<(), String> {
+        let conn = self.conn.lock().unwrap();
+        conn.execute(
+            "INSERT OR REPLACE INTO project_agent_state (project_id, last_session_id, sdk_session_id, status, cost_usd, input_tokens, output_tokens, last_prompt, updated_at) VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9)",
+            params![
+                state.project_id,
+                state.last_session_id,
+                state.sdk_session_id,
+                state.status,
+                state.cost_usd,
+                state.input_tokens,
+                state.output_tokens,
+                state.last_prompt,
+                state.updated_at,
+            ],
+        ).map_err(|e| format!("Save project agent state failed: {e}"))?;
+        Ok(())
+    }
+
+    pub fn load_project_agent_state(&self, project_id: &str) -> Result<Option<ProjectAgentState>, String> {
+        let conn = self.conn.lock().unwrap();
+        let mut stmt = conn.prepare(
+            "SELECT project_id, last_session_id, sdk_session_id, status, cost_usd, input_tokens, output_tokens, last_prompt, updated_at FROM project_agent_state WHERE project_id = ?1"
+        ).map_err(|e| format!("Query prepare failed: {e}"))?;
+
+        let result = stmt.query_row(params![project_id], |row| {
+            Ok(ProjectAgentState {
+                project_id: row.get(0)?,
+                last_session_id: row.get(1)?,
+                sdk_session_id: row.get(2)?,
+                status: row.get(3)?,
+                cost_usd: row.get(4)?,
+                input_tokens: row.get(5)?,
+                output_tokens: row.get(6)?,
+                last_prompt: row.get(7)?,
+                updated_at: row.get(8)?,
+            })
+        });
+
+        match result {
+            Ok(state) => Ok(Some(state)),
+            Err(rusqlite::Error::QueryReturnedNoRows) => Ok(None),
+            Err(e) => Err(format!("Load project agent state failed: {e}")),
+        }
+    }
+}
diff --git a/v2/src-tauri/src/session/anchors.rs b/v2/src-tauri/src/session/anchors.rs
new file mode 100644
index 0000000..1936feb
--- /dev/null
+++ b/v2/src-tauri/src/session/anchors.rs
@@ -0,0 +1,90 @@
+// Session anchor persistence (session_anchors table)
+
+use rusqlite::params;
+use serde::{Deserialize, Serialize};
+use super::SessionDb;
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct SessionAnchorRecord {
+    pub id: String,
+    pub project_id: String,
+    pub message_id: String,
+    pub anchor_type: String,
+    pub content: String,
+    pub estimated_tokens: i64,
+    pub turn_index: i64,
+    pub created_at: i64,
+}
+
+impl SessionDb {
+    pub fn save_session_anchors(&self, anchors: &[SessionAnchorRecord]) -> Result<(), String> {
+        if anchors.is_empty() {
+            return Ok(());
+        }
+        let conn = self.conn.lock().unwrap();
+        let mut stmt = conn.prepare(
+            "INSERT OR REPLACE INTO session_anchors (id, project_id, message_id, anchor_type, content, estimated_tokens, turn_index, created_at) VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8)"
+        ).map_err(|e| format!("Prepare anchor insert failed: {e}"))?;
+
+        for anchor in anchors {
+            stmt.execute(params![
+                anchor.id,
+                anchor.project_id,
+                anchor.message_id,
+                anchor.anchor_type,
+                anchor.content,
+                anchor.estimated_tokens,
+                anchor.turn_index,
+                anchor.created_at,
+            ]).map_err(|e| format!("Insert anchor failed: {e}"))?;
+        }
+        Ok(())
+    }
+
+    pub fn load_session_anchors(&self, project_id: &str) -> Result<Vec<SessionAnchorRecord>, String> {
+        let conn = self.conn.lock().unwrap();
+        let mut stmt = conn.prepare(
+            "SELECT id, project_id, message_id, anchor_type, content, estimated_tokens, turn_index, created_at FROM session_anchors WHERE project_id = ?1 ORDER BY turn_index ASC"
+        ).map_err(|e| format!("Query anchors failed: {e}"))?;
+
+        let anchors = stmt.query_map(params![project_id], |row| {
+            Ok(SessionAnchorRecord {
+                id: row.get(0)?,
+                project_id: row.get(1)?,
+                message_id: row.get(2)?,
+                anchor_type: row.get(3)?,
+                content: row.get(4)?,
+                estimated_tokens: row.get(5)?,
+                turn_index: row.get(6)?,
+                created_at: row.get(7)?,
+            })
+        }).map_err(|e| format!("Query anchors failed: {e}"))?
+        .collect::<Result<Vec<_>, _>>()
+        .map_err(|e| format!("Read anchor row failed: {e}"))?;
+
+        Ok(anchors)
+    }
+
+    pub fn delete_session_anchor(&self, id: &str) -> Result<(), String> {
+        let conn = self.conn.lock().unwrap();
+        conn.execute("DELETE FROM session_anchors WHERE id = ?1", params![id])
+            .map_err(|e| format!("Delete anchor failed: {e}"))?;
+        Ok(())
+    }
+
+    pub fn delete_project_anchors(&self, project_id: &str) -> Result<(), String> {
+        let conn = self.conn.lock().unwrap();
+        conn.execute("DELETE FROM session_anchors WHERE project_id = ?1", params![project_id])
+            .map_err(|e| format!("Delete project anchors failed: {e}"))?;
+        Ok(())
+    }
+
+    pub fn update_anchor_type(&self, id: &str, anchor_type: &str) -> Result<(), String> {
+        let conn = self.conn.lock().unwrap();
+        conn.execute(
+            "UPDATE session_anchors SET anchor_type = ?2 WHERE id = ?1",
+            params![id, anchor_type],
+        ).map_err(|e| format!("Update anchor type failed: {e}"))?;
+        Ok(())
+    }
+}
diff --git a/v2/src-tauri/src/session/layout.rs b/v2/src-tauri/src/session/layout.rs
new file mode 100644
index 0000000..d134521
--- /dev/null
+++ b/v2/src-tauri/src/session/layout.rs
@@ -0,0 +1,90 @@
+// Layout state persistence (layout_state table)
+
+use rusqlite::params;
+use serde::{Deserialize, Serialize};
+use super::SessionDb;
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct LayoutState {
+    pub preset: String,
+    pub pane_ids: Vec<String>,
+}
+
+impl SessionDb {
+    pub fn save_layout(&self, layout: &LayoutState) -> Result<(), String> {
+        let conn = self.conn.lock().unwrap();
+        let pane_ids_json = serde_json::to_string(&layout.pane_ids)
+            .map_err(|e| format!("Serialize pane_ids failed: {e}"))?;
+        conn.execute(
+            "UPDATE layout_state SET preset = ?1, pane_ids = ?2 WHERE id = 1",
+            params![layout.preset, pane_ids_json],
+        ).map_err(|e| format!("Layout save failed: {e}"))?;
+        Ok(())
+    }
+
+    pub fn load_layout(&self) -> Result<LayoutState, String> {
+        let conn = self.conn.lock().unwrap();
+        let mut stmt = conn
+            .prepare("SELECT preset, pane_ids FROM layout_state WHERE id = 1")
+            .map_err(|e| format!("Layout query failed: {e}"))?;
+
+        stmt.query_row([], |row| {
+            let preset: String = row.get(0)?;
+            let pane_ids_json: String = row.get(1)?;
+            let pane_ids: Vec<String> = serde_json::from_str(&pane_ids_json).unwrap_or_default();
+            Ok(LayoutState { preset, pane_ids })
+        }).map_err(|e| format!("Layout read failed: {e}"))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn make_db() -> SessionDb {
+        let dir = tempfile::tempdir().unwrap();
+        SessionDb::open(&dir.path().to_path_buf()).unwrap()
+    }
+
+    #[test]
+    fn test_load_default_layout() {
+        let db = make_db();
+        let layout = db.load_layout().unwrap();
+        assert_eq!(layout.preset, "1-col");
+        assert!(layout.pane_ids.is_empty());
+    }
+
+    #[test]
+    fn test_save_and_load_layout() {
+        let db = make_db();
+        let layout = LayoutState {
+            preset: "2-col".to_string(),
+            pane_ids: vec!["p1".to_string(), "p2".to_string()],
+        };
+        db.save_layout(&layout).unwrap();
+
+        let loaded = db.load_layout().unwrap();
+        assert_eq!(loaded.preset, "2-col");
+        assert_eq!(loaded.pane_ids, vec!["p1", "p2"]);
+    }
+
+    #[test]
+    fn test_save_layout_overwrites() {
+        let db = make_db();
+        let layout1 = LayoutState {
+            preset: "2-col".to_string(),
+            pane_ids: vec!["p1".to_string()],
+        };
+        db.save_layout(&layout1).unwrap();
+
+        let layout2 = LayoutState {
+            preset: "3-col".to_string(),
+            pane_ids: vec!["a".to_string(), "b".to_string(), "c".to_string()],
+        };
+        db.save_layout(&layout2).unwrap();
+
+        let loaded = db.load_layout().unwrap();
+        assert_eq!(loaded.preset, "3-col");
+        assert_eq!(loaded.pane_ids.len(), 3);
+    }
+}
diff --git a/v2/src-tauri/src/session/metrics.rs b/v2/src-tauri/src/session/metrics.rs
new file mode 100644
index 0000000..60f6660
--- /dev/null
+++ b/v2/src-tauri/src/session/metrics.rs
@@ -0,0 +1,80 @@
+// Session metrics persistence (session_metrics table)
+
+use rusqlite::params;
+use serde::{Deserialize, Serialize};
+use super::SessionDb;
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct SessionMetric {
+    #[serde(default)]
+    pub id: i64,
+    pub project_id: String,
+    pub session_id: String,
+    pub start_time: i64,
+    pub end_time: i64,
+    pub peak_tokens: i64,
+    pub turn_count: i64,
+    pub tool_call_count: i64,
+    pub cost_usd: f64,
+    pub model: Option<String>,
+    pub status: String,
+    pub error_message: Option<String>,
+}
+
+impl SessionDb {
+    pub fn save_session_metric(&self, metric: &SessionMetric) -> Result<(), String> {
+        let conn = self.conn.lock().unwrap();
+        conn.execute(
+            "INSERT INTO session_metrics (project_id, session_id, start_time, end_time, peak_tokens, turn_count, tool_call_count, cost_usd, model, status, error_message) VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10, ?11)",
+            params![
+                metric.project_id,
+                metric.session_id,
+                metric.start_time,
+                metric.end_time,
+                metric.peak_tokens,
+                metric.turn_count,
+                metric.tool_call_count,
+                metric.cost_usd,
+                metric.model,
+                metric.status,
+                metric.error_message,
+            ],
+        ).map_err(|e| format!("Save session metric failed: {e}"))?;
+
+        // Enforce retention: keep last 100 per project
+        conn.execute(
+            "DELETE FROM session_metrics WHERE project_id = ?1 AND id NOT IN (SELECT id FROM session_metrics WHERE project_id = ?1 ORDER BY end_time DESC LIMIT 100)",
+            params![metric.project_id],
+        ).map_err(|e| format!("Prune session metrics failed: {e}"))?;
+
+        Ok(())
+    }
+
+    pub fn load_session_metrics(&self, project_id: &str, limit: i64) -> Result<Vec<SessionMetric>, String> {
+        let conn = self.conn.lock().unwrap();
+        let mut stmt = conn.prepare(
+            "SELECT id, project_id, session_id, start_time, end_time, peak_tokens, turn_count, tool_call_count, cost_usd, model, status, error_message FROM session_metrics WHERE project_id = ?1 ORDER BY end_time DESC LIMIT ?2"
+        ).map_err(|e| format!("Query prepare failed: {e}"))?;
+
+        let metrics = stmt.query_map(params![project_id, limit], |row| {
+            Ok(SessionMetric {
+                id: row.get(0)?,
+                project_id: row.get(1)?,
+                session_id: row.get(2)?,
+                start_time: row.get(3)?,
+                end_time: row.get(4)?,
+                peak_tokens: row.get(5)?,
+                turn_count: row.get(6)?,
+                tool_call_count: row.get(7)?,
+                cost_usd: row.get(8)?,
+                model: row.get(9)?,
+                status: row.get(10)?,
+                error_message: row.get(11)?,
+            })
+        }).map_err(|e| format!("Query failed: {e}"))?
+        .collect::<Result<Vec<_>, _>>()
+        .map_err(|e| format!("Row read failed: {e}"))?;
+
+        Ok(metrics)
+    }
+}
diff --git a/v2/src-tauri/src/session/mod.rs b/v2/src-tauri/src/session/mod.rs
new file mode 100644
index 0000000..dd47ccf
--- /dev/null
+++ b/v2/src-tauri/src/session/mod.rs
@@ -0,0 +1,174 @@
+// Session persistence via rusqlite
+// SessionDb owns the connection; table-specific operations live in sub-modules
+
+mod sessions;
+mod layout;
+mod settings;
+mod ssh;
+mod agents;
+mod metrics;
+mod anchors;
+
+pub use sessions::Session;
+pub use layout::LayoutState;
+pub use ssh::SshSession;
+pub use agents::{AgentMessageRecord, ProjectAgentState};
+pub use metrics::SessionMetric;
+pub use anchors::SessionAnchorRecord;
+
+use rusqlite::Connection;
+use std::path::PathBuf;
+use std::sync::Mutex;
+
+pub struct SessionDb {
+    pub(in crate::session) conn: Mutex<Connection>,
+}
+
+impl SessionDb {
+    pub fn open(data_dir: &PathBuf) -> Result<Self, String> {
+        std::fs::create_dir_all(data_dir)
+            .map_err(|e| format!("Failed to create data dir: {e}"))?;
+
+        let db_path = data_dir.join("sessions.db");
+        let conn = Connection::open(&db_path)
+            .map_err(|e| format!("Failed to open database: {e}"))?;
+
+        // Enable WAL mode for better concurrent read performance
+        // journal_mode returns a result row, so use query_row instead of pragma_update
+        conn.query_row("PRAGMA journal_mode=WAL", [], |_| Ok(()))
+            .map_err(|e| format!("Failed to set journal_mode: {e}"))?;
+        conn.pragma_update(None, "foreign_keys", "ON")
+            .map_err(|e| format!("Failed to set foreign_keys: {e}"))?;
+
+        let db = Self { conn: Mutex::new(conn) };
+        db.migrate()?;
+        Ok(db)
+    }
+
+    fn migrate(&self) -> Result<(), String> {
+        let conn = self.conn.lock().unwrap();
+        conn.execute_batch(
+            "CREATE TABLE IF NOT EXISTS sessions (
+                id TEXT PRIMARY KEY,
+                type TEXT NOT NULL,
+                title TEXT NOT NULL,
+                shell TEXT,
+                cwd TEXT,
+                args TEXT,
+                created_at INTEGER NOT NULL,
+                last_used_at INTEGER NOT NULL
+            );
+
+            CREATE TABLE IF NOT EXISTS layout_state (
+                id INTEGER PRIMARY KEY CHECK (id = 1),
+                preset TEXT NOT NULL DEFAULT '1-col',
+                pane_ids TEXT NOT NULL DEFAULT '[]'
+            );
+
+            INSERT OR IGNORE INTO layout_state (id, preset, pane_ids) VALUES (1, '1-col', '[]');
+
+            CREATE TABLE IF NOT EXISTS settings (
+                key TEXT PRIMARY KEY,
+                value TEXT NOT NULL
+            );
+
+            CREATE TABLE IF NOT EXISTS ssh_sessions (
+                id TEXT PRIMARY KEY,
+                name TEXT NOT NULL,
+                host TEXT NOT NULL,
+                port INTEGER NOT NULL DEFAULT 22,
+                username TEXT NOT NULL,
+                key_file TEXT DEFAULT '',
+                folder TEXT DEFAULT '',
+                color TEXT DEFAULT '#89b4fa',
+                created_at INTEGER NOT NULL,
+                last_used_at INTEGER NOT NULL
+            );
+            "
+        ).map_err(|e| format!("Migration failed: {e}"))?;
+
+        // Add group_name column if missing (v2 migration)
+        let has_group: i64 = conn.query_row(
+            "SELECT COUNT(*) FROM pragma_table_info('sessions') WHERE name='group_name'",
+            [],
+            |row| row.get(0),
+        ).unwrap_or(0);
+        if has_group == 0 {
+            conn.execute("ALTER TABLE sessions ADD COLUMN group_name TEXT DEFAULT ''", [])
+                .map_err(|e| format!("Migration (group_name) failed: {e}"))?;
+        }
+
+        // v3 migration: project_id column on sessions
+        let has_project_id: i64 = conn.query_row(
+            "SELECT COUNT(*) FROM pragma_table_info('sessions') WHERE name='project_id'",
+            [],
+            |row| row.get(0),
+        ).unwrap_or(0);
+        if has_project_id == 0 {
+            conn.execute("ALTER TABLE sessions ADD COLUMN project_id TEXT DEFAULT ''", [])
+                .map_err(|e| format!("Migration (project_id) failed: {e}"))?;
+        }
+
+        // v3: agent message history for session continuity
+        conn.execute_batch(
+            "CREATE TABLE IF NOT EXISTS agent_messages (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                session_id TEXT NOT NULL,
+                project_id TEXT NOT NULL,
+                sdk_session_id TEXT,
+                message_type TEXT NOT NULL,
+                content TEXT NOT NULL,
+                parent_id TEXT,
+                created_at INTEGER NOT NULL
+            );
+            CREATE INDEX IF NOT EXISTS idx_agent_messages_session
+                ON agent_messages(session_id);
+            CREATE INDEX IF NOT EXISTS idx_agent_messages_project
+                ON agent_messages(project_id);
+
+            CREATE TABLE IF NOT EXISTS project_agent_state (
+                project_id TEXT PRIMARY KEY,
+                last_session_id TEXT NOT NULL,
+                sdk_session_id TEXT,
+                status TEXT NOT NULL,
+                cost_usd REAL DEFAULT 0,
+                input_tokens INTEGER DEFAULT 0,
+                output_tokens INTEGER DEFAULT 0,
+                last_prompt TEXT,
+                updated_at INTEGER NOT NULL
+            );
+
+            CREATE TABLE IF NOT EXISTS session_metrics (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                project_id TEXT NOT NULL,
+                session_id TEXT NOT NULL,
+                start_time INTEGER NOT NULL,
+                end_time INTEGER NOT NULL,
+                peak_tokens INTEGER DEFAULT 0,
+                turn_count INTEGER DEFAULT 0,
+                tool_call_count INTEGER DEFAULT 0,
+                cost_usd REAL DEFAULT 0,
+                model TEXT,
+                status TEXT NOT NULL,
+                error_message TEXT
+            );
+            CREATE INDEX IF NOT EXISTS idx_session_metrics_project
+                ON session_metrics(project_id);
+
+            CREATE TABLE IF NOT EXISTS session_anchors (
+                id TEXT PRIMARY KEY,
+                project_id TEXT NOT NULL,
+                message_id TEXT NOT NULL,
+                anchor_type TEXT NOT NULL,
+                content TEXT NOT NULL,
+                estimated_tokens INTEGER NOT NULL,
+                turn_index INTEGER NOT NULL DEFAULT 0,
+                created_at INTEGER NOT NULL
+            );
+            CREATE INDEX IF NOT EXISTS idx_session_anchors_project
+                ON session_anchors(project_id);"
+        ).map_err(|e| format!("Migration (v3 tables) failed: {e}"))?;
+
+        Ok(())
+    }
+}
diff --git a/v2/src-tauri/src/session/sessions.rs b/v2/src-tauri/src/session/sessions.rs
new file mode 100644
index 0000000..1d2b330
--- /dev/null
+++ b/v2/src-tauri/src/session/sessions.rs
@@ -0,0 +1,256 @@
+// Session CRUD operations (sessions table)
+
+use rusqlite::params;
+use serde::{Deserialize, Serialize};
+use super::SessionDb;
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Session {
+    pub id: String,
+    #[serde(rename = "type")]
+    pub session_type: String,
+    pub title: String,
+    pub shell: Option<String>,
+    pub cwd: Option<String>,
+    pub args: Option<Vec<String>>,
+    #[serde(default)]
+    pub group_name: String,
+    pub created_at: i64,
+    pub last_used_at: i64,
+}
+
+impl SessionDb {
+    pub fn list_sessions(&self) -> Result<Vec<Session>, String> {
+        let conn = self.conn.lock().unwrap();
+        let mut stmt = conn
+            .prepare("SELECT id, type, title, shell, cwd, args, group_name, created_at, last_used_at FROM sessions ORDER BY last_used_at DESC")
+            .map_err(|e| format!("Query prepare failed: {e}"))?;
+
+        let sessions = stmt
+            .query_map([], |row| {
+                let args_json: Option<String> = row.get(5)?;
+                let args: Option<Vec<String>> = args_json.and_then(|j| serde_json::from_str(&j).ok());
+                Ok(Session {
+                    id: row.get(0)?,
+                    session_type: row.get(1)?,
+                    title: row.get(2)?,
+                    shell: row.get(3)?,
+                    cwd: row.get(4)?,
+                    args,
+                    group_name: row.get::<_, Option<String>>(6)?.unwrap_or_default(),
+                    created_at: row.get(7)?,
+                    last_used_at: row.get(8)?,
+                })
+            })
+            .map_err(|e| format!("Query failed: {e}"))?
+            .collect::<Result<Vec<_>, _>>()
+            .map_err(|e| format!("Row read failed: {e}"))?;
+
+        Ok(sessions)
+    }
+
+    pub fn save_session(&self, session: &Session) -> Result<(), String> {
+        let conn = self.conn.lock().unwrap();
+        let args_json = session.args.as_ref().map(|a| serde_json::to_string(a).unwrap_or_default());
+        conn.execute(
+            "INSERT OR REPLACE INTO sessions (id, type, title, shell, cwd, args, group_name, created_at, last_used_at) VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9)",
+            params![
+                session.id,
+                session.session_type,
+                session.title,
+                session.shell,
+                session.cwd,
+                args_json,
+                session.group_name,
+                session.created_at,
+                session.last_used_at,
+            ],
+        ).map_err(|e| format!("Insert failed: {e}"))?;
+        Ok(())
+    }
+
+    pub fn delete_session(&self, id: &str) -> Result<(), String> {
+        let conn = self.conn.lock().unwrap();
+        conn.execute("DELETE FROM sessions WHERE id = ?1", params![id])
+            .map_err(|e| format!("Delete failed: {e}"))?;
+        Ok(())
+    }
+
+    pub fn update_title(&self, id: &str, title: &str) -> Result<(), String> {
+        let conn = self.conn.lock().unwrap();
+        conn.execute(
+            "UPDATE sessions SET title = ?1 WHERE id = ?2",
+            params![title, id],
+        ).map_err(|e| format!("Update failed: {e}"))?;
+        Ok(())
+    }
+
+    pub fn update_group(&self, id: &str, group_name: &str) -> Result<(), String> {
+        let conn = self.conn.lock().unwrap();
+        conn.execute(
+            "UPDATE sessions SET group_name = ?1 WHERE id = ?2",
+            params![group_name, id],
+        ).map_err(|e| format!("Update group failed: {e}"))?;
+        Ok(())
+    }
+
+    pub fn touch_session(&self, id: &str) -> Result<(), String> {
+        let conn = self.conn.lock().unwrap();
+        let now = std::time::SystemTime::now()
+            .duration_since(std::time::UNIX_EPOCH)
+            .unwrap()
+            .as_secs() as i64;
+        conn.execute(
+            "UPDATE sessions SET last_used_at = ?1 WHERE id = ?2",
+            params![now, id],
+        ).map_err(|e| format!("Touch failed: {e}"))?;
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn make_db() -> SessionDb {
+        let dir = tempfile::tempdir().unwrap();
+        SessionDb::open(&dir.path().to_path_buf()).unwrap()
+    }
+
+    fn make_session(id: &str, title: &str) -> Session {
+        Session {
+            id: id.to_string(),
+            session_type: "terminal".to_string(),
+            title: title.to_string(),
+            shell: Some("/bin/bash".to_string()),
+            cwd: Some("/home/user".to_string()),
+            args: Some(vec!["--login".to_string()]),
+            group_name: String::new(),
+            created_at: 1000,
+            last_used_at: 2000,
+        }
+    }
+
+    #[test]
+    fn test_list_sessions_empty() {
+        let db = make_db();
+        let sessions = db.list_sessions().unwrap();
+        assert!(sessions.is_empty());
+    }
+
+    #[test]
+    fn test_save_and_list_session() {
+        let db = make_db();
+        let s = make_session("s1", "My Terminal");
+        db.save_session(&s).unwrap();
+
+        let sessions = db.list_sessions().unwrap();
+        assert_eq!(sessions.len(), 1);
+        assert_eq!(sessions[0].id, "s1");
+        assert_eq!(sessions[0].title, "My Terminal");
+        assert_eq!(sessions[0].session_type, "terminal");
+        assert_eq!(sessions[0].shell, Some("/bin/bash".to_string()));
+        assert_eq!(sessions[0].cwd, Some("/home/user".to_string()));
+        assert_eq!(sessions[0].args, Some(vec!["--login".to_string()]));
+        assert_eq!(sessions[0].created_at, 1000);
+        assert_eq!(sessions[0].last_used_at, 2000);
+    }
+
+    #[test]
+    fn test_save_session_upsert() {
+        let db = make_db();
+        let mut s = make_session("s1", "First");
+        db.save_session(&s).unwrap();
+
+        s.title = "Updated".to_string();
+        db.save_session(&s).unwrap();
+
+        let sessions = db.list_sessions().unwrap();
+        assert_eq!(sessions.len(), 1);
+        assert_eq!(sessions[0].title, "Updated");
+    }
+
+    #[test]
+    fn test_delete_session() {
+        let db = make_db();
+        db.save_session(&make_session("s1", "A")).unwrap();
+        db.save_session(&make_session("s2", "B")).unwrap();
+        assert_eq!(db.list_sessions().unwrap().len(), 2);
+
+        db.delete_session("s1").unwrap();
+        let sessions = db.list_sessions().unwrap();
+        assert_eq!(sessions.len(), 1);
+        assert_eq!(sessions[0].id, "s2");
+    }
+
+    #[test]
+    fn test_delete_nonexistent_session_no_error() {
+        let db = make_db();
+        db.delete_session("nonexistent").unwrap();
+    }
+
+    #[test]
+    fn test_update_title() {
+        let db = make_db();
+        db.save_session(&make_session("s1", "Old")).unwrap();
+        db.update_title("s1", "New Title").unwrap();
+
+        let sessions = db.list_sessions().unwrap();
+        assert_eq!(sessions[0].title, "New Title");
+    }
+
+    #[test]
+    fn test_touch_session() {
+        let db = make_db();
+        db.save_session(&make_session("s1", "A")).unwrap();
+
+        let before = db.list_sessions().unwrap()[0].last_used_at;
+        db.touch_session("s1").unwrap();
+        let after = db.list_sessions().unwrap()[0].last_used_at;
+
+        assert!(after > before);
+    }
+
+    #[test]
+    fn test_session_with_no_optional_fields() {
+        let db = make_db();
+        let s = Session {
+            id: "s1".to_string(),
+            session_type: "agent".to_string(),
+            title: "Agent".to_string(),
+            shell: None,
+            cwd: None,
+            args: None,
+            group_name: String::new(),
+            created_at: 1000,
+            last_used_at: 2000,
+        };
+        db.save_session(&s).unwrap();
+
+        let sessions = db.list_sessions().unwrap();
+        assert_eq!(sessions.len(), 1);
+        assert!(sessions[0].shell.is_none());
+        assert!(sessions[0].cwd.is_none());
+        assert!(sessions[0].args.is_none());
+    }
+
+    #[test]
+    fn test_sessions_ordered_by_last_used_desc() {
+        let db = make_db();
+        let mut s1 = make_session("s1", "Older");
+        s1.last_used_at = 1000;
+        let mut s2 = make_session("s2", "Newer");
+        s2.last_used_at = 3000;
+        let mut s3 = make_session("s3", "Middle");
+        s3.last_used_at = 2000;
+
+        db.save_session(&s1).unwrap();
+        db.save_session(&s2).unwrap();
+        db.save_session(&s3).unwrap();
+
+        let sessions = db.list_sessions().unwrap();
+        assert_eq!(sessions[0].id, "s2");
+        assert_eq!(sessions[1].id, "s3");
+        assert_eq!(sessions[2].id, "s1");
+    }
+}
diff --git a/v2/src-tauri/src/session/settings.rs b/v2/src-tauri/src/session/settings.rs
new file mode 100644
index 0000000..b295753
--- /dev/null
+++ b/v2/src-tauri/src/session/settings.rs
@@ -0,0 +1,93 @@
+// Settings persistence (settings table)
+
+use rusqlite::params;
+use super::SessionDb;
+
+impl SessionDb {
+    pub fn get_setting(&self, key: &str) -> Result<Option<String>, String> {
+        let conn = self.conn.lock().unwrap();
+        let mut stmt = conn
+            .prepare("SELECT value FROM settings WHERE key = ?1")
+            .map_err(|e| format!("Settings query failed: {e}"))?;
+        let result = stmt.query_row(params![key], |row| row.get(0));
+        match result {
+            Ok(val) => Ok(Some(val)),
+            Err(rusqlite::Error::QueryReturnedNoRows) => Ok(None),
+            Err(e) => Err(format!("Settings read failed: {e}")),
+        }
+    }
+
+    pub fn set_setting(&self, key: &str, value: &str) -> Result<(), String> {
+        let conn = self.conn.lock().unwrap();
+        conn.execute(
+            "INSERT OR REPLACE INTO settings (key, value) VALUES (?1, ?2)",
+            params![key, value],
+        ).map_err(|e| format!("Settings write failed: {e}"))?;
+        Ok(())
+    }
+
+    pub fn get_all_settings(&self) -> Result<Vec<(String, String)>, String> {
+        let conn = self.conn.lock().unwrap();
+        let mut stmt = conn
+            .prepare("SELECT key, value FROM settings ORDER BY key")
+            .map_err(|e| format!("Settings query failed: {e}"))?;
+        let settings = stmt
+            .query_map([], |row| Ok((row.get(0)?, row.get(1)?)))
+            .map_err(|e| format!("Settings query failed: {e}"))?
+            .collect::<Result<Vec<_>, _>>()
+            .map_err(|e| format!("Settings read failed: {e}"))?;
+        Ok(settings)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn make_db() -> SessionDb {
+        let dir = tempfile::tempdir().unwrap();
+        SessionDb::open(&dir.path().to_path_buf()).unwrap()
+    }
+
+    #[test]
+    fn test_get_setting_missing_returns_none() {
+        let db = make_db();
+        let val = db.get_setting("nonexistent").unwrap();
+        assert!(val.is_none());
+    }
+
+    #[test]
+    fn test_set_and_get_setting() {
+        let db = make_db();
+        db.set_setting("theme", "mocha").unwrap();
+        let val = db.get_setting("theme").unwrap();
+        assert_eq!(val, Some("mocha".to_string()));
+    }
+
+    #[test]
+    fn test_set_setting_overwrites() {
+        let db = make_db();
+        db.set_setting("font_size", "12").unwrap();
+        db.set_setting("font_size", "14").unwrap();
+        assert_eq!(db.get_setting("font_size").unwrap(), Some("14".to_string()));
+    }
+
+    #[test]
+    fn test_get_all_settings() {
+        let db = make_db();
+        db.set_setting("b_key", "val_b").unwrap();
+        db.set_setting("a_key", "val_a").unwrap();
+
+        let all = db.get_all_settings().unwrap();
+        assert_eq!(all.len(), 2);
+        assert_eq!(all[0].0, "a_key");
+        assert_eq!(all[1].0, "b_key");
+    }
+
+    #[test]
+    fn test_get_all_settings_empty() {
+        let db = make_db();
+        let all = db.get_all_settings().unwrap();
+        assert!(all.is_empty());
+    }
+}
diff --git a/v2/src-tauri/src/session/ssh.rs b/v2/src-tauri/src/session/ssh.rs
new file mode 100644
index 0000000..226c48d
--- /dev/null
+++ b/v2/src-tauri/src/session/ssh.rs
@@ -0,0 +1,149 @@
+// SSH session persistence (ssh_sessions table)
+
+use rusqlite::params;
+use serde::{Deserialize, Serialize};
+use super::SessionDb;
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct SshSession {
+    pub id: String,
+    pub name: String,
+    pub host: String,
+    pub port: i32,
+    pub username: String,
+    pub key_file: String,
+    pub folder: String,
+    pub color: String,
+    pub created_at: i64,
+    pub last_used_at: i64,
+}
+
+impl SessionDb {
+    pub fn list_ssh_sessions(&self) -> Result<Vec<SshSession>, String> {
+        let conn = self.conn.lock().unwrap();
+        let mut stmt = conn
+            .prepare("SELECT id, name, host, port, username, key_file, folder, color, created_at, last_used_at FROM ssh_sessions ORDER BY last_used_at DESC")
+            .map_err(|e| format!("SSH query prepare failed: {e}"))?;
+
+        let sessions = stmt
+            .query_map([], |row| {
+                Ok(SshSession {
+                    id: row.get(0)?,
+                    name: row.get(1)?,
+                    host: row.get(2)?,
+                    port: row.get(3)?,
+                    username: row.get(4)?,
+                    key_file: row.get(5)?,
+                    folder: row.get(6)?,
+                    color: row.get(7)?,
+                    created_at: row.get(8)?,
+                    last_used_at: row.get(9)?,
+                })
+            })
+            .map_err(|e| format!("SSH query failed: {e}"))?
+            .collect::<Result<Vec<_>, _>>()
+            .map_err(|e| format!("SSH row read failed: {e}"))?;
+
+        Ok(sessions)
+    }
+
+    pub fn save_ssh_session(&self, session: &SshSession) -> Result<(), String> {
+        let conn = self.conn.lock().unwrap();
+        conn.execute(
+            "INSERT OR REPLACE INTO ssh_sessions (id, name, host, port, username, key_file, folder, color, created_at, last_used_at) VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10)",
+            params![
+                session.id,
+                session.name,
+                session.host,
+                session.port,
+                session.username,
+                session.key_file,
+                session.folder,
+                session.color,
+                session.created_at,
+                session.last_used_at,
+            ],
+        ).map_err(|e| format!("SSH insert failed: {e}"))?;
+        Ok(())
+    }
+
+    pub fn delete_ssh_session(&self, id: &str) -> Result<(), String> {
+        let conn = self.conn.lock().unwrap();
+        conn.execute("DELETE FROM ssh_sessions WHERE id = ?1", params![id])
+            .map_err(|e| format!("SSH delete failed: {e}"))?;
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn make_db() -> SessionDb {
+        let dir = tempfile::tempdir().unwrap();
+        SessionDb::open(&dir.path().to_path_buf()).unwrap()
+    }
+
+    fn make_ssh_session(id: &str, name: &str) -> SshSession {
+        SshSession {
+            id: id.to_string(),
+            name: name.to_string(),
+            host: "example.com".to_string(),
+            port: 22,
+            username: "admin".to_string(),
+            key_file: "/home/user/.ssh/id_rsa".to_string(),
+            folder: "/srv".to_string(),
+            color: "#89b4fa".to_string(),
+            created_at: 1000,
+            last_used_at: 2000,
+        }
+    }
+
+    #[test]
+    fn test_list_ssh_sessions_empty() {
+        let db = make_db();
+        let sessions = db.list_ssh_sessions().unwrap();
+        assert!(sessions.is_empty());
+    }
+
+    #[test]
+    fn test_save_and_list_ssh_session() {
+        let db = make_db();
+        let s = make_ssh_session("ssh1", "Prod Server");
+        db.save_ssh_session(&s).unwrap();
+
+        let sessions = db.list_ssh_sessions().unwrap();
+        assert_eq!(sessions.len(), 1);
+        assert_eq!(sessions[0].id, "ssh1");
+        assert_eq!(sessions[0].name, "Prod Server");
+        assert_eq!(sessions[0].host, "example.com");
+        assert_eq!(sessions[0].port, 22);
+        assert_eq!(sessions[0].username, "admin");
+    }
+
+    #[test]
+    fn test_delete_ssh_session() {
+        let db = make_db();
+        db.save_ssh_session(&make_ssh_session("ssh1", "A")).unwrap();
+        db.save_ssh_session(&make_ssh_session("ssh2", "B")).unwrap();
+
+        db.delete_ssh_session("ssh1").unwrap();
+        let sessions = db.list_ssh_sessions().unwrap();
+        assert_eq!(sessions.len(), 1);
+        assert_eq!(sessions[0].id, "ssh2");
+    }
+
+    #[test]
+    fn test_ssh_session_upsert() {
+        let db = make_db();
+        let mut s = make_ssh_session("ssh1", "First");
+        db.save_ssh_session(&s).unwrap();
+
+        s.name = "Second".to_string();
+        db.save_ssh_session(&s).unwrap();
+
+        let sessions = db.list_ssh_sessions().unwrap();
+        assert_eq!(sessions.len(), 1);
+        assert_eq!(sessions[0].name, "Second");
+    }
+}
diff --git a/v2/src-tauri/src/sidecar.rs b/v2/src-tauri/src/sidecar.rs
new file mode 100644
index 0000000..111266f
--- /dev/null
+++ b/v2/src-tauri/src/sidecar.rs
@@ -0,0 +1,4 @@
+// Thin wrapper — re-exports bterminal_core::sidecar types.
+// SidecarManager is now in bterminal-core; this module only re-exports for lib.rs.
+
+pub use bterminal_core::sidecar::{AgentQueryOptions, SidecarConfig, SidecarManager};
diff --git a/v2/src-tauri/src/telemetry.rs b/v2/src-tauri/src/telemetry.rs
new file mode 100644
index 0000000..0391460
--- /dev/null
+++ b/v2/src-tauri/src/telemetry.rs
@@ -0,0 +1,104 @@
+// OpenTelemetry telemetry — tracing spans + OTLP export to Tempo/Grafana
+//
+// Controlled by BTERMINAL_OTLP_ENDPOINT env var:
+//   - Set (e.g. "http://localhost:4318") → export traces via OTLP/HTTP + console
+//   - Absent → console-only (no network calls)
+
+use opentelemetry::trace::TracerProvider;
+use opentelemetry_sdk::trace::SdkTracerProvider;
+use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt, EnvFilter};
+
+/// Holds the tracer provider and shuts it down on drop.
+/// Store this in Tauri's managed state so it lives for the app lifetime.
+pub struct TelemetryGuard {
+    provider: Option<SdkTracerProvider>,
+}
+
+impl Drop for TelemetryGuard {
+    fn drop(&mut self) {
+        if let Some(provider) = self.provider.take() {
+            if let Err(e) = provider.shutdown() {
+                eprintln!("OTEL shutdown error: {e}");
+            }
+        }
+    }
+}
+
+/// Initialize tracing with optional OTLP export.
+/// Call once at app startup, before any tracing macros fire.
+pub fn init() -> TelemetryGuard {
+    let filter = EnvFilter::try_from_default_env()
+        .unwrap_or_else(|_| EnvFilter::new("bterminal=info,bterminal_lib=info,bterminal_core=info"));
+
+    let fmt_layer = tracing_subscriber::fmt::layer()
+        .with_target(true)
+        .compact();
+
+    // In test mode, never export telemetry (avoid contaminating production data)
+    let is_test = std::env::var("BTERMINAL_TEST").map_or(false, |v| v == "1");
+
+    match std::env::var("BTERMINAL_OTLP_ENDPOINT") {
+        Ok(endpoint) if !endpoint.is_empty() && !is_test => {
+            match build_otlp_provider(&endpoint) {
+                Ok(provider) => {
+                    let otel_layer = tracing_opentelemetry::layer()
+                        .with_tracer(provider.tracer("bterminal"));
+
+                    tracing_subscriber::registry()
+                        .with(filter)
+                        .with(fmt_layer)
+                        .with(otel_layer)
+                        .init();
+
+                    log::info!("Telemetry: OTLP export enabled → {endpoint}");
+                    TelemetryGuard { provider: Some(provider) }
+                }
+                Err(e) => {
+                    // Fall back to console-only if OTLP setup fails
+                    tracing_subscriber::registry()
+                        .with(filter)
+                        .with(fmt_layer)
+                        .init();
+
+                    log::warn!("Telemetry: OTLP setup failed ({e}), console-only fallback");
+                    TelemetryGuard { provider: None }
+                }
+            }
+        }
+        _ => {
+            tracing_subscriber::registry()
+                .with(filter)
+                .with(fmt_layer)
+                .init();
+
+            log::info!("Telemetry: console-only (BTERMINAL_OTLP_ENDPOINT not set)");
+            TelemetryGuard { provider: None }
+        }
+    }
+}
+
+fn build_otlp_provider(endpoint: &str) -> Result<SdkTracerProvider, Box<dyn std::error::Error>> {
+    use opentelemetry_otlp::{SpanExporter, WithExportConfig};
+    use opentelemetry_sdk::trace::SdkTracerProvider;
+    use opentelemetry_sdk::Resource;
+    use opentelemetry::KeyValue;
+
+    let exporter = SpanExporter::builder()
+        .with_http()
+        .with_endpoint(endpoint)
+        .build()?;
+
+    let resource = Resource::builder()
+        .with_attributes([
+            KeyValue::new("service.name", "bterminal"),
+            KeyValue::new("service.version", env!("CARGO_PKG_VERSION")),
+        ])
+        .build();
+
+    let provider = SdkTracerProvider::builder()
+        .with_batch_exporter(exporter)
+        .with_resource(resource)
+        .build();
+
+    Ok(provider)
+}
diff --git a/v2/src-tauri/src/watcher.rs b/v2/src-tauri/src/watcher.rs
new file mode 100644
index 0000000..8ecf0e4
--- /dev/null
+++ b/v2/src-tauri/src/watcher.rs
@@ -0,0 +1,105 @@
+// File watcher for markdown viewer
+// Uses notify crate to watch files and emit Tauri events on change
+
+use notify::{Config, Event, RecommendedWatcher, RecursiveMode, Watcher};
+use serde::Serialize;
+use std::collections::HashMap;
+use std::path::PathBuf;
+use std::sync::Mutex;
+use tauri::Emitter;
+
+#[derive(Clone, Serialize)]
+struct FileChangedPayload {
+    pane_id: String,
+    path: String,
+    content: String,
+}
+
+struct WatchEntry {
+    _watcher: RecommendedWatcher,
+    _path: PathBuf,
+}
+
+pub struct FileWatcherManager {
+    watchers: Mutex<HashMap<String, WatchEntry>>,
+}
+
+impl FileWatcherManager {
+    pub fn new() -> Self {
+        Self {
+            watchers: Mutex::new(HashMap::new()),
+        }
+    }
+
+    pub fn watch(
+        &self,
+        app: &tauri::AppHandle,
+        pane_id: &str,
+        path: &str,
+    ) -> Result<String, String> {
+        // In test mode, skip file watching to avoid inotify noise and flaky events
+        if std::env::var("BTERMINAL_TEST").map_or(false, |v| v == "1") {
+            return std::fs::read_to_string(path)
+                .map_err(|e| format!("Failed to read file: {e}"));
+        }
+
+        let file_path = PathBuf::from(path);
+        if !file_path.exists() {
+            return Err(format!("File not found: {path}"));
+        }
+
+        // Read initial content
+        let content = std::fs::read_to_string(&file_path)
+            .map_err(|e| format!("Failed to read file: {e}"))?;
+
+        // Set up watcher
+        let app_handle = app.clone();
+        let pane_id_owned = pane_id.to_string();
+        let watch_path = file_path.clone();
+
+        let mut watcher = RecommendedWatcher::new(
+            move |res: Result<Event, notify::Error>| {
+                if let Ok(event) = res {
+                    if event.kind.is_modify() {
+                        if let Ok(new_content) = std::fs::read_to_string(&watch_path) {
+                            let _ = app_handle.emit(
+                                "file-changed",
+                                FileChangedPayload {
+                                    pane_id: pane_id_owned.clone(),
+                                    path: watch_path.to_string_lossy().to_string(),
+                                    content: new_content,
+                                },
+                            );
+                        }
+                    }
+                }
+            },
+            Config::default(),
+        )
+        .map_err(|e| format!("Failed to create watcher: {e}"))?;
+
+        let watch_dir = file_path.parent()
+            .ok_or_else(|| format!("Cannot watch root-level path: {path}"))?;
+        watcher
+            .watch(watch_dir, RecursiveMode::NonRecursive)
+            .map_err(|e| format!("Failed to watch path: {e}"))?;
+
+        let mut watchers = self.watchers.lock().unwrap();
+        watchers.insert(pane_id.to_string(), WatchEntry {
+            _watcher: watcher,
+            _path: file_path,
+        });
+
+        Ok(content)
+    }
+
+    pub fn unwatch(&self, pane_id: &str) {
+        let mut watchers = self.watchers.lock().unwrap();
+        watchers.remove(pane_id);
+    }
+
+    pub fn read_file(&self, path: &str) -> Result<String, String> {
+        std::fs::read_to_string(path)
+            .map_err(|e| format!("Failed to read file: {e}"))
+    }
+}
diff --git a/v2/src-tauri/tauri.conf.json b/v2/src-tauri/tauri.conf.json
new file mode 100644
index 0000000..60920c8
--- /dev/null
+++ b/v2/src-tauri/tauri.conf.json
@@ -0,0 +1,69 @@
+{
+  "$schema": "https://schema.tauri.app/config/2",
+  "productName": "bterminal",
+  "version": "0.1.0",
+  "identifier": "com.dexterfromlab.bterminal",
+  "build": {
+    "frontendDist": "../dist",
+    "devUrl": "http://localhost:9700",
+    "beforeDevCommand": "npm run dev",
+    "beforeBuildCommand": "npm run build"
+  },
+  "app": {
+    "windows": [
+      {
+        "title": "BTerminal",
+        "width": 1920,
+        "height": 1080,
+        "resizable": true,
+        "fullscreen": false,
+        "decorations": true
+      }
+    ],
+    "security": {
+      "csp": null
+    }
+  },
+  "plugins": {
+    "updater": {
+      "endpoints": [
+        "https://github.com/DexterFromLab/BTerminal/releases/latest/download/latest.json"
+      ],
+      "dialog": true,
+      "pubkey": "dW50cnVzdGVkIGNvbW1lbnQ6IG1pbmlzaWduIHB1YmxpYyBrZXk6IEJCRkZEMERDMTUwMzY5MjIKUldRaWFRTVYzTkQvdTYwRDh6YStaSE9rWUZYYkRGd3UvVUcydE1IQVdTM29uNTRPTlpjQmFqVFEK"
+    }
+  },
+  "bundle": {
+    "active": true,
+    "targets": ["deb", "appimage"],
+    "icon": [
+      "icons/32x32.png",
+      "icons/128x128.png",
+      "icons/128x128@2x.png",
+      "icons/icon.icns",
+      "icons/icon.ico"
+    ],
+    "resources": [
+      "../sidecar/dist/claude-runner.mjs",
+      "../../btmsg",
+      "../../bttask"
+    ],
+    "category": "DeveloperTool",
+    "shortDescription": "Multi-session Claude agent dashboard",
+    "longDescription": "BTerminal is a terminal emulator with integrated Claude AI agent sessions, SSH management, and a tiling pane layout. Built with Tauri, Svelte 5, and xterm.js.",
+    "linux": {
+      "deb": {
+        "depends": [
+          "libwebkit2gtk-4.1-0",
+          "libgtk-3-0",
+          "libayatana-appindicator3-1"
+        ],
+        "section": "devel",
+        "priority": "optional"
+      },
+      "appimage": {
+        "bundleMediaFramework": false
+      }
+    }
+  }
+}
diff --git a/v2/src/App.svelte b/v2/src/App.svelte
new file mode 100644
index 0000000..634cc69
--- /dev/null
+++ b/v2/src/App.svelte
@@ -0,0 +1,392 @@
+<script lang="ts">
+  import { onMount } from 'svelte';
+  import { initTheme } from './lib/stores/theme.svelte';
+  import { getSetting } from './lib/adapters/settings-bridge';
+  import { isDetachedMode, getDetachedConfig } from './lib/utils/detach';
+  import { startAgentDispatcher, stopAgentDispatcher } from './lib/agent-dispatcher';
+  import { startHealthTick, stopHealthTick, clearHealthTracking } from './lib/stores/health.svelte';
+  import { registerProvider } from './lib/providers/registry.svelte';
+  import { CLAUDE_PROVIDER } from './lib/providers/claude';
+  import { CODEX_PROVIDER } from './lib/providers/codex';
+  import { OLLAMA_PROVIDER } from './lib/providers/ollama';
+  import { registerMemoryAdapter } from './lib/adapters/memory-adapter';
+  import { MemoraAdapter } from './lib/adapters/memora-bridge';
+  import {
+    loadWorkspace, getActiveTab, setActiveTab, setActiveProject,
+    getEnabledProjects, getAllWorkItems, getActiveProjectId,
+    triggerFocusFlash, emitProjectTabSwitch, emitTerminalToggle,
+  } from './lib/stores/workspace.svelte';
+  import { disableWakeScheduler } from './lib/stores/wake-scheduler.svelte';
+  import { invoke } from '@tauri-apps/api/core';
+
+  // Workspace components
+  import GlobalTabBar from './lib/components/Workspace/GlobalTabBar.svelte';
+  import GroupAgentsPanel from './lib/components/Workspace/GroupAgentsPanel.svelte';
+  import ProjectGrid from './lib/components/Workspace/ProjectGrid.svelte';
+  import SettingsTab from './lib/components/Workspace/SettingsTab.svelte';
+  import CommsTab from './lib/components/Workspace/CommsTab.svelte';
+  import CommandPalette from './lib/components/Workspace/CommandPalette.svelte';
+  import SearchOverlay from './lib/components/Workspace/SearchOverlay.svelte';
+
+  // Shared
+  import StatusBar from './lib/components/StatusBar/StatusBar.svelte';
+  import ToastContainer from './lib/components/Notifications/ToastContainer.svelte';
+
+  // Detached mode (preserved from v2)
+  import TerminalPane from './lib/components/Terminal/TerminalPane.svelte';
+  import AgentPane from './lib/components/Agent/AgentPane.svelte';
+
+  let detached = isDetachedMode();
+  let detachedConfig = getDetachedConfig();
+
+  let paletteOpen = $state(false);
+  let searchOpen = $state(false);
+  let drawerOpen = $state(false);
+  let loaded = $state(false);
+
+  let activeTab = $derived(getActiveTab());
+  let panelContentEl: HTMLElement | undefined = $state();
+  let panelWidth = $state<string | undefined>(undefined);
+
+  // Measure the panel content's natural width
+  $effect(() => {
+    const el = panelContentEl;
+    void activeTab;
+    if (!el) { panelWidth = undefined; return; }
+    const frame = requestAnimationFrame(() => {
+      let maxW = 0;
+      const candidates = el.querySelectorAll('[style*="white-space"], h3, h4, input, .settings-list, .settings-tab');
+      for (const c of candidates) {
+        maxW = Math.max(maxW, c.scrollWidth);
+      }
+      const child = el.firstElementChild as HTMLElement;
+      if (child) {
+        const cs = getComputedStyle(child);
+        const mw = parseFloat(cs.minWidth);
+        if (!isNaN(mw)) maxW = Math.max(maxW, mw);
+      }
+      if (maxW > 0) {
+        panelWidth = `${maxW + 24}px`;
+      }
+    });
+    return () => cancelAnimationFrame(frame);
+  });
+
+  function toggleDrawer() {
+    drawerOpen = !drawerOpen;
+  }
+
+  onMount(() => {
+    initTheme();
+    getSetting('project_max_aspect').then(v => {
+      if (v) document.documentElement.style.setProperty('--project-max-aspect', v);
+    });
+    registerProvider(CLAUDE_PROVIDER);
+    registerProvider(CODEX_PROVIDER);
+    registerProvider(OLLAMA_PROVIDER);
+    const memora = new MemoraAdapter();
+    registerMemoryAdapter(memora);
+    memora.checkAvailability();
+    startAgentDispatcher();
+    startHealthTick();
+
+    // Disable wake scheduler in test mode to prevent timer interference
+    invoke<boolean>('is_test_mode').then(isTest => {
+      if (isTest) disableWakeScheduler();
+    });
+
+    if (!detached) {
+      loadWorkspace().then(() => { loaded = true; });
+    }
+
+    /** Check if event target is an editable element (input, textarea, contenteditable) */
+    function isEditing(e: KeyboardEvent): boolean {
+      const t = e.target as HTMLElement;
+      if (!t) return false;
+      const tag = t.tagName;
+      if (tag === 'INPUT' || tag === 'TEXTAREA') return true;
+      if (t.isContentEditable) return true;
+      // xterm.js canvases and textareas should be considered editing
+      if (t.closest('.xterm')) return true;
+      return false;
+    }
+
+    function handleKeydown(e: KeyboardEvent) {
+      // Ctrl+K — command palette (always active)
+      if (e.ctrlKey && !e.shiftKey && e.key === 'k') {
+        e.preventDefault();
+        paletteOpen = !paletteOpen;
+        return;
+      }
+
+      // Ctrl+Shift+F — global search overlay
+      if (e.ctrlKey && e.shiftKey && (e.key === 'F' || e.key === 'f')) {
+        e.preventDefault();
+        searchOpen = !searchOpen;
+        return;
+      }
+
+      // Alt+1..5 — quick-jump to project by index
+      if (e.altKey && !e.ctrlKey && !e.shiftKey && e.key >= '1' && e.key <= '5') {
+        e.preventDefault();
+        const projects = getAllWorkItems();
+        const idx = parseInt(e.key) - 1;
+        if (idx < projects.length) {
+          setActiveProject(projects[idx].id);
+          triggerFocusFlash(projects[idx].id);
+        }
+        return;
+      }
+
+      // Ctrl+Shift+1..9 — switch tab within focused project
+      if (e.ctrlKey && e.shiftKey && e.key >= '1' && e.key <= '9') {
+        // Allow Ctrl+Shift+K to pass through to its own handler
+        if (e.key === 'K') return;
+        e.preventDefault();
+        const projectId = getActiveProjectId();
+        if (projectId) {
+          const tabIdx = parseInt(e.key);
+          emitProjectTabSwitch(projectId, tabIdx);
+        }
+        return;
+      }
+
+      // Ctrl+Shift+K — focus agent pane (switch to Model tab)
+      if (e.ctrlKey && e.shiftKey && (e.key === 'K' || e.key === 'k')) {
+        e.preventDefault();
+        const projectId = getActiveProjectId();
+        if (projectId) {
+          emitProjectTabSwitch(projectId, 1); // Model tab
+        }
+        return;
+      }
+
+      // Vi-style navigation (skip when editing text)
+      if (e.ctrlKey && !e.shiftKey && !e.altKey && !isEditing(e)) {
+        const projects = getAllWorkItems();
+        const currentId = getActiveProjectId();
+        const currentIdx = projects.findIndex(p => p.id === currentId);
+
+        // Ctrl+H — focus previous project (left)
+        if (e.key === 'h') {
+          e.preventDefault();
+          if (currentIdx > 0) {
+            setActiveProject(projects[currentIdx - 1].id);
+            triggerFocusFlash(projects[currentIdx - 1].id);
+          }
+          return;
+        }
+
+        // Ctrl+L — focus next project (right)
+        if (e.key === 'l') {
+          e.preventDefault();
+          if (currentIdx >= 0 && currentIdx < projects.length - 1) {
+            setActiveProject(projects[currentIdx + 1].id);
+            triggerFocusFlash(projects[currentIdx + 1].id);
+          }
+          return;
+        }
+
+        // Ctrl+J — toggle terminal section in focused project
+        if (e.key === 'j') {
+          e.preventDefault();
+          if (currentId) {
+            emitTerminalToggle(currentId);
+          }
+          return;
+        }
+      }
+
+      // Ctrl+, — toggle settings panel
+      if (e.ctrlKey && e.key === ',') {
+        e.preventDefault();
+        if (getActiveTab() === 'settings' && drawerOpen) {
+          drawerOpen = false;
+        } else {
+          setActiveTab('settings');
+          drawerOpen = true;
+        }
+        return;
+      }
+
+      // Ctrl+M — toggle messages panel
+      if (e.ctrlKey && !e.shiftKey && e.key === 'm') {
+        e.preventDefault();
+        if (getActiveTab() === 'comms' && drawerOpen) {
+          drawerOpen = false;
+        } else {
+          setActiveTab('comms');
+          drawerOpen = true;
+        }
+        return;
+      }
+
+      // Ctrl+B — toggle sidebar
+      if (e.ctrlKey && !e.shiftKey && e.key === 'b') {
+        e.preventDefault();
+        drawerOpen = !drawerOpen;
+        return;
+      }
+
+      // Escape — close drawer
+      if (e.key === 'Escape' && drawerOpen) {
+        e.preventDefault();
+        drawerOpen = false;
+        return;
+      }
+    }
+
+    window.addEventListener('keydown', handleKeydown);
+    return () => {
+      window.removeEventListener('keydown', handleKeydown);
+      stopAgentDispatcher();
+      stopHealthTick();
+    };
+  });
+</script>
+
+{#if detached && detachedConfig}
+  <div class="detached-pane">
+    {#if detachedConfig.type === 'terminal' || detachedConfig.type === 'ssh'}
+      <TerminalPane
+        shell={detachedConfig.shell}
+        cwd={detachedConfig.cwd}
+        args={detachedConfig.args}
+      />
+    {:else if detachedConfig.type === 'agent'}
+      <AgentPane
+        sessionId={detachedConfig.sessionId ?? crypto.randomUUID()}
+        cwd={detachedConfig.cwd}
+      />
+    {:else}
+      <TerminalPane />
+    {/if}
+  </div>
+{:else if loaded}
+  <div class="app-shell">
+    <div class="main-row">
+      <GlobalTabBar expanded={drawerOpen} ontoggle={toggleDrawer} />
+
+      {#if drawerOpen}
+        <aside class="sidebar-panel" style:width={panelWidth}>
+          <div class="panel-header">
+            <h2>{activeTab === 'comms' ? 'Messages' : 'Settings'}</h2>
+            <button class="panel-close" onclick={() => drawerOpen = false} title="Close sidebar (Ctrl+B)">
+              <svg width="14" height="14" viewBox="0 0 14 14" fill="none">
+                <path d="M2 2l10 10M12 2L2 12" stroke="currentColor" stroke-width="1.5" stroke-linecap="round"/>
+              </svg>
+            </button>
+          </div>
+          <div class="panel-content" bind:this={panelContentEl}>
+            {#if activeTab === 'comms'}
+              <CommsTab />
+            {:else}
+              <SettingsTab />
+            {/if}
+          </div>
+        </aside>
+      {/if}
+
+      <main class="workspace">
+        <GroupAgentsPanel />
+        <ProjectGrid />
+      </main>
+    </div>
+
+    <StatusBar />
+  </div>
+
+  <CommandPalette open={paletteOpen} onclose={() => paletteOpen = false} />
+  <SearchOverlay open={searchOpen} onclose={() => searchOpen = false} />
+{:else}
+  <div class="loading">Loading workspace...</div>
+{/if}
+<ToastContainer />
+
+<style>
+  .detached-pane {
+    height: 100vh;
+    width: 100vw;
+    background: var(--ctp-base);
+  }
+
+  .app-shell {
+    display: flex;
+    flex-direction: column;
+    height: 100vh;
+    background: var(--ctp-base);
+    overflow: hidden;
+  }
+
+  .main-row {
+    flex: 1;
+    display: flex;
+    overflow: hidden;
+  }
+
+  .sidebar-panel {
+    min-width: 16em;
+    max-width: 50%;
+    display: flex;
+    flex-direction: column;
+    background: var(--ctp-base);
+    border-right: 1px solid var(--ctp-surface1);
+    flex-shrink: 0;
+  }
+
+  .panel-header {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    padding: 0.5rem 0.75rem;
+    border-bottom: 1px solid var(--ctp-surface0);
+    flex-shrink: 0;
+  }
+
+  .panel-header h2 {
+    font-size: 0.8rem;
+    font-weight: 600;
+    color: var(--ctp-text);
+    margin: 0;
+  }
+
+  .panel-close {
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    width: 1.375rem;
+    height: 1.375rem;
+    background: transparent;
+    border: none;
+    border-radius: 0.25rem;
+    color: var(--ctp-subtext0);
+    cursor: pointer;
+  }
+
+  .panel-close:hover {
+    color: var(--ctp-text);
+    background: var(--ctp-surface0);
+  }
+
+  .panel-content {
+    flex: 1;
+    overflow-y: auto;
+  }
+
+  .workspace {
+    flex: 1;
+    overflow: hidden;
+    display: flex;
+    flex-direction: column;
+  }
+
+  .loading {
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    height: 100vh;
+    color: var(--ctp-overlay0);
+    font-size: 0.9rem;
+    background: var(--ctp-base);
+  }
+</style>
diff --git a/v2/src/app.css b/v2/src/app.css
new file mode 100644
index 0000000..c0bc9aa
--- /dev/null
+++ b/v2/src/app.css
@@ -0,0 +1,44 @@
+@import './lib/styles/catppuccin.css';
+
+*,
+*::before,
+*::after {
+  box-sizing: border-box;
+  margin: 0;
+  padding: 0;
+}
+
+html, body {
+  height: 100%;
+  width: 100%;
+  overflow: hidden;
+  background: var(--bg-primary);
+  color: var(--text-primary);
+  font-family: var(--ui-font-family);
+  font-size: var(--ui-font-size);
+  line-height: 1.4;
+  -webkit-font-smoothing: antialiased;
+}
+
+#app {
+  height: 100%;
+  width: 100%;
+}
+
+::-webkit-scrollbar {
+  width: 6px;
+  height: 6px;
+}
+
+::-webkit-scrollbar-track {
+  background: var(--bg-secondary);
+}
+
+::-webkit-scrollbar-thumb {
+  background: var(--ctp-surface2);
+  border-radius: 3px;
+}
+
+::-webkit-scrollbar-thumb:hover {
+  background: var(--ctp-overlay0);
+}
diff --git a/v2/src/lib/adapters/agent-bridge.test.ts b/v2/src/lib/adapters/agent-bridge.test.ts
new file mode 100644
index 0000000..e9a2b8e
--- /dev/null
+++ b/v2/src/lib/adapters/agent-bridge.test.ts
@@ -0,0 +1,170 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+// Use vi.hoisted to declare mocks that are accessible inside vi.mock factories
+const { mockInvoke, mockListen } = vi.hoisted(() => ({
+  mockInvoke: vi.fn(),
+  mockListen: vi.fn(),
+}));
+
+vi.mock('@tauri-apps/api/core', () => ({
+  invoke: mockInvoke,
+}));
+
+vi.mock('@tauri-apps/api/event', () => ({
+  listen: mockListen,
+}));
+
+import {
+  queryAgent,
+  stopAgent,
+  isAgentReady,
+  restartAgent,
+  onSidecarMessage,
+  onSidecarExited,
+  type AgentQueryOptions,
+} from './agent-bridge';
+
+beforeEach(() => {
+  vi.clearAllMocks();
+});
+
+describe('agent-bridge', () => {
+  describe('queryAgent', () => {
+    it('invokes agent_query with options', async () => {
+      mockInvoke.mockResolvedValue(undefined);
+
+      const options: AgentQueryOptions = {
+        session_id: 'sess-1',
+        prompt: 'Hello Claude',
+        cwd: '/tmp',
+        max_turns: 10,
+        max_budget_usd: 1.0,
+      };
+
+      await queryAgent(options);
+
+      expect(mockInvoke).toHaveBeenCalledWith('agent_query', { options });
+    });
+
+    it('passes minimal options (only required fields)', async () => {
+      mockInvoke.mockResolvedValue(undefined);
+
+      const options: AgentQueryOptions = {
+        session_id: 'sess-2',
+        prompt: 'Do something',
+      };
+
+      await queryAgent(options);
+
+      expect(mockInvoke).toHaveBeenCalledWith('agent_query', { options });
+    });
+
+    it('propagates invoke errors', async () => {
+      mockInvoke.mockRejectedValue(new Error('Sidecar not running'));
+
+      await expect(
+        queryAgent({ session_id: 'sess-3', prompt: 'test' }),
+      ).rejects.toThrow('Sidecar not running');
+    });
+  });
+
+  describe('stopAgent', () => {
+    it('invokes agent_stop with session ID', async () => {
+      mockInvoke.mockResolvedValue(undefined);
+
+      await stopAgent('sess-1');
+
+      expect(mockInvoke).toHaveBeenCalledWith('agent_stop', { sessionId: 'sess-1' });
+    });
+  });
+
+  describe('isAgentReady', () => {
+    it('returns true when sidecar is ready', async () => {
+      mockInvoke.mockResolvedValue(true);
+
+      const result = await isAgentReady();
+
+      expect(result).toBe(true);
+      expect(mockInvoke).toHaveBeenCalledWith('agent_ready');
+    });
+
+    it('returns false when sidecar is not ready', async () => {
+      mockInvoke.mockResolvedValue(false);
+
+      const result = await isAgentReady();
+
+      expect(result).toBe(false);
+    });
+  });
+
+  describe('restartAgent', () => {
+    it('invokes agent_restart', async () => {
+      mockInvoke.mockResolvedValue(undefined);
+
+      await restartAgent();
+
+      expect(mockInvoke).toHaveBeenCalledWith('agent_restart');
+    });
+  });
+
+  describe('onSidecarMessage', () => {
+    it('registers listener on sidecar-message event', async () => {
+      const unlisten = vi.fn();
+      mockListen.mockResolvedValue(unlisten);
+
+      const callback = vi.fn();
+      const result = await onSidecarMessage(callback);
+
+      expect(mockListen).toHaveBeenCalledWith('sidecar-message', expect.any(Function));
+      expect(result).toBe(unlisten);
+    });
+
+    it('extracts payload and passes to callback', async () => {
+      mockListen.mockImplementation(async (_event: string, handler: (e: unknown) => void) => {
+        // Simulate Tauri event delivery
+        handler({
+          payload: {
+            type: 'agent_event',
+            sessionId: 'sess-1',
+            event: { type: 'system', subtype: 'init' },
+          },
+        });
+        return vi.fn();
+      });
+
+      const callback = vi.fn();
+      await onSidecarMessage(callback);
+
+      expect(callback).toHaveBeenCalledWith({
+        type: 'agent_event',
+        sessionId: 'sess-1',
+        event: { type: 'system', subtype: 'init' },
+      });
+    });
+  });
+
+  describe('onSidecarExited', () => {
+    it('registers listener on sidecar-exited event', async () => {
+      const unlisten = vi.fn();
+      mockListen.mockResolvedValue(unlisten);
+
+      const callback = vi.fn();
+      const result = await onSidecarExited(callback);
+
+      expect(mockListen).toHaveBeenCalledWith('sidecar-exited', expect.any(Function));
+      expect(result).toBe(unlisten);
+    });
+
+    it('invokes callback without arguments on exit', async () => {
+      mockListen.mockImplementation(async (_event: string, handler: () => void) => {
+        handler();
+        return vi.fn();
+      });
+
+      const callback = vi.fn();
+      await onSidecarExited(callback);
+
+      expect(callback).toHaveBeenCalledWith();
+    });
+  });
+});
diff --git a/v2/src/lib/adapters/agent-bridge.ts b/v2/src/lib/adapters/agent-bridge.ts
new file mode 100644
index 0000000..df92e9e
--- /dev/null
+++ b/v2/src/lib/adapters/agent-bridge.ts
@@ -0,0 +1,86 @@
+// Agent Bridge — Tauri IPC adapter for sidecar communication
+// Mirrors pty-bridge.ts pattern: invoke for commands, listen for events
+
+import { invoke } from '@tauri-apps/api/core';
+import { listen, type UnlistenFn } from '@tauri-apps/api/event';
+
+import type { ProviderId } from '../providers/types';
+
+export interface AgentQueryOptions {
+  provider?: ProviderId;
+  session_id: string;
+  prompt: string;
+  cwd?: string;
+  max_turns?: number;
+  max_budget_usd?: number;
+  resume_session_id?: string;
+  permission_mode?: string;
+  setting_sources?: string[];
+  system_prompt?: string;
+  model?: string;
+  claude_config_dir?: string;
+  additional_directories?: string[];
+  /** When set, agent runs in a git worktree for isolation */
+  worktree_name?: string;
+  provider_config?: Record<string, unknown>;
+  /** Extra environment variables injected into the agent process (e.g. BTMSG_AGENT_ID) */
+  extra_env?: Record<string, string>;
+  remote_machine_id?: string;
+}
+
+export async function queryAgent(options: AgentQueryOptions): Promise<void> {
+  if (options.remote_machine_id) {
+    const { remote_machine_id: machineId, ...agentOptions } = options;
+    return invoke('remote_agent_query', { machineId, options: agentOptions });
+  }
+  return invoke('agent_query', { options });
+}
+
+export async function stopAgent(sessionId: string, remoteMachineId?: string): Promise<void> {
+  if (remoteMachineId) {
+    return invoke('remote_agent_stop', { machineId: remoteMachineId, sessionId });
+  }
+  return invoke('agent_stop', { sessionId });
+}
+
+export async function isAgentReady(): Promise<boolean> {
+  return invoke<boolean>('agent_ready');
+}
+
+export async function restartAgent(): Promise<void> {
+  return invoke('agent_restart');
+}
+
+/** Update Landlock sandbox config and restart sidecar to apply. */
+export async function setSandbox(
+  projectCwds: string[],
+  worktreeRoots: string[],
+  enabled: boolean,
+): Promise<void> {
+  return invoke('agent_set_sandbox', { projectCwds, worktreeRoots, enabled });
+}
+
+export interface SidecarMessage {
+  type: string;
+  sessionId?: string;
+  event?: Record<string, unknown>;
+  message?: string;
+  exitCode?: number | null;
+  signal?: string | null;
+}
+
+export async function onSidecarMessage(
+  callback: (msg: SidecarMessage) => void,
+): Promise<UnlistenFn> {
+  return listen<SidecarMessage>('sidecar-message', (event) => {
+    const payload = event.payload;
+    if (typeof payload !== 'object' || payload === null) return;
+    callback(payload as SidecarMessage);
+  });
+}
+
+export async function onSidecarExited(callback: () => void): Promise<UnlistenFn> {
+  return listen('sidecar-exited', () => {
+    callback();
+  });
+}
diff --git a/v2/src/lib/adapters/anchors-bridge.ts b/v2/src/lib/adapters/anchors-bridge.ts
new file mode 100644
index 0000000..abc51ca
--- /dev/null
+++ b/v2/src/lib/adapters/anchors-bridge.ts
@@ -0,0 +1,25 @@
+// Anchors Bridge — Tauri IPC adapter for session anchor CRUD
+// Mirrors groups-bridge.ts pattern
+
+import { invoke } from '@tauri-apps/api/core';
+import type { SessionAnchorRecord } from '../types/anchors';
+
+export async function saveSessionAnchors(anchors: SessionAnchorRecord[]): Promise<void> {
+  return invoke('session_anchors_save', { anchors });
+}
+
+export async function loadSessionAnchors(projectId: string): Promise<SessionAnchorRecord[]> {
+  return invoke('session_anchors_load', { projectId });
+}
+
+export async function deleteSessionAnchor(id: string): Promise<void> {
+  return invoke('session_anchor_delete', { id });
+}
+
+export async function clearProjectAnchors(projectId: string): Promise<void> {
+  return invoke('session_anchors_clear', { projectId });
+}
+
+export async function updateAnchorType(id: string, anchorType: string): Promise<void> {
+  return invoke('session_anchor_update_type', { id, anchorType });
+}
diff --git a/v2/src/lib/adapters/audit-bridge.ts b/v2/src/lib/adapters/audit-bridge.ts
new file mode 100644
index 0000000..34bba68
--- /dev/null
+++ b/v2/src/lib/adapters/audit-bridge.ts
@@ -0,0 +1,57 @@
+/**
+ * Audit log bridge — reads/writes audit events via Tauri IPC.
+ * Used by agent-dispatcher, wake-scheduler, and AgentSession for event tracking.
+ */
+
+import { invoke } from '@tauri-apps/api/core';
+import type { AgentId, GroupId } from '../types/ids';
+
+export interface AuditEntry {
+  id: number;
+  agentId: string;
+  eventType: string;
+  detail: string;
+  createdAt: string;
+}
+
+/** Audit event types */
+export type AuditEventType =
+  | 'prompt_injection'
+  | 'wake_event'
+  | 'btmsg_sent'
+  | 'btmsg_received'
+  | 'status_change'
+  | 'heartbeat_missed'
+  | 'dead_letter';
+
+/**
+ * Log an audit event for an agent.
+ */
+export async function logAuditEvent(
+  agentId: AgentId,
+  eventType: AuditEventType,
+  detail: string,
+): Promise<void> {
+  return invoke('audit_log_event', { agentId, eventType, detail });
+}
+
+/**
+ * Get audit log entries for a group (reverse chronological).
+ */
+export async function getAuditLog(
+  groupId: GroupId,
+  limit: number = 200,
+  offset: number = 0,
+): Promise<AuditEntry[]> {
+  return invoke('audit_log_list', { groupId, limit, offset });
+}
+
+/**
+ * Get audit log entries for a specific agent.
+ */
+export async function getAuditLogForAgent(
+  agentId: AgentId,
+  limit: number = 50,
+): Promise<AuditEntry[]> {
+  return invoke('audit_log_for_agent', { agentId, limit });
+}
diff --git a/v2/src/lib/adapters/btmsg-bridge.test.ts b/v2/src/lib/adapters/btmsg-bridge.test.ts
new file mode 100644
index 0000000..2905622
--- /dev/null
+++ b/v2/src/lib/adapters/btmsg-bridge.test.ts
@@ -0,0 +1,251 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+const { mockInvoke } = vi.hoisted(() => ({
+  mockInvoke: vi.fn(),
+}));
+
+vi.mock('@tauri-apps/api/core', () => ({
+  invoke: mockInvoke,
+}));
+
+import {
+  getGroupAgents,
+  getUnreadCount,
+  getUnreadMessages,
+  getHistory,
+  sendMessage,
+  setAgentStatus,
+  ensureAdmin,
+  getAllFeed,
+  markRead,
+  getChannels,
+  getChannelMessages,
+  sendChannelMessage,
+  createChannel,
+  addChannelMember,
+  registerAgents,
+  type BtmsgAgent,
+  type BtmsgMessage,
+  type BtmsgFeedMessage,
+  type BtmsgChannel,
+  type BtmsgChannelMessage,
+} from './btmsg-bridge';
+import { GroupId, AgentId } from '../types/ids';
+
+beforeEach(() => {
+  vi.clearAllMocks();
+});
+
+describe('btmsg-bridge', () => {
+  // ---- REGRESSION: camelCase field names ----
+  // Bug: TypeScript interfaces used snake_case (group_id, unread_count, from_agent, etc.)
+  // but Rust serde(rename_all = "camelCase") sends camelCase.
+
+  describe('BtmsgAgent camelCase fields', () => {
+    it('receives camelCase fields from Rust backend', async () => {
+      const agent: BtmsgAgent = {
+        id: AgentId('a1'),
+        name: 'Coder',
+        role: 'developer',
+        groupId: GroupId('g1'),       // was: group_id
+        tier: 1,
+        model: 'claude-4',
+        status: 'active',
+        unreadCount: 3,       // was: unread_count
+      };
+      mockInvoke.mockResolvedValue([agent]);
+
+      const result = await getGroupAgents(GroupId('g1'));
+
+      expect(result).toHaveLength(1);
+      expect(result[0].groupId).toBe('g1');
+      expect(result[0].unreadCount).toBe(3);
+      // Verify snake_case fields do NOT exist
+      expect((result[0] as Record<string, unknown>)['group_id']).toBeUndefined();
+      expect((result[0] as Record<string, unknown>)['unread_count']).toBeUndefined();
+    });
+
+    it('invokes btmsg_get_agents with groupId', async () => {
+      mockInvoke.mockResolvedValue([]);
+      await getGroupAgents(GroupId('g1'));
+      expect(mockInvoke).toHaveBeenCalledWith('btmsg_get_agents', { groupId: 'g1' });
+    });
+  });
+
+  describe('BtmsgMessage camelCase fields', () => {
+    it('receives camelCase fields from Rust backend', async () => {
+      const msg: BtmsgMessage = {
+        id: 'm1',
+        fromAgent: AgentId('a1'),      // was: from_agent
+        toAgent: AgentId('a2'),        // was: to_agent
+        content: 'hello',
+        read: false,
+        replyTo: null,         // was: reply_to
+        createdAt: '2026-01-01', // was: created_at
+        senderName: 'Coder',  // was: sender_name
+        senderRole: 'dev',    // was: sender_role
+      };
+      mockInvoke.mockResolvedValue([msg]);
+
+      const result = await getUnreadMessages(AgentId('a2'));
+
+      expect(result[0].fromAgent).toBe('a1');
+      expect(result[0].toAgent).toBe('a2');
+      expect(result[0].replyTo).toBeNull();
+      expect(result[0].createdAt).toBe('2026-01-01');
+      expect(result[0].senderName).toBe('Coder');
+      expect(result[0].senderRole).toBe('dev');
+    });
+  });
+
+  describe('BtmsgFeedMessage camelCase fields', () => {
+    it('receives camelCase fields including recipient info', async () => {
+      const feed: BtmsgFeedMessage = {
+        id: 'm1',
+        fromAgent: AgentId('a1'),
+        toAgent: AgentId('a2'),
+        content: 'review this',
+        createdAt: '2026-01-01',
+        replyTo: null,
+        senderName: 'Coder',
+        senderRole: 'developer',
+        recipientName: 'Reviewer',
+        recipientRole: 'reviewer',
+      };
+      mockInvoke.mockResolvedValue([feed]);
+
+      const result = await getAllFeed(GroupId('g1'));
+
+      expect(result[0].senderName).toBe('Coder');
+      expect(result[0].recipientName).toBe('Reviewer');
+      expect(result[0].recipientRole).toBe('reviewer');
+    });
+  });
+
+  describe('BtmsgChannel camelCase fields', () => {
+    it('receives camelCase fields', async () => {
+      const channel: BtmsgChannel = {
+        id: 'ch1',
+        name: 'general',
+        groupId: GroupId('g1'),        // was: group_id
+        createdBy: AgentId('admin'),   // was: created_by
+        memberCount: 5,       // was: member_count
+        createdAt: '2026-01-01',
+      };
+      mockInvoke.mockResolvedValue([channel]);
+
+      const result = await getChannels(GroupId('g1'));
+
+      expect(result[0].groupId).toBe('g1');
+      expect(result[0].createdBy).toBe('admin');
+      expect(result[0].memberCount).toBe(5);
+    });
+  });
+
+  describe('BtmsgChannelMessage camelCase fields', () => {
+    it('receives camelCase fields', async () => {
+      const msg: BtmsgChannelMessage = {
+        id: 'cm1',
+        channelId: 'ch1',     // was: channel_id
+        fromAgent: AgentId('a1'),
+        content: 'hello',
+        createdAt: '2026-01-01',
+        senderName: 'Coder',
+        senderRole: 'dev',
+      };
+      mockInvoke.mockResolvedValue([msg]);
+
+      const result = await getChannelMessages('ch1');
+
+      expect(result[0].channelId).toBe('ch1');
+      expect(result[0].fromAgent).toBe('a1');
+      expect(result[0].senderName).toBe('Coder');
+    });
+  });
+
+  // ---- IPC command name tests ----
+
+  describe('IPC commands', () => {
+    it('getUnreadCount invokes btmsg_unread_count', async () => {
+      mockInvoke.mockResolvedValue(5);
+      const result = await getUnreadCount(AgentId('a1'));
+      expect(result).toBe(5);
+      expect(mockInvoke).toHaveBeenCalledWith('btmsg_unread_count', { agentId: 'a1' });
+    });
+
+    it('getHistory invokes btmsg_history', async () => {
+      mockInvoke.mockResolvedValue([]);
+      await getHistory(AgentId('a1'), AgentId('a2'), 50);
+      expect(mockInvoke).toHaveBeenCalledWith('btmsg_history', { agentId: 'a1', otherId: 'a2', limit: 50 });
+    });
+
+    it('getHistory defaults limit to 20', async () => {
+      mockInvoke.mockResolvedValue([]);
+      await getHistory(AgentId('a1'), AgentId('a2'));
+      expect(mockInvoke).toHaveBeenCalledWith('btmsg_history', { agentId: 'a1', otherId: 'a2', limit: 20 });
+    });
+
+    it('sendMessage invokes btmsg_send', async () => {
+      mockInvoke.mockResolvedValue('msg-id');
+      const result = await sendMessage(AgentId('a1'), AgentId('a2'), 'hello');
+      expect(result).toBe('msg-id');
+      expect(mockInvoke).toHaveBeenCalledWith('btmsg_send', { fromAgent: 'a1', toAgent: 'a2', content: 'hello' });
+    });
+
+    it('setAgentStatus invokes btmsg_set_status', async () => {
+      mockInvoke.mockResolvedValue(undefined);
+      await setAgentStatus(AgentId('a1'), 'active');
+      expect(mockInvoke).toHaveBeenCalledWith('btmsg_set_status', { agentId: 'a1', status: 'active' });
+    });
+
+    it('ensureAdmin invokes btmsg_ensure_admin', async () => {
+      mockInvoke.mockResolvedValue(undefined);
+      await ensureAdmin(GroupId('g1'));
+      expect(mockInvoke).toHaveBeenCalledWith('btmsg_ensure_admin', { groupId: 'g1' });
+    });
+
+    it('markRead invokes btmsg_mark_read', async () => {
+      mockInvoke.mockResolvedValue(undefined);
+      await markRead(AgentId('a2'), AgentId('a1'));
+      expect(mockInvoke).toHaveBeenCalledWith('btmsg_mark_read', { readerId: 'a2', senderId: 'a1' });
+    });
+
+    it('sendChannelMessage invokes btmsg_channel_send', async () => {
+      mockInvoke.mockResolvedValue('cm-id');
+      const result = await sendChannelMessage('ch1', AgentId('a1'), 'hello channel');
+      expect(result).toBe('cm-id');
+      expect(mockInvoke).toHaveBeenCalledWith('btmsg_channel_send', { channelId: 'ch1', fromAgent: 'a1', content: 'hello channel' });
+    });
+
+    it('createChannel invokes btmsg_create_channel', async () => {
+      mockInvoke.mockResolvedValue('ch-id');
+      const result = await createChannel('general', GroupId('g1'), AgentId('admin'));
+      expect(result).toBe('ch-id');
+      expect(mockInvoke).toHaveBeenCalledWith('btmsg_create_channel', { name: 'general', groupId: 'g1', createdBy: 'admin' });
+    });
+
+    it('addChannelMember invokes btmsg_add_channel_member', async () => {
+      mockInvoke.mockResolvedValue(undefined);
+      await addChannelMember('ch1', AgentId('a1'));
+      expect(mockInvoke).toHaveBeenCalledWith('btmsg_add_channel_member', { channelId: 'ch1', agentId: 'a1' });
+    });
+
+    it('registerAgents invokes btmsg_register_agents with groups config', async () => {
+      mockInvoke.mockResolvedValue(undefined);
+      const config = {
+        version: 1,
+        groups: [{ id: 'g1', name: 'Test', projects: [], agents: [] }],
+        activeGroupId: 'g1',
+      };
+      await registerAgents(config as any);
+      expect(mockInvoke).toHaveBeenCalledWith('btmsg_register_agents', { config });
+    });
+  });
+
+  describe('error propagation', () => {
+    it('propagates invoke errors', async () => {
+      mockInvoke.mockRejectedValue(new Error('btmsg database not found'));
+      await expect(getGroupAgents(GroupId('g1'))).rejects.toThrow('btmsg database not found');
+    });
+  });
+});
diff --git a/v2/src/lib/adapters/btmsg-bridge.ts b/v2/src/lib/adapters/btmsg-bridge.ts
new file mode 100644
index 0000000..a3e97ad
--- /dev/null
+++ b/v2/src/lib/adapters/btmsg-bridge.ts
@@ -0,0 +1,211 @@
+/**
+ * btmsg bridge — reads btmsg SQLite database for agent notifications.
+ * Used by GroupAgentsPanel to show unread counts and agent statuses.
+ * Polls the database periodically for new messages.
+ */
+
+import { invoke } from '@tauri-apps/api/core';
+import type { GroupId, AgentId } from '../types/ids';
+
+export interface BtmsgAgent {
+  id: AgentId;
+  name: string;
+  role: string;
+  groupId: GroupId;
+  tier: number;
+  model: string | null;
+  status: string;
+  unreadCount: number;
+}
+
+export interface BtmsgMessage {
+  id: string;
+  fromAgent: AgentId;
+  toAgent: AgentId;
+  content: string;
+  read: boolean;
+  replyTo: string | null;
+  createdAt: string;
+  senderName?: string;
+  senderRole?: string;
+}
+
+export interface BtmsgFeedMessage {
+  id: string;
+  fromAgent: AgentId;
+  toAgent: AgentId;
+  content: string;
+  createdAt: string;
+  replyTo: string | null;
+  senderName: string;
+  senderRole: string;
+  recipientName: string;
+  recipientRole: string;
+}
+
+export interface BtmsgChannel {
+  id: string;
+  name: string;
+  groupId: GroupId;
+  createdBy: AgentId;
+  memberCount: number;
+  createdAt: string;
+}
+
+export interface BtmsgChannelMessage {
+  id: string;
+  channelId: string;
+  fromAgent: AgentId;
+  content: string;
+  createdAt: string;
+  senderName: string;
+  senderRole: string;
+}
+
+/**
+ * Get all agents in a group with their unread counts.
+ */
+export async function getGroupAgents(groupId: GroupId): Promise<BtmsgAgent[]> {
+  return invoke('btmsg_get_agents', { groupId });
+}
+
+/**
+ * Get unread message count for an agent.
+ */
+export async function getUnreadCount(agentId: AgentId): Promise<number> {
+  return invoke('btmsg_unread_count', { agentId });
+}
+
+/**
+ * Get unread messages for an agent.
+ */
+export async function getUnreadMessages(agentId: AgentId): Promise<BtmsgMessage[]> {
+  return invoke('btmsg_unread_messages', { agentId });
+}
+
+/**
+ * Get conversation history between two agents.
+ */
+export async function getHistory(agentId: AgentId, otherId: AgentId, limit: number = 20): Promise<BtmsgMessage[]> {
+  return invoke('btmsg_history', { agentId, otherId, limit });
+}
+
+/**
+ * Send a message from one agent to another.
+ */
+export async function sendMessage(fromAgent: AgentId, toAgent: AgentId, content: string): Promise<string> {
+  return invoke('btmsg_send', { fromAgent, toAgent, content });
+}
+
+/**
+ * Update agent status (active/sleeping/stopped).
+ */
+export async function setAgentStatus(agentId: AgentId, status: string): Promise<void> {
+  return invoke('btmsg_set_status', { agentId, status });
+}
+
+/**
+ * Ensure admin agent exists with contacts to all agents.
+ */
+export async function ensureAdmin(groupId: GroupId): Promise<void> {
+  return invoke('btmsg_ensure_admin', { groupId });
+}
+
+/**
+ * Get all messages in group (admin global feed).
+ */
+export async function getAllFeed(groupId: GroupId, limit: number = 100): Promise<BtmsgFeedMessage[]> {
+  return invoke('btmsg_all_feed', { groupId, limit });
+}
+
+/**
+ * Mark all messages from sender to reader as read.
+ */
+export async function markRead(readerId: AgentId, senderId: AgentId): Promise<void> {
+  return invoke('btmsg_mark_read', { readerId, senderId });
+}
+
+/**
+ * Get channels in a group.
+ */
+export async function getChannels(groupId: GroupId): Promise<BtmsgChannel[]> {
+  return invoke('btmsg_get_channels', { groupId });
+}
+
+/**
+ * Get messages in a channel.
+ */
+export async function getChannelMessages(channelId: string, limit: number = 100): Promise<BtmsgChannelMessage[]> {
+  return invoke('btmsg_channel_messages', { channelId, limit });
+}
+
+/**
+ * Send a message to a channel.
+ */
+export async function sendChannelMessage(channelId: string, fromAgent: AgentId, content: string): Promise<string> {
+  return invoke('btmsg_channel_send', { channelId, fromAgent, content });
+}
+
+/**
+ * Create a new channel.
+ */
+export async function createChannel(name: string, groupId: GroupId, createdBy: AgentId): Promise<string> {
+  return invoke('btmsg_create_channel', { name, groupId, createdBy });
+}
+
+/**
+ * Add a member to a channel.
+ */
+export async function addChannelMember(channelId: string, agentId: AgentId): Promise<void> {
+  return invoke('btmsg_add_channel_member', { channelId, agentId });
+}
+
+/**
+ * Register all agents from groups config into the btmsg database.
+ * Creates/updates agent records, sets up contact permissions, ensures review channels.
+ * Should be called whenever groups are loaded or switched.
+ */
+export async function registerAgents(config: import('../types/groups').GroupsFile): Promise<void> {
+  return invoke('btmsg_register_agents', { config });
+}
+
+// ---- Heartbeat monitoring ----
+
+/**
+ * Record a heartbeat for an agent (upserts timestamp).
+ */
+export async function recordHeartbeat(agentId: AgentId): Promise<void> {
+  return invoke('btmsg_record_heartbeat', { agentId });
+}
+
+/**
+ * Get stale agents in a group (no heartbeat within threshold).
+ */
+export async function getStaleAgents(groupId: GroupId, thresholdSecs: number = 300): Promise<string[]> {
+  return invoke('btmsg_get_stale_agents', { groupId, thresholdSecs });
+}
+
+// ---- Dead letter queue ----
+
+export interface DeadLetter {
+  id: number;
+  fromAgent: string;
+  toAgent: string;
+  content: string;
+  error: string;
+  createdAt: string;
+}
+
+/**
+ * Get dead letter queue entries for a group.
+ */
+export async function getDeadLetters(groupId: GroupId, limit: number = 50): Promise<DeadLetter[]> {
+  return invoke('btmsg_get_dead_letters', { groupId, limit });
+}
+
+/**
+ * Clear all dead letters for a group.
+ */
+export async function clearDeadLetters(groupId: GroupId): Promise<void> {
+  return invoke('btmsg_clear_dead_letters', { groupId });
+}
diff --git a/v2/src/lib/adapters/bttask-bridge.test.ts b/v2/src/lib/adapters/bttask-bridge.test.ts
new file mode 100644
index 0000000..92ee745
--- /dev/null
+++ b/v2/src/lib/adapters/bttask-bridge.test.ts
@@ -0,0 +1,152 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+const { mockInvoke } = vi.hoisted(() => ({
+  mockInvoke: vi.fn(),
+}));
+
+vi.mock('@tauri-apps/api/core', () => ({
+  invoke: mockInvoke,
+}));
+
+import {
+  listTasks,
+  getTaskComments,
+  updateTaskStatus,
+  addTaskComment,
+  createTask,
+  deleteTask,
+  type Task,
+  type TaskComment,
+} from './bttask-bridge';
+import { GroupId, AgentId } from '../types/ids';
+
+beforeEach(() => {
+  vi.clearAllMocks();
+});
+
+describe('bttask-bridge', () => {
+  // ---- REGRESSION: camelCase field names ----
+
+  describe('Task camelCase fields', () => {
+    it('receives camelCase fields from Rust backend', async () => {
+      const task: Task = {
+        id: 't1',
+        title: 'Fix bug',
+        description: 'Critical fix',
+        status: 'progress',
+        priority: 'high',
+        assignedTo: AgentId('a1'),        // was: assigned_to
+        createdBy: AgentId('admin'),      // was: created_by
+        groupId: GroupId('g1'),           // was: group_id
+        parentTaskId: null,      // was: parent_task_id
+        sortOrder: 1,            // was: sort_order
+        createdAt: '2026-01-01', // was: created_at
+        updatedAt: '2026-01-01', // was: updated_at
+      };
+      mockInvoke.mockResolvedValue([task]);
+
+      const result = await listTasks(GroupId('g1'));
+
+      expect(result).toHaveLength(1);
+      expect(result[0].assignedTo).toBe('a1');
+      expect(result[0].createdBy).toBe('admin');
+      expect(result[0].groupId).toBe('g1');
+      expect(result[0].parentTaskId).toBeNull();
+      expect(result[0].sortOrder).toBe(1);
+      // Verify no snake_case leaks
+      expect((result[0] as Record<string, unknown>)['assigned_to']).toBeUndefined();
+      expect((result[0] as Record<string, unknown>)['created_by']).toBeUndefined();
+      expect((result[0] as Record<string, unknown>)['group_id']).toBeUndefined();
+    });
+  });
+
+  describe('TaskComment camelCase fields', () => {
+    it('receives camelCase fields from Rust backend', async () => {
+      const comment: TaskComment = {
+        id: 'c1',
+        taskId: 't1',           // was: task_id
+        agentId: AgentId('a1'),          // was: agent_id
+        content: 'Working on it',
+        createdAt: '2026-01-01',
+      };
+      mockInvoke.mockResolvedValue([comment]);
+
+      const result = await getTaskComments('t1');
+
+      expect(result[0].taskId).toBe('t1');
+      expect(result[0].agentId).toBe('a1');
+      expect((result[0] as Record<string, unknown>)['task_id']).toBeUndefined();
+      expect((result[0] as Record<string, unknown>)['agent_id']).toBeUndefined();
+    });
+  });
+
+  // ---- IPC command name tests ----
+
+  describe('IPC commands', () => {
+    it('listTasks invokes bttask_list', async () => {
+      mockInvoke.mockResolvedValue([]);
+      await listTasks(GroupId('g1'));
+      expect(mockInvoke).toHaveBeenCalledWith('bttask_list', { groupId: 'g1' });
+    });
+
+    it('getTaskComments invokes bttask_comments', async () => {
+      mockInvoke.mockResolvedValue([]);
+      await getTaskComments('t1');
+      expect(mockInvoke).toHaveBeenCalledWith('bttask_comments', { taskId: 't1' });
+    });
+
+    it('updateTaskStatus invokes bttask_update_status with version', async () => {
+      mockInvoke.mockResolvedValue(2);
+      const newVersion = await updateTaskStatus('t1', 'done', 1);
+      expect(newVersion).toBe(2);
+      expect(mockInvoke).toHaveBeenCalledWith('bttask_update_status', { taskId: 't1', status: 'done', version: 1 });
+    });
+
+    it('addTaskComment invokes bttask_add_comment', async () => {
+      mockInvoke.mockResolvedValue('c-id');
+      const result = await addTaskComment('t1', AgentId('a1'), 'Done!');
+      expect(result).toBe('c-id');
+      expect(mockInvoke).toHaveBeenCalledWith('bttask_add_comment', { taskId: 't1', agentId: 'a1', content: 'Done!' });
+    });
+
+    it('createTask invokes bttask_create with all fields', async () => {
+      mockInvoke.mockResolvedValue('t-id');
+      const result = await createTask('Fix bug', 'desc', 'high', GroupId('g1'), AgentId('admin'), AgentId('a1'));
+      expect(result).toBe('t-id');
+      expect(mockInvoke).toHaveBeenCalledWith('bttask_create', {
+        title: 'Fix bug',
+        description: 'desc',
+        priority: 'high',
+        groupId: 'g1',
+        createdBy: 'admin',
+        assignedTo: 'a1',
+      });
+    });
+
+    it('createTask invokes bttask_create without assignedTo', async () => {
+      mockInvoke.mockResolvedValue('t-id');
+      await createTask('Add tests', '', 'medium', GroupId('g1'), AgentId('a1'));
+      expect(mockInvoke).toHaveBeenCalledWith('bttask_create', {
+        title: 'Add tests',
+        description: '',
+        priority: 'medium',
+        groupId: 'g1',
+        createdBy: 'a1',
+        assignedTo: undefined,
+      });
+    });
+
+    it('deleteTask invokes bttask_delete', async () => {
+      mockInvoke.mockResolvedValue(undefined);
+      await deleteTask('t1');
+      expect(mockInvoke).toHaveBeenCalledWith('bttask_delete', { taskId: 't1' });
+    });
+  });
+
+  describe('error propagation', () => {
+    it('propagates invoke errors', async () => {
+      mockInvoke.mockRejectedValue(new Error('btmsg database not found'));
+      await expect(listTasks(GroupId('g1'))).rejects.toThrow('btmsg database not found');
+    });
+  });
+});
diff --git a/v2/src/lib/adapters/bttask-bridge.ts b/v2/src/lib/adapters/bttask-bridge.ts
new file mode 100644
index 0000000..adfecea
--- /dev/null
+++ b/v2/src/lib/adapters/bttask-bridge.ts
@@ -0,0 +1,65 @@
+// bttask Bridge — Tauri IPC adapter for task board
+
+import { invoke } from '@tauri-apps/api/core';
+import type { GroupId, AgentId } from '../types/ids';
+
+export interface Task {
+  id: string;
+  title: string;
+  description: string;
+  status: 'todo' | 'progress' | 'review' | 'done' | 'blocked';
+  priority: 'low' | 'medium' | 'high' | 'critical';
+  assignedTo: AgentId | null;
+  createdBy: AgentId;
+  groupId: GroupId;
+  parentTaskId: string | null;
+  sortOrder: number;
+  createdAt: string;
+  updatedAt: string;
+  version: number;
+}
+
+export interface TaskComment {
+  id: string;
+  taskId: string;
+  agentId: AgentId;
+  content: string;
+  createdAt: string;
+}
+
+export async function listTasks(groupId: GroupId): Promise<Task[]> {
+  return invoke<Task[]>('bttask_list', { groupId });
+}
+
+export async function getTaskComments(taskId: string): Promise<TaskComment[]> {
+  return invoke<TaskComment[]>('bttask_comments', { taskId });
+}
+
+/** Update task status with optimistic locking. Returns the new version number. */
+export async function updateTaskStatus(taskId: string, status: string, version: number): Promise<number> {
+  return invoke<number>('bttask_update_status', { taskId, status, version });
+}
+
+export async function addTaskComment(taskId: string, agentId: AgentId, content: string): Promise<string> {
+  return invoke<string>('bttask_add_comment', { taskId, agentId, content });
+}
+
+export async function createTask(
+  title: string,
+  description: string,
+  priority: string,
+  groupId: GroupId,
+  createdBy: AgentId,
+  assignedTo?: AgentId,
+): Promise<string> {
+  return invoke<string>('bttask_create', { title, description, priority, groupId, createdBy, assignedTo });
+}
+
+export async function deleteTask(taskId: string): Promise<void> {
+  return invoke('bttask_delete', { taskId });
+}
+
+/** Count tasks currently in 'review' status for a group */
+export async function reviewQueueCount(groupId: GroupId): Promise<number> {
+  return invoke<number>('bttask_review_queue_count', { groupId });
+}
diff --git a/v2/src/lib/adapters/claude-bridge.ts b/v2/src/lib/adapters/claude-bridge.ts
new file mode 100644
index 0000000..a03c318
--- /dev/null
+++ b/v2/src/lib/adapters/claude-bridge.ts
@@ -0,0 +1,28 @@
+// Claude Bridge — Tauri IPC adapter for Claude profiles and skills
+import { invoke } from '@tauri-apps/api/core';
+
+export interface ClaudeProfile {
+  name: string;
+  email: string | null;
+  subscription_type: string | null;
+  display_name: string | null;
+  config_dir: string;
+}
+
+export interface ClaudeSkill {
+  name: string;
+  description: string;
+  source_path: string;
+}
+
+export async function listProfiles(): Promise<ClaudeProfile[]> {
+  return invoke<ClaudeProfile[]>('claude_list_profiles');
+}
+
+export async function listSkills(): Promise<ClaudeSkill[]> {
+  return invoke<ClaudeSkill[]>('claude_list_skills');
+}
+
+export async function readSkill(path: string): Promise<string> {
+  return invoke<string>('claude_read_skill', { path });
+}
diff --git a/v2/src/lib/adapters/claude-messages.test.ts b/v2/src/lib/adapters/claude-messages.test.ts
new file mode 100644
index 0000000..752f0ad
--- /dev/null
+++ b/v2/src/lib/adapters/claude-messages.test.ts
@@ -0,0 +1,446 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { adaptSDKMessage } from './claude-messages';
+import type { InitContent, TextContent, ThinkingContent, ToolCallContent, ToolResultContent, StatusContent, CostContent } from './claude-messages';
+
+// Mock crypto.randomUUID for deterministic IDs when uuid is missing
+beforeEach(() => {
+  vi.stubGlobal('crypto', {
+    randomUUID: () => 'fallback-uuid',
+  });
+});
+
+describe('adaptSDKMessage', () => {
+  describe('system/init messages', () => {
+    it('adapts a system init message', () => {
+      const raw = {
+        type: 'system',
+        subtype: 'init',
+        uuid: 'sys-001',
+        session_id: 'sess-abc',
+        model: 'claude-sonnet-4-20250514',
+        cwd: '/home/user/project',
+        tools: ['Read', 'Write', 'Bash'],
+      };
+
+      const result = adaptSDKMessage(raw);
+
+      expect(result).toHaveLength(1);
+      expect(result[0].id).toBe('sys-001');
+      expect(result[0].type).toBe('init');
+      const content = result[0].content as InitContent;
+      expect(content.sessionId).toBe('sess-abc');
+      expect(content.model).toBe('claude-sonnet-4-20250514');
+      expect(content.cwd).toBe('/home/user/project');
+      expect(content.tools).toEqual(['Read', 'Write', 'Bash']);
+    });
+
+    it('defaults tools to empty array when missing', () => {
+      const raw = {
+        type: 'system',
+        subtype: 'init',
+        uuid: 'sys-002',
+        session_id: 'sess-abc',
+        model: 'claude-sonnet-4-20250514',
+        cwd: '/tmp',
+      };
+
+      const result = adaptSDKMessage(raw);
+      const content = result[0].content as InitContent;
+      expect(content.tools).toEqual([]);
+    });
+  });
+
+  describe('system/status messages (non-init subtypes)', () => {
+    it('adapts a system status message', () => {
+      const raw = {
+        type: 'system',
+        subtype: 'api_key_check',
+        uuid: 'sys-003',
+        status: 'API key is valid',
+      };
+
+      const result = adaptSDKMessage(raw);
+
+      expect(result).toHaveLength(1);
+      expect(result[0].type).toBe('status');
+      const content = result[0].content as StatusContent;
+      expect(content.subtype).toBe('api_key_check');
+      expect(content.message).toBe('API key is valid');
+    });
+
+    it('handles missing status field', () => {
+      const raw = {
+        type: 'system',
+        subtype: 'some_event',
+        uuid: 'sys-004',
+      };
+
+      const result = adaptSDKMessage(raw);
+      const content = result[0].content as StatusContent;
+      expect(content.subtype).toBe('some_event');
+      expect(content.message).toBeUndefined();
+    });
+  });
+
+  describe('assistant/text messages', () => {
+    it('adapts a single text block', () => {
+      const raw = {
+        type: 'assistant',
+        uuid: 'asst-001',
+        message: {
+          content: [{ type: 'text', text: 'Hello, world!' }],
+        },
+      };
+
+      const result = adaptSDKMessage(raw);
+
+      expect(result).toHaveLength(1);
+      expect(result[0].type).toBe('text');
+      expect(result[0].id).toBe('asst-001-text-0');
+      const content = result[0].content as TextContent;
+      expect(content.text).toBe('Hello, world!');
+    });
+
+    it('preserves parentId on assistant messages', () => {
+      const raw = {
+        type: 'assistant',
+        uuid: 'asst-002',
+        parent_tool_use_id: 'tool-parent-123',
+        message: {
+          content: [{ type: 'text', text: 'subagent response' }],
+        },
+      };
+
+      const result = adaptSDKMessage(raw);
+      expect(result[0].parentId).toBe('tool-parent-123');
+    });
+  });
+
+  describe('assistant/thinking messages', () => {
+    it('adapts a thinking block with thinking field', () => {
+      const raw = {
+        type: 'assistant',
+        uuid: 'asst-003',
+        message: {
+          content: [{ type: 'thinking', thinking: 'Let me consider...', text: 'fallback' }],
+        },
+      };
+
+      const result = adaptSDKMessage(raw);
+
+      expect(result).toHaveLength(1);
+      expect(result[0].type).toBe('thinking');
+      expect(result[0].id).toBe('asst-003-think-0');
+      const content = result[0].content as ThinkingContent;
+      expect(content.text).toBe('Let me consider...');
+    });
+
+    it('falls back to text field when thinking is absent', () => {
+      const raw = {
+        type: 'assistant',
+        uuid: 'asst-004',
+        message: {
+          content: [{ type: 'thinking', text: 'Thinking via text field' }],
+        },
+      };
+
+      const result = adaptSDKMessage(raw);
+      const content = result[0].content as ThinkingContent;
+      expect(content.text).toBe('Thinking via text field');
+    });
+  });
+
+  describe('assistant/tool_use messages', () => {
+    it('adapts a tool_use block', () => {
+      const raw = {
+        type: 'assistant',
+        uuid: 'asst-005',
+        message: {
+          content: [{
+            type: 'tool_use',
+            id: 'toolu_abc123',
+            name: 'Read',
+            input: { file_path: '/src/main.ts' },
+          }],
+        },
+      };
+
+      const result = adaptSDKMessage(raw);
+
+      expect(result).toHaveLength(1);
+      expect(result[0].type).toBe('tool_call');
+      expect(result[0].id).toBe('asst-005-tool-0');
+      const content = result[0].content as ToolCallContent;
+      expect(content.toolUseId).toBe('toolu_abc123');
+      expect(content.name).toBe('Read');
+      expect(content.input).toEqual({ file_path: '/src/main.ts' });
+    });
+  });
+
+  describe('assistant messages with multiple content blocks', () => {
+    it('produces one AgentMessage per content block', () => {
+      const raw = {
+        type: 'assistant',
+        uuid: 'asst-multi',
+        message: {
+          content: [
+            { type: 'thinking', thinking: 'Hmm...' },
+            { type: 'text', text: 'Here is the answer.' },
+            { type: 'tool_use', id: 'toolu_xyz', name: 'Bash', input: { command: 'ls' } },
+          ],
+        },
+      };
+
+      const result = adaptSDKMessage(raw);
+
+      expect(result).toHaveLength(3);
+      expect(result[0].type).toBe('thinking');
+      expect(result[0].id).toBe('asst-multi-think-0');
+      expect(result[1].type).toBe('text');
+      expect(result[1].id).toBe('asst-multi-text-1');
+      expect(result[2].type).toBe('tool_call');
+      expect(result[2].id).toBe('asst-multi-tool-2');
+    });
+
+    it('skips unknown content block types silently', () => {
+      const raw = {
+        type: 'assistant',
+        uuid: 'asst-unk-block',
+        message: {
+          content: [
+            { type: 'text', text: 'Hello' },
+            { type: 'image', data: 'base64...' },
+          ],
+        },
+      };
+
+      const result = adaptSDKMessage(raw);
+      expect(result).toHaveLength(1);
+      expect(result[0].type).toBe('text');
+    });
+  });
+
+  describe('user/tool_result messages', () => {
+    it('adapts a tool_result block', () => {
+      const raw = {
+        type: 'user',
+        uuid: 'user-001',
+        message: {
+          content: [{
+            type: 'tool_result',
+            tool_use_id: 'toolu_abc123',
+            content: 'file contents here',
+          }],
+        },
+      };
+
+      const result = adaptSDKMessage(raw);
+
+      expect(result).toHaveLength(1);
+      expect(result[0].type).toBe('tool_result');
+      expect(result[0].id).toBe('user-001-result-0');
+      const content = result[0].content as ToolResultContent;
+      expect(content.toolUseId).toBe('toolu_abc123');
+      expect(content.output).toBe('file contents here');
+    });
+
+    it('falls back to tool_use_result when block content is missing', () => {
+      const raw = {
+        type: 'user',
+        uuid: 'user-002',
+        tool_use_result: { status: 'success', output: 'done' },
+        message: {
+          content: [{
+            type: 'tool_result',
+            tool_use_id: 'toolu_def456',
+            // no content field
+          }],
+        },
+      };
+
+      const result = adaptSDKMessage(raw);
+      const content = result[0].content as ToolResultContent;
+      expect(content.output).toEqual({ status: 'success', output: 'done' });
+    });
+
+    it('preserves parentId on user messages', () => {
+      const raw = {
+        type: 'user',
+        uuid: 'user-003',
+        parent_tool_use_id: 'parent-tool-id',
+        message: {
+          content: [{
+            type: 'tool_result',
+            tool_use_id: 'toolu_ghi',
+            content: 'ok',
+          }],
+        },
+      };
+
+      const result = adaptSDKMessage(raw);
+      expect(result[0].parentId).toBe('parent-tool-id');
+    });
+  });
+
+  describe('result/cost messages', () => {
+    it('adapts a full result message', () => {
+      const raw = {
+        type: 'result',
+        uuid: 'res-001',
+        total_cost_usd: 0.0125,
+        duration_ms: 4500,
+        usage: { input_tokens: 1000, output_tokens: 500 },
+        num_turns: 3,
+        is_error: false,
+        result: 'Task completed successfully.',
+      };
+
+      const result = adaptSDKMessage(raw);
+
+      expect(result).toHaveLength(1);
+      expect(result[0].type).toBe('cost');
+      expect(result[0].id).toBe('res-001');
+      const content = result[0].content as CostContent;
+      expect(content.totalCostUsd).toBe(0.0125);
+      expect(content.durationMs).toBe(4500);
+      expect(content.inputTokens).toBe(1000);
+      expect(content.outputTokens).toBe(500);
+      expect(content.numTurns).toBe(3);
+      expect(content.isError).toBe(false);
+      expect(content.result).toBe('Task completed successfully.');
+      expect(content.errors).toBeUndefined();
+    });
+
+    it('defaults numeric fields to 0 when missing', () => {
+      const raw = {
+        type: 'result',
+        uuid: 'res-002',
+      };
+
+      const result = adaptSDKMessage(raw);
+      const content = result[0].content as CostContent;
+      expect(content.totalCostUsd).toBe(0);
+      expect(content.durationMs).toBe(0);
+      expect(content.inputTokens).toBe(0);
+      expect(content.outputTokens).toBe(0);
+      expect(content.numTurns).toBe(0);
+      expect(content.isError).toBe(false);
+    });
+
+    it('includes errors array when present', () => {
+      const raw = {
+        type: 'result',
+        uuid: 'res-003',
+        is_error: true,
+        errors: ['Rate limit exceeded', 'Retry failed'],
+      };
+
+      const result = adaptSDKMessage(raw);
+      const content = result[0].content as CostContent;
+      expect(content.isError).toBe(true);
+      expect(content.errors).toEqual(['Rate limit exceeded', 'Retry failed']);
+    });
+  });
+
+  describe('edge cases', () => {
+    it('returns unknown type for unrecognized message types', () => {
+      const raw = {
+        type: 'something_new',
+        uuid: 'unk-001',
+        data: 'arbitrary',
+      };
+
+      const result = adaptSDKMessage(raw);
+
+      expect(result).toHaveLength(1);
+      expect(result[0].type).toBe('unknown');
+      expect(result[0].id).toBe('unk-001');
+      expect(result[0].content).toBe(raw);
+    });
+
+    it('uses crypto.randomUUID when uuid is missing', () => {
+      const raw = {
+        type: 'result',
+        total_cost_usd: 0.001,
+      };
+
+      const result = adaptSDKMessage(raw);
+      expect(result[0].id).toBe('fallback-uuid');
+    });
+
+    it('returns empty array when assistant message has no message field', () => {
+      const raw = {
+        type: 'assistant',
+        uuid: 'asst-empty',
+      };
+
+      const result = adaptSDKMessage(raw);
+      expect(result).toHaveLength(0);
+    });
+
+    it('returns empty array when assistant message.content is not an array', () => {
+      const raw = {
+        type: 'assistant',
+        uuid: 'asst-bad-content',
+        message: { content: 'not-an-array' },
+      };
+
+      const result = adaptSDKMessage(raw);
+      expect(result).toHaveLength(0);
+    });
+
+    it('returns empty array when user message has no message field', () => {
+      const raw = {
+        type: 'user',
+        uuid: 'user-empty',
+      };
+
+      const result = adaptSDKMessage(raw);
+      expect(result).toHaveLength(0);
+    });
+
+    it('returns empty array when user message.content is not an array', () => {
+      const raw = {
+        type: 'user',
+        uuid: 'user-bad',
+        message: { content: 'string' },
+      };
+
+      const result = adaptSDKMessage(raw);
+      expect(result).toHaveLength(0);
+    });
+
+    it('ignores non-tool_result blocks in user messages', () => {
+      const raw = {
+        type: 'user',
+        uuid: 'user-text',
+        message: {
+          content: [
+            { type: 'text', text: 'User typed something' },
+            { type: 'tool_result', tool_use_id: 'toolu_1', content: 'ok' },
+          ],
+        },
+      };
+
+      const result = adaptSDKMessage(raw);
+      expect(result).toHaveLength(1);
+      expect(result[0].type).toBe('tool_result');
+    });
+
+    it('sets timestamp on every message', () => {
+      const before = Date.now();
+      const result = adaptSDKMessage({
+        type: 'system',
+        subtype: 'init',
+        uuid: 'ts-test',
+        session_id: 's',
+        model: 'm',
+        cwd: '/',
+      });
+      const after = Date.now();
+
+      expect(result[0].timestamp).toBeGreaterThanOrEqual(before);
+      expect(result[0].timestamp).toBeLessThanOrEqual(after);
+    });
+  });
+});
diff --git a/v2/src/lib/adapters/claude-messages.ts b/v2/src/lib/adapters/claude-messages.ts
new file mode 100644
index 0000000..2d75d07
--- /dev/null
+++ b/v2/src/lib/adapters/claude-messages.ts
@@ -0,0 +1,257 @@
+// Claude Message Adapter — transforms Claude Agent SDK wire format to internal AgentMessage format
+// This is the ONLY place that knows Claude SDK internals.
+
+export type AgentMessageType =
+  | 'init'
+  | 'text'
+  | 'thinking'
+  | 'tool_call'
+  | 'tool_result'
+  | 'status'
+  | 'compaction'
+  | 'cost'
+  | 'error'
+  | 'unknown';
+
+export interface AgentMessage {
+  id: string;
+  type: AgentMessageType;
+  parentId?: string;
+  content: unknown;
+  timestamp: number;
+}
+
+export interface InitContent {
+  sessionId: string;
+  model: string;
+  cwd: string;
+  tools: string[];
+}
+
+export interface TextContent {
+  text: string;
+}
+
+export interface ThinkingContent {
+  text: string;
+}
+
+export interface ToolCallContent {
+  toolUseId: string;
+  name: string;
+  input: unknown;
+}
+
+export interface ToolResultContent {
+  toolUseId: string;
+  output: unknown;
+}
+
+export interface StatusContent {
+  subtype: string;
+  message?: string;
+}
+
+export interface CostContent {
+  totalCostUsd: number;
+  durationMs: number;
+  inputTokens: number;
+  outputTokens: number;
+  numTurns: number;
+  isError: boolean;
+  result?: string;
+  errors?: string[];
+}
+
+export interface CompactionContent {
+  trigger: 'manual' | 'auto';
+  preTokens: number;
+}
+
+export interface ErrorContent {
+  message: string;
+}
+
+import { str, num } from '../utils/type-guards';
+
+/**
+ * Adapt a raw SDK stream-json message to our internal format.
+ * When SDK changes wire format, only this function needs updating.
+ */
+export function adaptSDKMessage(raw: Record<string, unknown>): AgentMessage[] {
+  const uuid = str(raw.uuid) || crypto.randomUUID();
+  const timestamp = Date.now();
+  const parentId = typeof raw.parent_tool_use_id === 'string' ? raw.parent_tool_use_id : undefined;
+
+  switch (raw.type) {
+    case 'system':
+      return adaptSystemMessage(raw, uuid, timestamp);
+    case 'assistant':
+      return adaptAssistantMessage(raw, uuid, timestamp, parentId);
+    case 'user':
+      return adaptUserMessage(raw, uuid, timestamp, parentId);
+    case 'result':
+      return adaptResultMessage(raw, uuid, timestamp);
+    default:
+      return [{
+        id: uuid,
+        type: 'unknown',
+        content: raw,
+        timestamp,
+      }];
+  }
+}
+
+function adaptSystemMessage(
+  raw: Record<string, unknown>,
+  uuid: string,
+  timestamp: number,
+): AgentMessage[] {
+  const subtype = str(raw.subtype);
+
+  if (subtype === 'init') {
+    return [{
+      id: uuid,
+      type: 'init',
+      content: {
+        sessionId: str(raw.session_id),
+        model: str(raw.model),
+        cwd: str(raw.cwd),
+        tools: Array.isArray(raw.tools) ? raw.tools.filter((t): t is string => typeof t === 'string') : [],
+      } satisfies InitContent,
+      timestamp,
+    }];
+  }
+
+  if (subtype === 'compact_boundary') {
+    const meta = typeof raw.compact_metadata === 'object' && raw.compact_metadata !== null
+      ? raw.compact_metadata as Record<string, unknown>
+      : {};
+    return [{
+      id: uuid,
+      type: 'compaction',
+      content: {
+        trigger: str(meta.trigger, 'auto') as 'manual' | 'auto',
+        preTokens: num(meta.pre_tokens),
+      } satisfies CompactionContent,
+      timestamp,
+    }];
+  }
+
+  return [{
+    id: uuid,
+    type: 'status',
+    content: {
+      subtype,
+      message: typeof raw.status === 'string' ? raw.status : undefined,
+    } satisfies StatusContent,
+    timestamp,
+  }];
+}
+
+function adaptAssistantMessage(
+  raw: Record<string, unknown>,
+  uuid: string,
+  timestamp: number,
+  parentId?: string,
+): AgentMessage[] {
+  const messages: AgentMessage[] = [];
+  const msg = typeof raw.message === 'object' && raw.message !== null ? raw.message as Record<string, unknown> : undefined;
+  if (!msg) return messages;
+
+  const content = Array.isArray(msg.content) ? msg.content as Array<Record<string, unknown>> : undefined;
+  if (!content) return messages;
+
+  for (const block of content) {
+    switch (block.type) {
+      case 'text':
+        messages.push({
+          id: `${uuid}-text-${messages.length}`,
+          type: 'text',
+          parentId,
+          content: { text: str(block.text) } satisfies TextContent,
+          timestamp,
+        });
+        break;
+      case 'thinking':
+        messages.push({
+          id: `${uuid}-think-${messages.length}`,
+          type: 'thinking',
+          parentId,
+          content: { text: str(block.thinking ?? block.text) } satisfies ThinkingContent,
+          timestamp,
+        });
+        break;
+      case 'tool_use':
+        messages.push({
+          id: `${uuid}-tool-${messages.length}`,
+          type: 'tool_call',
+          parentId,
+          content: {
+            toolUseId: str(block.id),
+            name: str(block.name),
+            input: block.input,
+          } satisfies ToolCallContent,
+          timestamp,
+        });
+        break;
+    }
+  }
+
+  return messages;
+}
+
+function adaptUserMessage(
+  raw: Record<string, unknown>,
+  uuid: string,
+  timestamp: number,
+  parentId?: string,
+): AgentMessage[] {
+  const messages: AgentMessage[] = [];
+  const msg = typeof raw.message === 'object' && raw.message !== null ? raw.message as Record<string, unknown> : undefined;
+  if (!msg) return messages;
+
+  const content = Array.isArray(msg.content) ? msg.content as Array<Record<string, unknown>> : undefined;
+  if (!content) return messages;
+
+  for (const block of content) {
+    if (block.type === 'tool_result') {
+      messages.push({
+        id: `${uuid}-result-${messages.length}`,
+        type: 'tool_result',
+        parentId,
+        content: {
+          toolUseId: str(block.tool_use_id),
+          output: block.content ?? raw.tool_use_result,
+        } satisfies ToolResultContent,
+        timestamp,
+      });
+    }
+  }
+
+  return messages;
+}
+
+function adaptResultMessage(
+  raw: Record<string, unknown>,
+  uuid: string,
+  timestamp: number,
+): AgentMessage[] {
+  const usage = typeof raw.usage === 'object' && raw.usage !== null ? raw.usage as Record<string, unknown> : undefined;
+
+  return [{
+    id: uuid,
+    type: 'cost',
+    content: {
+      totalCostUsd: num(raw.total_cost_usd),
+      durationMs: num(raw.duration_ms),
+      inputTokens: num(usage?.input_tokens),
+      outputTokens: num(usage?.output_tokens),
+      numTurns: num(raw.num_turns),
+      isError: raw.is_error === true,
+      result: typeof raw.result === 'string' ? raw.result : undefined,
+      errors: Array.isArray(raw.errors) ? raw.errors.filter((e): e is string => typeof e === 'string') : undefined,
+    } satisfies CostContent,
+    timestamp,
+  }];
+}
diff --git a/v2/src/lib/adapters/codex-messages.test.ts b/v2/src/lib/adapters/codex-messages.test.ts
new file mode 100644
index 0000000..e3ac559
--- /dev/null
+++ b/v2/src/lib/adapters/codex-messages.test.ts
@@ -0,0 +1,249 @@
+import { describe, it, expect } from 'vitest';
+import { adaptCodexMessage } from './codex-messages';
+
+describe('adaptCodexMessage', () => {
+  describe('thread.started', () => {
+    it('maps to init message with thread_id as sessionId', () => {
+      const result = adaptCodexMessage({
+        type: 'thread.started',
+        thread_id: 'thread-abc-123',
+      });
+      expect(result).toHaveLength(1);
+      expect(result[0].type).toBe('init');
+      expect((result[0].content as any).sessionId).toBe('thread-abc-123');
+    });
+  });
+
+  describe('turn.started', () => {
+    it('maps to status message', () => {
+      const result = adaptCodexMessage({ type: 'turn.started' });
+      expect(result).toHaveLength(1);
+      expect(result[0].type).toBe('status');
+      expect((result[0].content as any).subtype).toBe('turn_started');
+    });
+  });
+
+  describe('turn.completed', () => {
+    it('maps to cost message with token usage', () => {
+      const result = adaptCodexMessage({
+        type: 'turn.completed',
+        usage: { input_tokens: 1000, output_tokens: 200, cached_input_tokens: 800 },
+      });
+      expect(result).toHaveLength(1);
+      expect(result[0].type).toBe('cost');
+      const content = result[0].content as any;
+      expect(content.inputTokens).toBe(1000);
+      expect(content.outputTokens).toBe(200);
+      expect(content.totalCostUsd).toBe(0);
+    });
+  });
+
+  describe('turn.failed', () => {
+    it('maps to error message', () => {
+      const result = adaptCodexMessage({
+        type: 'turn.failed',
+        error: { message: 'Rate limit exceeded' },
+      });
+      expect(result).toHaveLength(1);
+      expect(result[0].type).toBe('error');
+      expect((result[0].content as any).message).toBe('Rate limit exceeded');
+    });
+  });
+
+  describe('item.completed — agent_message', () => {
+    it('maps to text message', () => {
+      const result = adaptCodexMessage({
+        type: 'item.completed',
+        item: { id: 'item_3', type: 'agent_message', text: 'Done. I updated foo.ts.' },
+      });
+      expect(result).toHaveLength(1);
+      expect(result[0].type).toBe('text');
+      expect((result[0].content as any).text).toBe('Done. I updated foo.ts.');
+    });
+
+    it('ignores item.started for agent_message', () => {
+      const result = adaptCodexMessage({
+        type: 'item.started',
+        item: { type: 'agent_message', text: '' },
+      });
+      expect(result).toHaveLength(0);
+    });
+  });
+
+  describe('item.completed — reasoning', () => {
+    it('maps to thinking message', () => {
+      const result = adaptCodexMessage({
+        type: 'item.completed',
+        item: { type: 'reasoning', text: 'Let me think about this...' },
+      });
+      expect(result).toHaveLength(1);
+      expect(result[0].type).toBe('thinking');
+      expect((result[0].content as any).text).toBe('Let me think about this...');
+    });
+  });
+
+  describe('item — command_execution', () => {
+    it('maps item.started to tool_call', () => {
+      const result = adaptCodexMessage({
+        type: 'item.started',
+        item: { id: 'item_1', type: 'command_execution', command: 'ls -la', status: 'in_progress' },
+      });
+      expect(result).toHaveLength(1);
+      expect(result[0].type).toBe('tool_call');
+      expect((result[0].content as any).name).toBe('Bash');
+      expect((result[0].content as any).input.command).toBe('ls -la');
+    });
+
+    it('maps item.completed to tool_call + tool_result pair', () => {
+      const result = adaptCodexMessage({
+        type: 'item.completed',
+        item: {
+          id: 'item_1',
+          type: 'command_execution',
+          command: 'ls -la',
+          aggregated_output: 'total 48\ndrwxr-xr-x',
+          exit_code: 0,
+          status: 'completed',
+        },
+      });
+      expect(result).toHaveLength(2);
+      expect(result[0].type).toBe('tool_call');
+      expect(result[1].type).toBe('tool_result');
+      expect((result[1].content as any).output).toBe('total 48\ndrwxr-xr-x');
+    });
+
+    it('ignores item.updated for command_execution', () => {
+      const result = adaptCodexMessage({
+        type: 'item.updated',
+        item: { type: 'command_execution', command: 'ls', status: 'in_progress' },
+      });
+      expect(result).toHaveLength(0);
+    });
+  });
+
+  describe('item.completed — file_change', () => {
+    it('maps file changes to tool_call + tool_result pairs', () => {
+      const result = adaptCodexMessage({
+        type: 'item.completed',
+        item: {
+          type: 'file_change',
+          changes: [
+            { path: 'src/foo.ts', kind: 'update' },
+            { path: 'src/bar.ts', kind: 'add' },
+          ],
+          status: 'completed',
+        },
+      });
+      expect(result).toHaveLength(4);
+      expect(result[0].type).toBe('tool_call');
+      expect((result[0].content as any).name).toBe('Edit');
+      expect(result[1].type).toBe('tool_result');
+      expect(result[2].type).toBe('tool_call');
+      expect((result[2].content as any).name).toBe('Write');
+    });
+
+    it('maps delete to Bash tool name', () => {
+      const result = adaptCodexMessage({
+        type: 'item.completed',
+        item: {
+          type: 'file_change',
+          changes: [{ path: 'old.ts', kind: 'delete' }],
+          status: 'completed',
+        },
+      });
+      expect(result).toHaveLength(2);
+      expect((result[0].content as any).name).toBe('Bash');
+    });
+
+    it('returns empty for no changes', () => {
+      const result = adaptCodexMessage({
+        type: 'item.completed',
+        item: { type: 'file_change', changes: [], status: 'completed' },
+      });
+      expect(result).toHaveLength(0);
+    });
+  });
+
+  describe('item.completed — mcp_tool_call', () => {
+    it('maps to tool_call + tool_result with server:tool name', () => {
+      const result = adaptCodexMessage({
+        type: 'item.completed',
+        item: {
+          id: 'mcp_1',
+          type: 'mcp_tool_call',
+          server: 'filesystem',
+          tool: 'read_file',
+          arguments: { path: '/tmp/test.txt' },
+          result: { content: 'file contents' },
+          status: 'completed',
+        },
+      });
+      expect(result).toHaveLength(2);
+      expect((result[0].content as any).name).toBe('filesystem:read_file');
+      expect((result[0].content as any).input.path).toBe('/tmp/test.txt');
+    });
+
+    it('maps error result to error message in tool_result', () => {
+      const result = adaptCodexMessage({
+        type: 'item.completed',
+        item: {
+          id: 'mcp_2',
+          type: 'mcp_tool_call',
+          server: 'fs',
+          tool: 'write',
+          arguments: {},
+          error: { message: 'Permission denied' },
+          status: 'completed',
+        },
+      });
+      expect(result).toHaveLength(2);
+      expect((result[1].content as any).output).toBe('Permission denied');
+    });
+  });
+
+  describe('item.completed — web_search', () => {
+    it('maps to WebSearch tool_call', () => {
+      const result = adaptCodexMessage({
+        type: 'item.completed',
+        item: { id: 'ws_1', type: 'web_search', query: 'ollama api docs' },
+      });
+      expect(result).toHaveLength(1);
+      expect(result[0].type).toBe('tool_call');
+      expect((result[0].content as any).name).toBe('WebSearch');
+      expect((result[0].content as any).input.query).toBe('ollama api docs');
+    });
+  });
+
+  describe('item — error', () => {
+    it('maps to error message', () => {
+      const result = adaptCodexMessage({
+        type: 'item.completed',
+        item: { type: 'error', message: 'Sandbox violation' },
+      });
+      expect(result).toHaveLength(1);
+      expect(result[0].type).toBe('error');
+      expect((result[0].content as any).message).toBe('Sandbox violation');
+    });
+  });
+
+  describe('top-level error', () => {
+    it('maps to error message', () => {
+      const result = adaptCodexMessage({
+        type: 'error',
+        message: 'Connection lost',
+      });
+      expect(result).toHaveLength(1);
+      expect(result[0].type).toBe('error');
+      expect((result[0].content as any).message).toBe('Connection lost');
+    });
+  });
+
+  describe('unknown event type', () => {
+    it('maps to unknown message preserving raw data', () => {
+      const result = adaptCodexMessage({ type: 'custom.event', data: 42 });
+      expect(result).toHaveLength(1);
+      expect(result[0].type).toBe('unknown');
+      expect((result[0].content as any).data).toBe(42);
+    });
+  });
+});
diff --git a/v2/src/lib/adapters/codex-messages.ts b/v2/src/lib/adapters/codex-messages.ts
new file mode 100644
index 0000000..9290335
--- /dev/null
+++ b/v2/src/lib/adapters/codex-messages.ts
@@ -0,0 +1,291 @@
+// Codex Message Adapter — transforms Codex CLI NDJSON events to internal AgentMessage format
+// Codex events: thread.started, turn.started, item.started/updated/completed, turn.completed/failed
+
+import type {
+  AgentMessage,
+  InitContent,
+  TextContent,
+  ThinkingContent,
+  ToolCallContent,
+  ToolResultContent,
+  StatusContent,
+  CostContent,
+  ErrorContent,
+} from './claude-messages';
+
+import { str, num } from '../utils/type-guards';
+
+export function adaptCodexMessage(raw: Record<string, unknown>): AgentMessage[] {
+  const timestamp = Date.now();
+  const uuid = crypto.randomUUID();
+
+  switch (raw.type) {
+    case 'thread.started':
+      return [{
+        id: uuid,
+        type: 'init',
+        content: {
+          sessionId: str(raw.thread_id),
+          model: '',
+          cwd: '',
+          tools: [],
+        } satisfies InitContent,
+        timestamp,
+      }];
+
+    case 'turn.started':
+      return [{
+        id: uuid,
+        type: 'status',
+        content: { subtype: 'turn_started' } satisfies StatusContent,
+        timestamp,
+      }];
+
+    case 'turn.completed':
+      return adaptTurnCompleted(raw, uuid, timestamp);
+
+    case 'turn.failed':
+      return [{
+        id: uuid,
+        type: 'error',
+        content: {
+          message: str((raw.error as Record<string, unknown>)?.message, 'Turn failed'),
+        } satisfies ErrorContent,
+        timestamp,
+      }];
+
+    case 'item.started':
+    case 'item.updated':
+    case 'item.completed':
+      return adaptItem(raw, uuid, timestamp);
+
+    case 'error':
+      return [{
+        id: uuid,
+        type: 'error',
+        content: { message: str(raw.message, 'Unknown error') } satisfies ErrorContent,
+        timestamp,
+      }];
+
+    default:
+      return [{
+        id: uuid,
+        type: 'unknown',
+        content: raw,
+        timestamp,
+      }];
+  }
+}
+
+function adaptTurnCompleted(
+  raw: Record<string, unknown>,
+  uuid: string,
+  timestamp: number,
+): AgentMessage[] {
+  const usage = typeof raw.usage === 'object' && raw.usage !== null
+    ? raw.usage as Record<string, unknown>
+    : {};
+
+  return [{
+    id: uuid,
+    type: 'cost',
+    content: {
+      totalCostUsd: 0,
+      durationMs: 0,
+      inputTokens: num(usage.input_tokens),
+      outputTokens: num(usage.output_tokens),
+      numTurns: 1,
+      isError: false,
+    } satisfies CostContent,
+    timestamp,
+  }];
+}
+
+function adaptItem(
+  raw: Record<string, unknown>,
+  uuid: string,
+  timestamp: number,
+): AgentMessage[] {
+  const item = typeof raw.item === 'object' && raw.item !== null
+    ? raw.item as Record<string, unknown>
+    : {};
+  const itemType = str(item.type);
+  const eventType = str(raw.type);
+
+  switch (itemType) {
+    case 'agent_message':
+      if (eventType !== 'item.completed') return [];
+      return [{
+        id: uuid,
+        type: 'text',
+        content: { text: str(item.text) } satisfies TextContent,
+        timestamp,
+      }];
+
+    case 'reasoning':
+      if (eventType !== 'item.completed') return [];
+      return [{
+        id: uuid,
+        type: 'thinking',
+        content: { text: str(item.text) } satisfies ThinkingContent,
+        timestamp,
+      }];
+
+    case 'command_execution':
+      return adaptCommandExecution(item, uuid, timestamp, eventType);
+
+    case 'file_change':
+      return adaptFileChange(item, uuid, timestamp, eventType);
+
+    case 'mcp_tool_call':
+      return adaptMcpToolCall(item, uuid, timestamp, eventType);
+
+    case 'web_search':
+      if (eventType !== 'item.completed') return [];
+      return [{
+        id: uuid,
+        type: 'tool_call',
+        content: {
+          toolUseId: str(item.id, uuid),
+          name: 'WebSearch',
+          input: { query: str(item.query) },
+        } satisfies ToolCallContent,
+        timestamp,
+      }];
+
+    case 'error':
+      return [{
+        id: uuid,
+        type: 'error',
+        content: { message: str(item.message, 'Item error') } satisfies ErrorContent,
+        timestamp,
+      }];
+
+    default:
+      return [];
+  }
+}
+
+function adaptCommandExecution(
+  item: Record<string, unknown>,
+  uuid: string,
+  timestamp: number,
+  eventType: string,
+): AgentMessage[] {
+  const messages: AgentMessage[] = [];
+  const toolUseId = str(item.id, uuid);
+
+  if (eventType === 'item.started' || eventType === 'item.completed') {
+    messages.push({
+      id: `${uuid}-call`,
+      type: 'tool_call',
+      content: {
+        toolUseId,
+        name: 'Bash',
+        input: { command: str(item.command) },
+      } satisfies ToolCallContent,
+      timestamp,
+    });
+  }
+
+  if (eventType === 'item.completed') {
+    messages.push({
+      id: `${uuid}-result`,
+      type: 'tool_result',
+      content: {
+        toolUseId,
+        output: str(item.aggregated_output),
+      } satisfies ToolResultContent,
+      timestamp,
+    });
+  }
+
+  return messages;
+}
+
+function adaptFileChange(
+  item: Record<string, unknown>,
+  uuid: string,
+  timestamp: number,
+  eventType: string,
+): AgentMessage[] {
+  if (eventType !== 'item.completed') return [];
+
+  const changes = Array.isArray(item.changes) ? item.changes as Array<Record<string, unknown>> : [];
+  if (changes.length === 0) return [];
+
+  const messages: AgentMessage[] = [];
+  for (const change of changes) {
+    const kind = str(change.kind);
+    const toolName = kind === 'delete' ? 'Bash' : kind === 'add' ? 'Write' : 'Edit';
+    const toolUseId = `${uuid}-${str(change.path)}`;
+
+    messages.push({
+      id: `${toolUseId}-call`,
+      type: 'tool_call',
+      content: {
+        toolUseId,
+        name: toolName,
+        input: { file_path: str(change.path) },
+      } satisfies ToolCallContent,
+      timestamp,
+    });
+
+    messages.push({
+      id: `${toolUseId}-result`,
+      type: 'tool_result',
+      content: {
+        toolUseId,
+        output: `File ${kind}: ${str(change.path)}`,
+      } satisfies ToolResultContent,
+      timestamp,
+    });
+  }
+
+  return messages;
+}
+
+function adaptMcpToolCall(
+  item: Record<string, unknown>,
+  uuid: string,
+  timestamp: number,
+  eventType: string,
+): AgentMessage[] {
+  const messages: AgentMessage[] = [];
+  const toolUseId = str(item.id, uuid);
+  const toolName = `${str(item.server)}:${str(item.tool)}`;
+
+  if (eventType === 'item.started' || eventType === 'item.completed') {
+    messages.push({
+      id: `${uuid}-call`,
+      type: 'tool_call',
+      content: {
+        toolUseId,
+        name: toolName,
+        input: item.arguments,
+      } satisfies ToolCallContent,
+      timestamp,
+    });
+  }
+
+  if (eventType === 'item.completed') {
+    const result = typeof item.result === 'object' && item.result !== null
+      ? item.result as Record<string, unknown>
+      : undefined;
+    const error = typeof item.error === 'object' && item.error !== null
+      ? item.error as Record<string, unknown>
+      : undefined;
+
+    messages.push({
+      id: `${uuid}-result`,
+      type: 'tool_result',
+      content: {
+        toolUseId,
+        output: error ? str(error.message, 'MCP tool error') : (result?.content ?? result?.structured_content ?? 'OK'),
+      } satisfies ToolResultContent,
+      timestamp,
+    });
+  }
+
+  return messages;
+}
diff --git a/v2/src/lib/adapters/ctx-bridge.ts b/v2/src/lib/adapters/ctx-bridge.ts
new file mode 100644
index 0000000..4956282
--- /dev/null
+++ b/v2/src/lib/adapters/ctx-bridge.ts
@@ -0,0 +1,38 @@
+import { invoke } from '@tauri-apps/api/core';
+
+export interface CtxEntry {
+  project: string;
+  key: string;
+  value: string;
+  updated_at: string;
+}
+
+export interface CtxSummary {
+  project: string;
+  summary: string;
+  created_at: string;
+}
+
+export async function ctxInitDb(): Promise<void> {
+  return invoke('ctx_init_db');
+}
+
+export async function ctxRegisterProject(name: string, description: string, workDir?: string): Promise<void> {
+  return invoke('ctx_register_project', { name, description, workDir: workDir ?? null });
+}
+
+export async function ctxGetContext(project: string): Promise<CtxEntry[]> {
+  return invoke('ctx_get_context', { project });
+}
+
+export async function ctxGetShared(): Promise<CtxEntry[]> {
+  return invoke('ctx_get_shared');
+}
+
+export async function ctxGetSummaries(project: string, limit: number = 5): Promise<CtxSummary[]> {
+  return invoke('ctx_get_summaries', { project, limit });
+}
+
+export async function ctxSearch(query: string): Promise<CtxEntry[]> {
+  return invoke('ctx_search', { query });
+}
diff --git a/v2/src/lib/adapters/file-bridge.ts b/v2/src/lib/adapters/file-bridge.ts
new file mode 100644
index 0000000..7937488
--- /dev/null
+++ b/v2/src/lib/adapters/file-bridge.ts
@@ -0,0 +1,29 @@
+import { invoke } from '@tauri-apps/api/core';
+import { listen, type UnlistenFn } from '@tauri-apps/api/event';
+
+export interface FileChangedPayload {
+  pane_id: string;
+  path: string;
+  content: string;
+}
+
+/** Start watching a file; returns initial content */
+export async function watchFile(paneId: string, path: string): Promise<string> {
+  return invoke('file_watch', { paneId, path });
+}
+
+export async function unwatchFile(paneId: string): Promise<void> {
+  return invoke('file_unwatch', { paneId });
+}
+
+export async function readFile(path: string): Promise<string> {
+  return invoke('file_read', { path });
+}
+
+export async function onFileChanged(
+  callback: (payload: FileChangedPayload) => void
+): Promise<UnlistenFn> {
+  return listen<FileChangedPayload>('file-changed', (event) => {
+    callback(event.payload);
+  });
+}
diff --git a/v2/src/lib/adapters/files-bridge.ts b/v2/src/lib/adapters/files-bridge.ts
new file mode 100644
index 0000000..a46f4f2
--- /dev/null
+++ b/v2/src/lib/adapters/files-bridge.ts
@@ -0,0 +1,26 @@
+import { invoke } from '@tauri-apps/api/core';
+
+export interface DirEntry {
+  name: string;
+  path: string;
+  is_dir: boolean;
+  size: number;
+  ext: string;
+}
+
+export type FileContent =
+  | { type: 'Text'; content: string; lang: string }
+  | { type: 'Binary'; message: string }
+  | { type: 'TooLarge'; size: number };
+
+export function listDirectoryChildren(path: string): Promise<DirEntry[]> {
+  return invoke<DirEntry[]>('list_directory_children', { path });
+}
+
+export function readFileContent(path: string): Promise<FileContent> {
+  return invoke<FileContent>('read_file_content', { path });
+}
+
+export function writeFileContent(path: string, content: string): Promise<void> {
+  return invoke<void>('write_file_content', { path, content });
+}
diff --git a/v2/src/lib/adapters/fs-watcher-bridge.ts b/v2/src/lib/adapters/fs-watcher-bridge.ts
new file mode 100644
index 0000000..17d4e6b
--- /dev/null
+++ b/v2/src/lib/adapters/fs-watcher-bridge.ts
@@ -0,0 +1,41 @@
+// Filesystem watcher bridge — listens for inotify-based write events from Rust
+// Part of S-1 Phase 2: real-time filesystem write detection
+
+import { invoke } from '@tauri-apps/api/core';
+import { listen, type UnlistenFn } from '@tauri-apps/api/event';
+
+export interface FsWriteEvent {
+  project_id: string;
+  file_path: string;
+  timestamp_ms: number;
+}
+
+/** Start watching a project's CWD for filesystem writes */
+export function fsWatchProject(projectId: string, cwd: string): Promise<void> {
+  return invoke('fs_watch_project', { projectId, cwd });
+}
+
+/** Stop watching a project's CWD */
+export function fsUnwatchProject(projectId: string): Promise<void> {
+  return invoke('fs_unwatch_project', { projectId });
+}
+
+/** Listen for filesystem write events from all watched projects */
+export function onFsWriteDetected(
+  callback: (event: FsWriteEvent) => void,
+): Promise<UnlistenFn> {
+  return listen<FsWriteEvent>('fs-write-detected', (e) => callback(e.payload));
+}
+
+export interface FsWatcherStatus {
+  max_watches: number;
+  estimated_watches: number;
+  usage_ratio: number;
+  active_projects: number;
+  warning: string | null;
+}
+
+/** Get inotify watcher status including kernel limit check */
+export function fsWatcherStatus(): Promise<FsWatcherStatus> {
+  return invoke('fs_watcher_status');
+}
diff --git a/v2/src/lib/adapters/groups-bridge.ts b/v2/src/lib/adapters/groups-bridge.ts
new file mode 100644
index 0000000..72551f9
--- /dev/null
+++ b/v2/src/lib/adapters/groups-bridge.ts
@@ -0,0 +1,111 @@
+import { invoke } from '@tauri-apps/api/core';
+import type { GroupsFile, ProjectConfig, GroupConfig } from '../types/groups';
+import type { SessionId, ProjectId } from '../types/ids';
+
+export type { GroupsFile, ProjectConfig, GroupConfig };
+
+export interface MdFileEntry {
+  name: string;
+  path: string;
+  priority: boolean;
+}
+
+export interface AgentMessageRecord {
+  id: number;
+  session_id: SessionId;
+  project_id: ProjectId;
+  sdk_session_id: string | null;
+  message_type: string;
+  content: string;
+  parent_id: string | null;
+  created_at: number;
+}
+
+export interface ProjectAgentState {
+  project_id: ProjectId;
+  last_session_id: SessionId;
+  sdk_session_id: string | null;
+  status: string;
+  cost_usd: number;
+  input_tokens: number;
+  output_tokens: number;
+  last_prompt: string | null;
+  updated_at: number;
+}
+
+// --- Group config ---
+
+export async function loadGroups(): Promise<GroupsFile> {
+  return invoke('groups_load');
+}
+
+export async function saveGroups(config: GroupsFile): Promise<void> {
+  return invoke('groups_save', { config });
+}
+
+// --- Markdown discovery ---
+
+export async function discoverMarkdownFiles(cwd: string): Promise<MdFileEntry[]> {
+  return invoke('discover_markdown_files', { cwd });
+}
+
+// --- Agent message persistence ---
+
+export async function saveAgentMessages(
+  sessionId: SessionId,
+  projectId: ProjectId,
+  sdkSessionId: string | undefined,
+  messages: AgentMessageRecord[],
+): Promise<void> {
+  return invoke('agent_messages_save', {
+    sessionId,
+    projectId,
+    sdkSessionId: sdkSessionId ?? null,
+    messages,
+  });
+}
+
+export async function loadAgentMessages(projectId: ProjectId): Promise<AgentMessageRecord[]> {
+  return invoke('agent_messages_load', { projectId });
+}
+
+// --- Project agent state ---
+
+export async function saveProjectAgentState(state: ProjectAgentState): Promise<void> {
+  return invoke('project_agent_state_save', { state });
+}
+
+export async function loadProjectAgentState(projectId: ProjectId): Promise<ProjectAgentState | null> {
+  return invoke('project_agent_state_load', { projectId });
+}
+
+// --- Session metrics ---
+
+export interface SessionMetric {
+  id: number;
+  project_id: ProjectId;
+  session_id: SessionId;
+  start_time: number;
+  end_time: number;
+  peak_tokens: number;
+  turn_count: number;
+  tool_call_count: number;
+  cost_usd: number;
+  model: string | null;
+  status: string;
+  error_message: string | null;
+}
+
+export async function saveSessionMetric(metric: Omit<SessionMetric, 'id'>): Promise<void> {
+  return invoke('session_metric_save', { metric: { id: 0, ...metric } });
+}
+
+export async function loadSessionMetrics(projectId: ProjectId, limit = 20): Promise<SessionMetric[]> {
+  return invoke('session_metrics_load', { projectId, limit });
+}
+
+// --- CLI arguments ---
+
+export async function getCliGroup(): Promise<string | null> {
+  return invoke('cli_get_group');
+}
diff --git a/v2/src/lib/adapters/memora-bridge.test.ts b/v2/src/lib/adapters/memora-bridge.test.ts
new file mode 100644
index 0000000..206bcaf
--- /dev/null
+++ b/v2/src/lib/adapters/memora-bridge.test.ts
@@ -0,0 +1,171 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+const { mockInvoke } = vi.hoisted(() => ({
+  mockInvoke: vi.fn(),
+}));
+
+vi.mock('@tauri-apps/api/core', () => ({
+  invoke: mockInvoke,
+}));
+
+import {
+  memoraAvailable,
+  memoraList,
+  memoraSearch,
+  memoraGet,
+  MemoraAdapter,
+} from './memora-bridge';
+
+beforeEach(() => {
+  vi.clearAllMocks();
+});
+
+describe('memora IPC wrappers', () => {
+  it('memoraAvailable invokes memora_available', async () => {
+    mockInvoke.mockResolvedValue(true);
+    const result = await memoraAvailable();
+    expect(result).toBe(true);
+    expect(mockInvoke).toHaveBeenCalledWith('memora_available');
+  });
+
+  it('memoraList invokes memora_list with defaults', async () => {
+    mockInvoke.mockResolvedValue({ nodes: [], total: 0 });
+    await memoraList();
+    expect(mockInvoke).toHaveBeenCalledWith('memora_list', {
+      tags: null,
+      limit: 50,
+      offset: 0,
+    });
+  });
+
+  it('memoraList passes tags and pagination', async () => {
+    mockInvoke.mockResolvedValue({ nodes: [], total: 0 });
+    await memoraList({ tags: ['bterminal'], limit: 10, offset: 5 });
+    expect(mockInvoke).toHaveBeenCalledWith('memora_list', {
+      tags: ['bterminal'],
+      limit: 10,
+      offset: 5,
+    });
+  });
+
+  it('memoraSearch invokes memora_search', async () => {
+    mockInvoke.mockResolvedValue({ nodes: [], total: 0 });
+    await memoraSearch('test query', { tags: ['foo'], limit: 20 });
+    expect(mockInvoke).toHaveBeenCalledWith('memora_search', {
+      query: 'test query',
+      tags: ['foo'],
+      limit: 20,
+    });
+  });
+
+  it('memoraSearch uses defaults when no options', async () => {
+    mockInvoke.mockResolvedValue({ nodes: [], total: 0 });
+    await memoraSearch('hello');
+    expect(mockInvoke).toHaveBeenCalledWith('memora_search', {
+      query: 'hello',
+      tags: null,
+      limit: 50,
+    });
+  });
+
+  it('memoraGet invokes memora_get', async () => {
+    const node = { id: 42, content: 'test', tags: ['a'], metadata: null, created_at: null, updated_at: null };
+    mockInvoke.mockResolvedValue(node);
+    const result = await memoraGet(42);
+    expect(result).toEqual(node);
+    expect(mockInvoke).toHaveBeenCalledWith('memora_get', { id: 42 });
+  });
+
+  it('memoraGet returns null for missing', async () => {
+    mockInvoke.mockResolvedValue(null);
+    const result = await memoraGet(999);
+    expect(result).toBeNull();
+  });
+});
+
+describe('MemoraAdapter', () => {
+  it('has name "memora"', () => {
+    const adapter = new MemoraAdapter();
+    expect(adapter.name).toBe('memora');
+  });
+
+  it('available is true by default (optimistic)', () => {
+    const adapter = new MemoraAdapter();
+    expect(adapter.available).toBe(true);
+  });
+
+  it('checkAvailability updates available state', async () => {
+    mockInvoke.mockResolvedValue(false);
+    const adapter = new MemoraAdapter();
+    const result = await adapter.checkAvailability();
+    expect(result).toBe(false);
+    expect(adapter.available).toBe(false);
+  });
+
+  it('list returns mapped MemorySearchResult', async () => {
+    mockInvoke.mockResolvedValue({
+      nodes: [
+        { id: 1, content: 'hello', tags: ['a', 'b'], metadata: { key: 'val' }, created_at: '2026-01-01', updated_at: null },
+      ],
+      total: 1,
+    });
+
+    const adapter = new MemoraAdapter();
+    const result = await adapter.list({ limit: 10 });
+    expect(result.total).toBe(1);
+    expect(result.nodes).toHaveLength(1);
+    expect(result.nodes[0].id).toBe(1);
+    expect(result.nodes[0].content).toBe('hello');
+    expect(result.nodes[0].tags).toEqual(['a', 'b']);
+    expect(result.nodes[0].metadata).toEqual({ key: 'val' });
+  });
+
+  it('search returns mapped results', async () => {
+    mockInvoke.mockResolvedValue({
+      nodes: [{ id: 5, content: 'found', tags: ['x'], metadata: null, created_at: null, updated_at: null }],
+      total: 1,
+    });
+
+    const adapter = new MemoraAdapter();
+    const result = await adapter.search('found', { limit: 5 });
+    expect(result.nodes[0].content).toBe('found');
+    expect(adapter.available).toBe(true);
+  });
+
+  it('get returns mapped node', async () => {
+    mockInvoke.mockResolvedValue({
+      id: 10, content: 'node', tags: ['t'], metadata: null, created_at: '2026-01-01', updated_at: '2026-01-02',
+    });
+
+    const adapter = new MemoraAdapter();
+    const node = await adapter.get(10);
+    expect(node).not.toBeNull();
+    expect(node!.id).toBe(10);
+    expect(node!.updated_at).toBe('2026-01-02');
+  });
+
+  it('get returns null for missing node', async () => {
+    mockInvoke.mockResolvedValue(null);
+    const adapter = new MemoraAdapter();
+    const node = await adapter.get(999);
+    expect(node).toBeNull();
+  });
+
+  it('get handles string id', async () => {
+    mockInvoke.mockResolvedValue({
+      id: 7, content: 'x', tags: [], metadata: null, created_at: null, updated_at: null,
+    });
+
+    const adapter = new MemoraAdapter();
+    const node = await adapter.get('7');
+    expect(node).not.toBeNull();
+    expect(mockInvoke).toHaveBeenCalledWith('memora_get', { id: 7 });
+  });
+
+  it('get returns null for non-numeric string id', async () => {
+    const adapter = new MemoraAdapter();
+    const node = await adapter.get('abc');
+    expect(node).toBeNull();
+    expect(mockInvoke).not.toHaveBeenCalled();
+  });
+});
diff --git a/v2/src/lib/adapters/memora-bridge.ts b/v2/src/lib/adapters/memora-bridge.ts
new file mode 100644
index 0000000..c206c73
--- /dev/null
+++ b/v2/src/lib/adapters/memora-bridge.ts
@@ -0,0 +1,122 @@
+/**
+ * Memora IPC bridge — read-only access to the Memora memory database.
+ * Wraps Tauri commands and provides a MemoryAdapter implementation.
+ */
+
+import { invoke } from '@tauri-apps/api/core';
+import type { MemoryAdapter, MemoryNode, MemorySearchResult } from './memory-adapter';
+
+// --- Raw IPC types (match Rust structs) ---
+
+interface MemoraNode {
+  id: number;
+  content: string;
+  tags: string[];
+  metadata?: Record<string, unknown>;
+  created_at?: string;
+  updated_at?: string;
+}
+
+interface MemoraSearchResult {
+  nodes: MemoraNode[];
+  total: number;
+}
+
+// --- IPC wrappers ---
+
+export async function memoraAvailable(): Promise<boolean> {
+  return invoke<boolean>('memora_available');
+}
+
+export async function memoraList(options?: {
+  tags?: string[];
+  limit?: number;
+  offset?: number;
+}): Promise<MemoraSearchResult> {
+  return invoke<MemoraSearchResult>('memora_list', {
+    tags: options?.tags ?? null,
+    limit: options?.limit ?? 50,
+    offset: options?.offset ?? 0,
+  });
+}
+
+export async function memoraSearch(
+  query: string,
+  options?: { tags?: string[]; limit?: number },
+): Promise<MemoraSearchResult> {
+  return invoke<MemoraSearchResult>('memora_search', {
+    query,
+    tags: options?.tags ?? null,
+    limit: options?.limit ?? 50,
+  });
+}
+
+export async function memoraGet(id: number): Promise<MemoraNode | null> {
+  return invoke<MemoraNode | null>('memora_get', { id });
+}
+
+// --- MemoryAdapter implementation ---
+
+function toMemoryNode(n: MemoraNode): MemoryNode {
+  return {
+    id: n.id,
+    content: n.content,
+    tags: n.tags,
+    metadata: n.metadata,
+    created_at: n.created_at,
+    updated_at: n.updated_at,
+  };
+}
+
+function toSearchResult(r: MemoraSearchResult): MemorySearchResult {
+  return {
+    nodes: r.nodes.map(toMemoryNode),
+    total: r.total,
+  };
+}
+
+export class MemoraAdapter implements MemoryAdapter {
+  readonly name = 'memora';
+  private _available: boolean | null = null;
+
+  get available(): boolean {
+    // Optimistic: assume available until first check proves otherwise.
+    // Actual availability is checked lazily on first operation.
+    return this._available ?? true;
+  }
+
+  async checkAvailability(): Promise<boolean> {
+    this._available = await memoraAvailable();
+    return this._available;
+  }
+
+  async list(options?: {
+    tags?: string[];
+    limit?: number;
+    offset?: number;
+  }): Promise<MemorySearchResult> {
+    const result = await memoraList(options);
+    this._available = true;
+    return toSearchResult(result);
+  }
+
+  async search(
+    query: string,
+    options?: { tags?: string[]; limit?: number },
+  ): Promise<MemorySearchResult> {
+    const result = await memoraSearch(query, options);
+    this._available = true;
+    return toSearchResult(result);
+  }
+
+  async get(id: string | number): Promise<MemoryNode | null> {
+    const numId = typeof id === 'string' ? parseInt(id, 10) : id;
+    if (isNaN(numId)) return null;
+    const node = await memoraGet(numId);
+    if (node) {
+      this._available = true;
+      return toMemoryNode(node);
+    }
+    return null;
+  }
+}
diff --git a/v2/src/lib/adapters/memory-adapter.ts b/v2/src/lib/adapters/memory-adapter.ts
new file mode 100644
index 0000000..69d0e14
--- /dev/null
+++ b/v2/src/lib/adapters/memory-adapter.ts
@@ -0,0 +1,52 @@
+/**
+ * Pluggable memory adapter interface.
+ * Memora is the default implementation, but others can be swapped in.
+ */
+
+export interface MemoryNode {
+  id: string | number;
+  content: string;
+  tags: string[];
+  metadata?: Record<string, unknown>;
+  created_at?: string;
+  updated_at?: string;
+}
+
+export interface MemorySearchResult {
+  nodes: MemoryNode[];
+  total: number;
+}
+
+export interface MemoryAdapter {
+  readonly name: string;
+  readonly available: boolean;
+
+  /** List memories, optionally filtered by tags */
+  list(options?: { tags?: string[]; limit?: number; offset?: number }): Promise<MemorySearchResult>;
+
+  /** Semantic search across memories */
+  search(query: string, options?: { tags?: string[]; limit?: number }): Promise<MemorySearchResult>;
+
+  /** Get a single memory by ID */
+  get(id: string | number): Promise<MemoryNode | null>;
+}
+
+/** Registry of available memory adapters */
+const adapters = new Map<string, MemoryAdapter>();
+
+export function registerMemoryAdapter(adapter: MemoryAdapter): void {
+  adapters.set(adapter.name, adapter);
+}
+
+export function getMemoryAdapter(name: string): MemoryAdapter | undefined {
+  return adapters.get(name);
+}
+
+export function getAvailableAdapters(): MemoryAdapter[] {
+  return Array.from(adapters.values()).filter(a => a.available);
+}
+
+export function getDefaultAdapter(): MemoryAdapter | undefined {
+  // Prefer Memora if available, otherwise first available
+  return adapters.get('memora') ?? getAvailableAdapters()[0];
+}
diff --git a/v2/src/lib/adapters/message-adapters.ts b/v2/src/lib/adapters/message-adapters.ts
new file mode 100644
index 0000000..b816b91
--- /dev/null
+++ b/v2/src/lib/adapters/message-adapters.ts
@@ -0,0 +1,33 @@
+// Message Adapter Registry — routes raw provider messages to the correct parser
+// Each provider registers its own adapter; the dispatcher calls adaptMessage()
+
+import type { AgentMessage } from './claude-messages';
+import type { ProviderId } from '../providers/types';
+import { adaptSDKMessage } from './claude-messages';
+import { adaptCodexMessage } from './codex-messages';
+import { adaptOllamaMessage } from './ollama-messages';
+
+/** Function signature for a provider message adapter */
+export type MessageAdapter = (raw: Record<string, unknown>) => AgentMessage[];
+
+const adapters = new Map<ProviderId, MessageAdapter>();
+
+/** Register a message adapter for a provider */
+export function registerMessageAdapter(providerId: ProviderId, adapter: MessageAdapter): void {
+  adapters.set(providerId, adapter);
+}
+
+/** Adapt a raw message using the appropriate provider adapter */
+export function adaptMessage(providerId: ProviderId, raw: Record<string, unknown>): AgentMessage[] {
+  const adapter = adapters.get(providerId);
+  if (!adapter) {
+    console.warn(`No message adapter for provider: ${providerId}, falling back to claude`);
+    return adaptSDKMessage(raw);
+  }
+  return adapter(raw);
+}
+
+// Register all provider adapters
+registerMessageAdapter('claude', adaptSDKMessage);
+registerMessageAdapter('codex', adaptCodexMessage);
+registerMessageAdapter('ollama', adaptOllamaMessage);
diff --git a/v2/src/lib/adapters/notifications-bridge.ts b/v2/src/lib/adapters/notifications-bridge.ts
new file mode 100644
index 0000000..8b5609e
--- /dev/null
+++ b/v2/src/lib/adapters/notifications-bridge.ts
@@ -0,0 +1,19 @@
+// Notifications bridge — wraps Tauri desktop notification command
+
+import { invoke } from '@tauri-apps/api/core';
+
+export type NotificationUrgency = 'low' | 'normal' | 'critical';
+
+/**
+ * Send an OS desktop notification via notify-rust.
+ * Fire-and-forget: errors are swallowed (notification daemon may not be running).
+ */
+export function sendDesktopNotification(
+  title: string,
+  body: string,
+  urgency: NotificationUrgency = 'normal',
+): void {
+  invoke('notify_desktop', { title, body, urgency }).catch(() => {
+    // Swallow IPC errors — notifications must never break the app
+  });
+}
diff --git a/v2/src/lib/adapters/ollama-messages.test.ts b/v2/src/lib/adapters/ollama-messages.test.ts
new file mode 100644
index 0000000..65d4719
--- /dev/null
+++ b/v2/src/lib/adapters/ollama-messages.test.ts
@@ -0,0 +1,153 @@
+import { describe, it, expect } from 'vitest';
+import { adaptOllamaMessage } from './ollama-messages';
+
+describe('adaptOllamaMessage', () => {
+  describe('system init', () => {
+    it('maps to init message', () => {
+      const result = adaptOllamaMessage({
+        type: 'system',
+        subtype: 'init',
+        session_id: 'sess-123',
+        model: 'qwen3:8b',
+        cwd: '/home/user/project',
+      });
+      expect(result).toHaveLength(1);
+      expect(result[0].type).toBe('init');
+      const content = result[0].content as any;
+      expect(content.sessionId).toBe('sess-123');
+      expect(content.model).toBe('qwen3:8b');
+      expect(content.cwd).toBe('/home/user/project');
+    });
+  });
+
+  describe('system status', () => {
+    it('maps non-init subtypes to status message', () => {
+      const result = adaptOllamaMessage({
+        type: 'system',
+        subtype: 'model_loaded',
+        status: 'Model loaded successfully',
+      });
+      expect(result).toHaveLength(1);
+      expect(result[0].type).toBe('status');
+      expect((result[0].content as any).subtype).toBe('model_loaded');
+      expect((result[0].content as any).message).toBe('Model loaded successfully');
+    });
+  });
+
+  describe('chunk — text content', () => {
+    it('maps streaming text to text message', () => {
+      const result = adaptOllamaMessage({
+        type: 'chunk',
+        message: { role: 'assistant', content: 'Hello world' },
+        done: false,
+      });
+      expect(result).toHaveLength(1);
+      expect(result[0].type).toBe('text');
+      expect((result[0].content as any).text).toBe('Hello world');
+    });
+
+    it('ignores empty content', () => {
+      const result = adaptOllamaMessage({
+        type: 'chunk',
+        message: { role: 'assistant', content: '' },
+        done: false,
+      });
+      expect(result).toHaveLength(0);
+    });
+  });
+
+  describe('chunk — thinking content', () => {
+    it('maps thinking field to thinking message', () => {
+      const result = adaptOllamaMessage({
+        type: 'chunk',
+        message: { role: 'assistant', content: '', thinking: 'Let me reason about this...' },
+        done: false,
+      });
+      expect(result).toHaveLength(1);
+      expect(result[0].type).toBe('thinking');
+      expect((result[0].content as any).text).toBe('Let me reason about this...');
+    });
+
+    it('emits both thinking and text when both present', () => {
+      const result = adaptOllamaMessage({
+        type: 'chunk',
+        message: { role: 'assistant', content: 'Answer', thinking: 'Reasoning' },
+        done: false,
+      });
+      expect(result).toHaveLength(2);
+      expect(result[0].type).toBe('thinking');
+      expect(result[1].type).toBe('text');
+    });
+  });
+
+  describe('chunk — done with token counts', () => {
+    it('maps final chunk to cost message', () => {
+      const result = adaptOllamaMessage({
+        type: 'chunk',
+        message: { role: 'assistant', content: '' },
+        done: true,
+        done_reason: 'stop',
+        prompt_eval_count: 500,
+        eval_count: 120,
+        eval_duration: 2_000_000_000,
+        total_duration: 3_000_000_000,
+      });
+      // Should have cost message (no text since content is empty)
+      const costMsg = result.find(m => m.type === 'cost');
+      expect(costMsg).toBeDefined();
+      const content = costMsg!.content as any;
+      expect(content.inputTokens).toBe(500);
+      expect(content.outputTokens).toBe(120);
+      expect(content.durationMs).toBe(2000);
+      expect(content.totalCostUsd).toBe(0);
+      expect(content.isError).toBe(false);
+    });
+
+    it('marks error done_reason as isError', () => {
+      const result = adaptOllamaMessage({
+        type: 'chunk',
+        message: { role: 'assistant', content: '' },
+        done: true,
+        done_reason: 'error',
+        prompt_eval_count: 0,
+        eval_count: 0,
+      });
+      const costMsg = result.find(m => m.type === 'cost');
+      expect(costMsg).toBeDefined();
+      expect((costMsg!.content as any).isError).toBe(true);
+    });
+
+    it('includes text + cost when final chunk has content', () => {
+      const result = adaptOllamaMessage({
+        type: 'chunk',
+        message: { role: 'assistant', content: '.' },
+        done: true,
+        done_reason: 'stop',
+        prompt_eval_count: 10,
+        eval_count: 5,
+      });
+      expect(result.some(m => m.type === 'text')).toBe(true);
+      expect(result.some(m => m.type === 'cost')).toBe(true);
+    });
+  });
+
+  describe('error event', () => {
+    it('maps to error message', () => {
+      const result = adaptOllamaMessage({
+        type: 'error',
+        message: 'model not found',
+      });
+      expect(result).toHaveLength(1);
+      expect(result[0].type).toBe('error');
+      expect((result[0].content as any).message).toBe('model not found');
+    });
+  });
+
+  describe('unknown event type', () => {
+    it('maps to unknown message preserving raw data', () => {
+      const result = adaptOllamaMessage({ type: 'something_else', data: 'test' });
+      expect(result).toHaveLength(1);
+      expect(result[0].type).toBe('unknown');
+    });
+  });
+});
diff --git a/v2/src/lib/adapters/ollama-messages.ts b/v2/src/lib/adapters/ollama-messages.ts
new file mode 100644
index 0000000..f5e6e48
--- /dev/null
+++ b/v2/src/lib/adapters/ollama-messages.ts
@@ -0,0 +1,141 @@
+// Ollama Message Adapter — transforms Ollama chat streaming events to internal AgentMessage format
+// Ollama runner emits synthesized events wrapping /api/chat NDJSON chunks
+
+import type {
+  AgentMessage,
+  InitContent,
+  TextContent,
+  ThinkingContent,
+  StatusContent,
+  CostContent,
+  ErrorContent,
+} from './claude-messages';
+
+import { str, num } from '../utils/type-guards';
+
+/**
+ * Adapt a raw Ollama runner event to AgentMessage[].
+ *
+ * The Ollama runner emits events in this format:
+ * - {type:'system', subtype:'init', model, ...}
+ * - {type:'chunk', message:{role,content,thinking}, done:false}
+ * - {type:'chunk', message:{role,content}, done:true, done_reason, prompt_eval_count, eval_count, ...}
+ * - {type:'error', message:'...'}
+ */
+export function adaptOllamaMessage(raw: Record<string, unknown>): AgentMessage[] {
+  const timestamp = Date.now();
+  const uuid = crypto.randomUUID();
+
+  switch (raw.type) {
+    case 'system':
+      return adaptSystemEvent(raw, uuid, timestamp);
+
+    case 'chunk':
+      return adaptChunk(raw, uuid, timestamp);
+
+    case 'error':
+      return [{
+        id: uuid,
+        type: 'error',
+        content: { message: str(raw.message, 'Ollama error') } satisfies ErrorContent,
+        timestamp,
+      }];
+
+    default:
+      return [{
+        id: uuid,
+        type: 'unknown',
+        content: raw,
+        timestamp,
+      }];
+  }
+}
+
+function adaptSystemEvent(
+  raw: Record<string, unknown>,
+  uuid: string,
+  timestamp: number,
+): AgentMessage[] {
+  const subtype = str(raw.subtype);
+
+  if (subtype === 'init') {
+    return [{
+      id: uuid,
+      type: 'init',
+      content: {
+        sessionId: str(raw.session_id),
+        model: str(raw.model),
+        cwd: str(raw.cwd),
+        tools: [],
+      } satisfies InitContent,
+      timestamp,
+    }];
+  }
+
+  return [{
+    id: uuid,
+    type: 'status',
+    content: {
+      subtype,
+      message: typeof raw.status === 'string' ? raw.status : undefined,
+    } satisfies StatusContent,
+    timestamp,
+  }];
+}
+
+function adaptChunk(
+  raw: Record<string, unknown>,
+  uuid: string,
+  timestamp: number,
+): AgentMessage[] {
+  const messages: AgentMessage[] = [];
+  const msg = typeof raw.message === 'object' && raw.message !== null
+    ? raw.message as Record<string, unknown>
+    : {};
+  const done = raw.done === true;
+
+  // Thinking content (extended thinking from Qwen3 etc.)
+  const thinking = str(msg.thinking);
+  if (thinking) {
+    messages.push({
+      id: `${uuid}-think`,
+      type: 'thinking',
+      content: { text: thinking } satisfies ThinkingContent,
+      timestamp,
+    });
+  }
+
+  // Text content
+  const text = str(msg.content);
+  if (text) {
+    messages.push({
+      id: `${uuid}-text`,
+      type: 'text',
+      content: { text } satisfies TextContent,
+      timestamp,
+    });
+  }
+
+  // Final chunk with token counts
+  if (done) {
+    const doneReason = str(raw.done_reason);
+    const evalDuration = num(raw.eval_duration);
+    const durationMs = evalDuration > 0 ? Math.round(evalDuration / 1_000_000) : 0;
+
+    messages.push({
+      id: `${uuid}-cost`,
+      type: 'cost',
+      content: {
+        totalCostUsd: 0,
+        durationMs,
+        inputTokens: num(raw.prompt_eval_count),
+        outputTokens: num(raw.eval_count),
+        numTurns: 1,
+        isError: doneReason === 'error',
+      } satisfies CostContent,
+      timestamp,
+    });
+  }
+
+  return messages;
+}
diff --git a/v2/src/lib/adapters/plugins-bridge.ts b/v2/src/lib/adapters/plugins-bridge.ts
new file mode 100644
index 0000000..5bf67ee
--- /dev/null
+++ b/v2/src/lib/adapters/plugins-bridge.ts
@@ -0,0 +1,22 @@
+// Plugin discovery and file access — Tauri IPC adapter
+
+import { invoke } from '@tauri-apps/api/core';
+
+export interface PluginMeta {
+  id: string;
+  name: string;
+  version: string;
+  description: string;
+  main: string;
+  permissions: string[];
+}
+
+/** Discover all plugins in ~/.config/bterminal/plugins/ */
+export async function discoverPlugins(): Promise<PluginMeta[]> {
+  return invoke<PluginMeta[]>('plugins_discover');
+}
+
+/** Read a file from a plugin's directory (path-traversal safe) */
+export async function readPluginFile(pluginId: string, filename: string): Promise<string> {
+  return invoke<string>('plugin_read_file', { pluginId, filename });
+}
diff --git a/v2/src/lib/adapters/provider-bridge.ts b/v2/src/lib/adapters/provider-bridge.ts
new file mode 100644
index 0000000..e5fb5db
--- /dev/null
+++ b/v2/src/lib/adapters/provider-bridge.ts
@@ -0,0 +1,26 @@
+// Provider Bridge — generic adapter that delegates to provider-specific bridges
+// Currently only Claude is implemented; future providers add their own bridge files
+
+import type { ProviderId } from '../providers/types';
+import { listProfiles as claudeListProfiles, listSkills as claudeListSkills, readSkill as claudeReadSkill, type ClaudeProfile, type ClaudeSkill } from './claude-bridge';
+
+// Re-export types for consumers
+export type { ClaudeProfile, ClaudeSkill };
+
+/** List profiles for a given provider (only Claude supports this) */
+export async function listProviderProfiles(provider: ProviderId): Promise<ClaudeProfile[]> {
+  if (provider === 'claude') return claudeListProfiles();
+  return [];
+}
+
+/** List skills for a given provider (only Claude supports this) */
+export async function listProviderSkills(provider: ProviderId): Promise<ClaudeSkill[]> {
+  if (provider === 'claude') return claudeListSkills();
+  return [];
+}
+
+/** Read a skill file (only Claude supports this) */
+export async function readProviderSkill(provider: ProviderId, path: string): Promise<string> {
+  if (provider === 'claude') return claudeReadSkill(path);
+  return '';
+}
diff --git a/v2/src/lib/adapters/pty-bridge.ts b/v2/src/lib/adapters/pty-bridge.ts
new file mode 100644
index 0000000..1018c37
--- /dev/null
+++ b/v2/src/lib/adapters/pty-bridge.ts
@@ -0,0 +1,52 @@
+import { invoke } from '@tauri-apps/api/core';
+import { listen, type UnlistenFn } from '@tauri-apps/api/event';
+
+export interface PtyOptions {
+  shell?: string;
+  cwd?: string;
+  args?: string[];
+  cols?: number;
+  rows?: number;
+  remote_machine_id?: string;
+}
+
+export async function spawnPty(options: PtyOptions): Promise<string> {
+  if (options.remote_machine_id) {
+    const { remote_machine_id: machineId, ...ptyOptions } = options;
+    return invoke<string>('remote_pty_spawn', { machineId, options: ptyOptions });
+  }
+  return invoke<string>('pty_spawn', { options });
+}
+
+export async function writePty(id: string, data: string, remoteMachineId?: string): Promise<void> {
+  if (remoteMachineId) {
+    return invoke('remote_pty_write', { machineId: remoteMachineId, id, data });
+  }
+  return invoke('pty_write', { id, data });
+}
+
+export async function resizePty(id: string, cols: number, rows: number, remoteMachineId?: string): Promise<void> {
+  if (remoteMachineId) {
+    return invoke('remote_pty_resize', { machineId: remoteMachineId, id, cols, rows });
+  }
+  return invoke('pty_resize', { id, cols, rows });
+}
+
+export async function killPty(id: string, remoteMachineId?: string): Promise<void> {
+  if (remoteMachineId) {
+    return invoke('remote_pty_kill', { machineId: remoteMachineId, id });
+  }
+  return invoke('pty_kill', { id });
+}
+
+export async function onPtyData(id: string, callback: (data: string) => void): Promise<UnlistenFn> {
+  return listen<string>(`pty-data-${id}`, (event) => {
+    callback(event.payload);
+  });
+}
+
+export async function onPtyExit(id: string, callback: () => void): Promise<UnlistenFn> {
+  return listen(`pty-exit-${id}`, () => {
+    callback();
+  });
+}
diff --git a/v2/src/lib/adapters/remote-bridge.ts b/v2/src/lib/adapters/remote-bridge.ts
new file mode 100644
index 0000000..51a66a9
--- /dev/null
+++ b/v2/src/lib/adapters/remote-bridge.ts
@@ -0,0 +1,143 @@
+// Remote Machine Bridge — Tauri IPC adapter for multi-machine management
+
+import { invoke } from '@tauri-apps/api/core';
+import { listen, type UnlistenFn } from '@tauri-apps/api/event';
+
+export interface RemoteMachineConfig {
+  label: string;
+  url: string;
+  token: string;
+  auto_connect: boolean;
+}
+
+export interface RemoteMachineInfo {
+  id: string;
+  label: string;
+  url: string;
+  status: string;
+  auto_connect: boolean;
+}
+
+// --- Machine management ---
+
+export async function listRemoteMachines(): Promise<RemoteMachineInfo[]> {
+  return invoke('remote_list');
+}
+
+export async function addRemoteMachine(config: RemoteMachineConfig): Promise<string> {
+  return invoke('remote_add', { config });
+}
+
+export async function removeRemoteMachine(machineId: string): Promise<void> {
+  return invoke('remote_remove', { machineId });
+}
+
+export async function connectRemoteMachine(machineId: string): Promise<void> {
+  return invoke('remote_connect', { machineId });
+}
+
+export async function disconnectRemoteMachine(machineId: string): Promise<void> {
+  return invoke('remote_disconnect', { machineId });
+}
+
+// --- Remote event listeners ---
+
+export interface RemoteSidecarMessage {
+  machineId: string;
+  sessionId?: string;
+  event?: Record<string, unknown>;
+}
+
+export interface RemotePtyData {
+  machineId: string;
+  sessionId?: string;
+  data?: string;
+}
+
+export interface RemotePtyExit {
+  machineId: string;
+  sessionId?: string;
+}
+
+export interface RemoteMachineEvent {
+  machineId: string;
+  payload?: unknown;
+  error?: unknown;
+}
+
+export async function onRemoteSidecarMessage(
+  callback: (msg: RemoteSidecarMessage) => void,
+): Promise<UnlistenFn> {
+  return listen<RemoteSidecarMessage>('remote-sidecar-message', (event) => {
+    callback(event.payload);
+  });
+}
+
+export async function onRemotePtyData(
+  callback: (msg: RemotePtyData) => void,
+): Promise<UnlistenFn> {
+  return listen<RemotePtyData>('remote-pty-data', (event) => {
+    callback(event.payload);
+  });
+}
+
+export async function onRemotePtyExit(
+  callback: (msg: RemotePtyExit) => void,
+): Promise<UnlistenFn> {
+  return listen<RemotePtyExit>('remote-pty-exit', (event) => {
+    callback(event.payload);
+  });
+}
+
+export async function onRemoteMachineReady(
+  callback: (msg: RemoteMachineEvent) => void,
+): Promise<UnlistenFn> {
+  return listen<RemoteMachineEvent>('remote-machine-ready', (event) => {
+    callback(event.payload);
+  });
+}
+
+export async function onRemoteMachineDisconnected(
+  callback: (msg: RemoteMachineEvent) => void,
+): Promise<UnlistenFn> {
+  return listen<RemoteMachineEvent>('remote-machine-disconnected', (event) => {
+    callback(event.payload);
+  });
+}
+
+export async function onRemoteStateSync(
+  callback: (msg: RemoteMachineEvent) => void,
+): Promise<UnlistenFn> {
+  return listen<RemoteMachineEvent>('remote-state-sync', (event) => {
+    callback(event.payload);
+  });
+}
+
+export async function onRemoteError(
+  callback: (msg: RemoteMachineEvent) => void,
+): Promise<UnlistenFn> {
+  return listen<RemoteMachineEvent>('remote-error', (event) => {
+    callback(event.payload);
+  });
+}
+
+export interface RemoteReconnectingEvent {
+  machineId: string;
+  backoffSecs: number;
+}
+
+export async function onRemoteMachineReconnecting(
+  callback: (msg: RemoteReconnectingEvent) => void,
+): Promise<UnlistenFn> {
+  return listen<RemoteReconnectingEvent>('remote-machine-reconnecting', (event) => {
+    callback(event.payload);
+  });
+}
+
+export async function onRemoteMachineReconnectReady(
+  callback: (msg: RemoteMachineEvent) => void,
+): Promise<UnlistenFn> {
+  return listen<RemoteMachineEvent>('remote-machine-reconnect-ready', (event) => {
+    callback(event.payload);
+  });
+}
diff --git a/v2/src/lib/adapters/search-bridge.ts b/v2/src/lib/adapters/search-bridge.ts
new file mode 100644
index 0000000..562b20d
--- /dev/null
+++ b/v2/src/lib/adapters/search-bridge.ts
@@ -0,0 +1,31 @@
+// Search Bridge — Tauri IPC adapter for FTS5 full-text search
+
+import { invoke } from '@tauri-apps/api/core';
+
+export interface SearchResult {
+  resultType: string;
+  id: string;
+  title: string;
+  snippet: string;
+  score: number;
+}
+
+/** Confirm search database is ready (no-op, initialized at app startup). */
+export async function initSearch(): Promise<void> {
+  return invoke('search_init');
+}
+
+/** Search across all FTS5 tables (messages, tasks, btmsg). */
+export async function searchAll(query: string, limit?: number): Promise<SearchResult[]> {
+  return invoke<SearchResult[]>('search_query', { query, limit: limit ?? 20 });
+}
+
+/** Drop and recreate all FTS5 tables (clears the index). */
+export async function rebuildIndex(): Promise<void> {
+  return invoke('search_rebuild');
+}
+
+/** Index an agent message into the search database. */
+export async function indexMessage(sessionId: string, role: string, content: string): Promise<void> {
+  return invoke('search_index_message', { sessionId, role, content });
+}
diff --git a/v2/src/lib/adapters/secrets-bridge.ts b/v2/src/lib/adapters/secrets-bridge.ts
new file mode 100644
index 0000000..5c62a1e
--- /dev/null
+++ b/v2/src/lib/adapters/secrets-bridge.ts
@@ -0,0 +1,39 @@
+import { invoke } from '@tauri-apps/api/core';
+
+/** Store a secret in the system keyring. */
+export async function storeSecret(key: string, value: string): Promise<void> {
+  return invoke('secrets_store', { key, value });
+}
+
+/** Retrieve a secret from the system keyring. Returns null if not found. */
+export async function getSecret(key: string): Promise<string | null> {
+  return invoke('secrets_get', { key });
+}
+
+/** Delete a secret from the system keyring. */
+export async function deleteSecret(key: string): Promise<void> {
+  return invoke('secrets_delete', { key });
+}
+
+/** List keys that have been stored in the keyring. */
+export async function listSecrets(): Promise<string[]> {
+  return invoke('secrets_list');
+}
+
+/** Check if the system keyring is available. */
+export async function hasKeyring(): Promise<boolean> {
+  return invoke('secrets_has_keyring');
+}
+
+/** Get the list of known/recognized secret key identifiers. */
+export async function knownSecretKeys(): Promise<string[]> {
+  return invoke('secrets_known_keys');
+}
+
+/** Human-readable labels for known secret keys. */
+export const SECRET_KEY_LABELS: Record<string, string> = {
+  anthropic_api_key: 'Anthropic API Key',
+  openai_api_key: 'OpenAI API Key',
+  github_token: 'GitHub Token',
+  relay_token: 'Relay Token',
+};
diff --git a/v2/src/lib/adapters/session-bridge.ts b/v2/src/lib/adapters/session-bridge.ts
new file mode 100644
index 0000000..4815ca7
--- /dev/null
+++ b/v2/src/lib/adapters/session-bridge.ts
@@ -0,0 +1,50 @@
+import { invoke } from '@tauri-apps/api/core';
+
+export interface PersistedSession {
+  id: string;
+  type: string;
+  title: string;
+  shell?: string;
+  cwd?: string;
+  args?: string[];
+  group_name?: string;
+  created_at: number;
+  last_used_at: number;
+}
+
+export interface PersistedLayout {
+  preset: string;
+  pane_ids: string[];
+}
+
+export async function listSessions(): Promise<PersistedSession[]> {
+  return invoke('session_list');
+}
+
+export async function saveSession(session: PersistedSession): Promise<void> {
+  return invoke('session_save', { session });
+}
+
+export async function deleteSession(id: string): Promise<void> {
+  return invoke('session_delete', { id });
+}
+
+export async function updateSessionTitle(id: string, title: string): Promise<void> {
+  return invoke('session_update_title', { id, title });
+}
+
+export async function touchSession(id: string): Promise<void> {
+  return invoke('session_touch', { id });
+}
+
+export async function updateSessionGroup(id: string, groupName: string): Promise<void> {
+  return invoke('session_update_group', { id, group_name: groupName });
+}
+
+export async function saveLayout(layout: PersistedLayout): Promise<void> {
+  return invoke('layout_save', { layout });
+}
+
+export async function loadLayout(): Promise<PersistedLayout> {
+  return invoke('layout_load');
+}
diff --git a/v2/src/lib/adapters/settings-bridge.ts b/v2/src/lib/adapters/settings-bridge.ts
new file mode 100644
index 0000000..0dfb346
--- /dev/null
+++ b/v2/src/lib/adapters/settings-bridge.ts
@@ -0,0 +1,13 @@
+import { invoke } from '@tauri-apps/api/core';
+
+export async function getSetting(key: string): Promise<string | null> {
+  return invoke('settings_get', { key });
+}
+
+export async function setSetting(key: string, value: string): Promise<void> {
+  return invoke('settings_set', { key, value });
+}
+
+export async function listSettings(): Promise<[string, string][]> {
+  return invoke('settings_list');
+}
diff --git a/v2/src/lib/adapters/ssh-bridge.ts b/v2/src/lib/adapters/ssh-bridge.ts
new file mode 100644
index 0000000..a01c40c
--- /dev/null
+++ b/v2/src/lib/adapters/ssh-bridge.ts
@@ -0,0 +1,26 @@
+import { invoke } from '@tauri-apps/api/core';
+
+export interface SshSession {
+  id: string;
+  name: string;
+  host: string;
+  port: number;
+  username: string;
+  key_file: string;
+  folder: string;
+  color: string;
+  created_at: number;
+  last_used_at: number;
+}
+
+export async function listSshSessions(): Promise<SshSession[]> {
+  return invoke('ssh_session_list');
+}
+
+export async function saveSshSession(session: SshSession): Promise<void> {
+  return invoke('ssh_session_save', { session });
+}
+
+export async function deleteSshSession(id: string): Promise<void> {
+  return invoke('ssh_session_delete', { id });
+}
diff --git a/v2/src/lib/adapters/telemetry-bridge.ts b/v2/src/lib/adapters/telemetry-bridge.ts
new file mode 100644
index 0000000..394c596
--- /dev/null
+++ b/v2/src/lib/adapters/telemetry-bridge.ts
@@ -0,0 +1,26 @@
+// Telemetry bridge — routes frontend events to Rust tracing via IPC
+// No browser OTEL SDK needed (WebKit2GTK incompatible)
+
+import { invoke } from '@tauri-apps/api/core';
+
+type LogLevel = 'error' | 'warn' | 'info' | 'debug' | 'trace';
+
+/** Emit a structured log event to the Rust tracing layer */
+export function telemetryLog(
+  level: LogLevel,
+  message: string,
+  context?: Record<string, unknown>,
+): void {
+  invoke('frontend_log', { level, message, context: context ?? null }).catch(() => {
+    // Swallow IPC errors — telemetry must never break the app
+  });
+}
+
+/** Convenience wrappers */
+export const tel = {
+  error: (msg: string, ctx?: Record<string, unknown>) => telemetryLog('error', msg, ctx),
+  warn: (msg: string, ctx?: Record<string, unknown>) => telemetryLog('warn', msg, ctx),
+  info: (msg: string, ctx?: Record<string, unknown>) => telemetryLog('info', msg, ctx),
+  debug: (msg: string, ctx?: Record<string, unknown>) => telemetryLog('debug', msg, ctx),
+  trace: (msg: string, ctx?: Record<string, unknown>) => telemetryLog('trace', msg, ctx),
+};
diff --git a/v2/src/lib/agent-dispatcher.test.ts b/v2/src/lib/agent-dispatcher.test.ts
new file mode 100644
index 0000000..74a4ff1
--- /dev/null
+++ b/v2/src/lib/agent-dispatcher.test.ts
@@ -0,0 +1,669 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+// --- Hoisted mocks ---
+
+const {
+  capturedCallbacks,
+  mockUnlistenMsg,
+  mockUnlistenExit,
+  mockRestartAgent,
+  mockUpdateAgentStatus,
+  mockSetAgentSdkSessionId,
+  mockSetAgentModel,
+  mockAppendAgentMessages,
+  mockUpdateAgentCost,
+  mockGetAgentSessions,
+  mockCreateAgentSession,
+  mockFindChildByToolUseId,
+  mockAddPane,
+  mockGetPanes,
+  mockNotify,
+  mockAddNotification,
+} = vi.hoisted(() => ({
+  capturedCallbacks: {
+    msg: null as ((msg: any) => void) | null,
+    exit: null as (() => void) | null,
+  },
+  mockUnlistenMsg: vi.fn(),
+  mockUnlistenExit: vi.fn(),
+  mockRestartAgent: vi.fn(),
+  mockUpdateAgentStatus: vi.fn(),
+  mockSetAgentSdkSessionId: vi.fn(),
+  mockSetAgentModel: vi.fn(),
+  mockAppendAgentMessages: vi.fn(),
+  mockUpdateAgentCost: vi.fn(),
+  mockGetAgentSessions: vi.fn().mockReturnValue([]),
+  mockCreateAgentSession: vi.fn(),
+  mockFindChildByToolUseId: vi.fn().mockReturnValue(undefined),
+  mockAddPane: vi.fn(),
+  mockGetPanes: vi.fn().mockReturnValue([]),
+  mockNotify: vi.fn(),
+  mockAddNotification: vi.fn(),
+}));
+
+vi.mock('./adapters/agent-bridge', () => ({
+  onSidecarMessage: vi.fn(async (cb: (msg: any) => void) => {
+    capturedCallbacks.msg = cb;
+    return mockUnlistenMsg;
+  }),
+  onSidecarExited: vi.fn(async (cb: () => void) => {
+    capturedCallbacks.exit = cb;
+    return mockUnlistenExit;
+  }),
+  restartAgent: (...args: unknown[]) => mockRestartAgent(...args),
+}));
+
+vi.mock('./providers/types', () => ({}));
+
+vi.mock('./adapters/message-adapters', () => ({
+  adaptMessage: vi.fn((_provider: string, raw: Record<string, unknown>) => {
+    if (raw.type === 'system' && raw.subtype === 'init') {
+      return [{
+        id: 'msg-1',
+        type: 'init',
+        content: { sessionId: 'sdk-sess', model: 'claude-sonnet-4-20250514', cwd: '/tmp', tools: [] },
+        timestamp: Date.now(),
+      }];
+    }
+    if (raw.type === 'result') {
+      return [{
+        id: 'msg-2',
+        type: 'cost',
+        content: {
+          totalCostUsd: 0.05,
+          durationMs: 5000,
+          inputTokens: 500,
+          outputTokens: 200,
+          numTurns: 2,
+          isError: false,
+        },
+        timestamp: Date.now(),
+      }];
+    }
+    if (raw.type === 'assistant') {
+      return [{
+        id: 'msg-3',
+        type: 'text',
+        content: { text: 'Hello' },
+        timestamp: Date.now(),
+      }];
+    }
+    // Subagent tool_call (Agent/Task)
+    if (raw.type === 'tool_call_agent') {
+      return [{
+        id: 'msg-tc-agent',
+        type: 'tool_call',
+        content: {
+          toolUseId: raw.toolUseId ?? 'tu-123',
+          name: raw.toolName ?? 'Agent',
+          input: raw.toolInput ?? { prompt: 'Do something', name: 'researcher' },
+        },
+        timestamp: Date.now(),
+      }];
+    }
+    // Non-subagent tool_call
+    if (raw.type === 'tool_call_normal') {
+      return [{
+        id: 'msg-tc-normal',
+        type: 'tool_call',
+        content: {
+          toolUseId: 'tu-normal',
+          name: 'Read',
+          input: { file: 'test.ts' },
+        },
+        timestamp: Date.now(),
+      }];
+    }
+    // Message with parentId (routed to child)
+    if (raw.type === 'child_message') {
+      return [{
+        id: 'msg-child',
+        type: 'text',
+        parentId: raw.parentId as string,
+        content: { text: 'Child output' },
+        timestamp: Date.now(),
+      }];
+    }
+    // Child init message
+    if (raw.type === 'child_init') {
+      return [{
+        id: 'msg-child-init',
+        type: 'init',
+        parentId: raw.parentId as string,
+        content: { sessionId: 'child-sdk-sess', model: 'claude-sonnet-4-20250514', cwd: '/tmp', tools: [] },
+        timestamp: Date.now(),
+      }];
+    }
+    // Child cost message
+    if (raw.type === 'child_cost') {
+      return [{
+        id: 'msg-child-cost',
+        type: 'cost',
+        parentId: raw.parentId as string,
+        content: {
+          totalCostUsd: 0.02,
+          durationMs: 2000,
+          inputTokens: 200,
+          outputTokens: 100,
+          numTurns: 1,
+          isError: false,
+        },
+        timestamp: Date.now(),
+      }];
+    }
+    return [];
+  }),
+}));
+
+vi.mock('./stores/agents.svelte', () => ({
+  updateAgentStatus: (...args: unknown[]) => mockUpdateAgentStatus(...args),
+  setAgentSdkSessionId: (...args: unknown[]) => mockSetAgentSdkSessionId(...args),
+  setAgentModel: (...args: unknown[]) => mockSetAgentModel(...args),
+  appendAgentMessages: (...args: unknown[]) => mockAppendAgentMessages(...args),
+  updateAgentCost: (...args: unknown[]) => mockUpdateAgentCost(...args),
+  getAgentSessions: () => mockGetAgentSessions(),
+  createAgentSession: (...args: unknown[]) => mockCreateAgentSession(...args),
+  findChildByToolUseId: (...args: unknown[]) => mockFindChildByToolUseId(...args),
+}));
+
+vi.mock('./stores/layout.svelte', () => ({
+  addPane: (...args: unknown[]) => mockAddPane(...args),
+  getPanes: () => mockGetPanes(),
+}));
+
+vi.mock('./stores/notifications.svelte', () => ({
+  notify: (...args: unknown[]) => mockNotify(...args),
+  addNotification: (...args: unknown[]) => mockAddNotification(...args),
+}));
+
+vi.mock('./stores/conflicts.svelte', () => ({
+  recordFileWrite: vi.fn().mockReturnValue(false),
+  clearSessionWrites: vi.fn(),
+  setSessionWorktree: vi.fn(),
+}));
+
+vi.mock('./utils/tool-files', () => ({
+  extractWritePaths: vi.fn().mockReturnValue([]),
+  extractWorktreePath: vi.fn().mockReturnValue(null),
+}));
+
+// Use fake timers to control setTimeout in sidecar crash recovery
+beforeEach(() => {
+  vi.useFakeTimers();
+  vi.clearAllMocks();
+  capturedCallbacks.msg = null;
+  capturedCallbacks.exit = null;
+  mockRestartAgent.mockResolvedValue(undefined);
+  mockGetAgentSessions.mockReturnValue([]);
+});
+
+// We need to dynamically import the dispatcher in each test to get fresh module state.
+// However, vi.mock is module-scoped so the mocks persist. The module-level restartAttempts
+// and sidecarAlive variables persist across tests since they share the same module instance.
+// We work around this by resetting via the exported setSidecarAlive and stopAgentDispatcher.
+
+import {
+  startAgentDispatcher,
+  stopAgentDispatcher,
+  isSidecarAlive,
+  setSidecarAlive,
+  waitForPendingPersistence,
+} from './agent-dispatcher';
+
+// Stop any previous dispatcher between tests so `unlistenMsg` is null and start works
+beforeEach(() => {
+  stopAgentDispatcher();
+});
+
+afterEach(async () => {
+  vi.useRealTimers();
+});
+
+// Need afterEach import
+import { afterEach } from 'vitest';
+
+describe('agent-dispatcher', () => {
+  describe('startAgentDispatcher', () => {
+    it('registers sidecar message and exit listeners', async () => {
+      await startAgentDispatcher();
+
+      expect(capturedCallbacks.msg).toBeTypeOf('function');
+      expect(capturedCallbacks.exit).toBeTypeOf('function');
+    });
+
+    it('does not register duplicate listeners on repeated calls', async () => {
+      await startAgentDispatcher();
+      await startAgentDispatcher(); // second call should be no-op
+
+      const { onSidecarMessage } = await import('./adapters/agent-bridge');
+      expect(onSidecarMessage).toHaveBeenCalledTimes(1);
+    });
+
+    it('sets sidecarAlive to true on start', async () => {
+      setSidecarAlive(false);
+      await startAgentDispatcher();
+      expect(isSidecarAlive()).toBe(true);
+    });
+  });
+
+  describe('message routing', () => {
+    beforeEach(async () => {
+      await startAgentDispatcher();
+    });
+
+    it('routes agent_started to updateAgentStatus(running)', () => {
+      capturedCallbacks.msg!({
+        type: 'agent_started',
+        sessionId: 'sess-1',
+      });
+
+      expect(mockUpdateAgentStatus).toHaveBeenCalledWith('sess-1', 'running');
+    });
+
+    it('routes agent_stopped to updateAgentStatus(done) and notifies', () => {
+      capturedCallbacks.msg!({
+        type: 'agent_stopped',
+        sessionId: 'sess-1',
+      });
+
+      expect(mockUpdateAgentStatus).toHaveBeenCalledWith('sess-1', 'done');
+      expect(mockNotify).toHaveBeenCalledWith('success', expect.stringContaining('completed'));
+    });
+
+    it('routes agent_error to updateAgentStatus(error) with message', () => {
+      capturedCallbacks.msg!({
+        type: 'agent_error',
+        sessionId: 'sess-1',
+        message: 'Process crashed',
+      });
+
+      expect(mockUpdateAgentStatus).toHaveBeenCalledWith('sess-1', 'error', 'Process crashed');
+      expect(mockNotify).toHaveBeenCalledWith('error', expect.stringContaining('Process crashed'));
+    });
+
+    it('ignores messages without sessionId', () => {
+      capturedCallbacks.msg!({
+        type: 'agent_started',
+      });
+
+      expect(mockUpdateAgentStatus).not.toHaveBeenCalled();
+    });
+
+    it('handles agent_log silently (no-op)', () => {
+      capturedCallbacks.msg!({
+        type: 'agent_log',
+        sessionId: 'sess-1',
+        message: 'Debug info',
+      });
+
+      expect(mockUpdateAgentStatus).not.toHaveBeenCalled();
+      expect(mockNotify).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('agent_event routing via SDK adapter', () => {
+    beforeEach(async () => {
+      await startAgentDispatcher();
+    });
+
+    it('routes init event to setAgentSdkSessionId and setAgentModel', () => {
+      capturedCallbacks.msg!({
+        type: 'agent_event',
+        sessionId: 'sess-1',
+        event: { type: 'system', subtype: 'init' },
+      });
+
+      expect(mockSetAgentSdkSessionId).toHaveBeenCalledWith('sess-1', 'sdk-sess');
+      expect(mockSetAgentModel).toHaveBeenCalledWith('sess-1', 'claude-sonnet-4-20250514');
+      expect(mockAppendAgentMessages).toHaveBeenCalled();
+    });
+
+    it('routes cost event to updateAgentCost and updateAgentStatus', () => {
+      capturedCallbacks.msg!({
+        type: 'agent_event',
+        sessionId: 'sess-1',
+        event: { type: 'result' },
+      });
+
+      expect(mockUpdateAgentCost).toHaveBeenCalledWith('sess-1', {
+        costUsd: 0.05,
+        inputTokens: 500,
+        outputTokens: 200,
+        numTurns: 2,
+        durationMs: 5000,
+      });
+      expect(mockUpdateAgentStatus).toHaveBeenCalledWith('sess-1', 'done');
+    });
+
+    it('appends messages to agent session', () => {
+      capturedCallbacks.msg!({
+        type: 'agent_event',
+        sessionId: 'sess-1',
+        event: { type: 'assistant' },
+      });
+
+      expect(mockAppendAgentMessages).toHaveBeenCalledWith('sess-1', [
+        expect.objectContaining({ type: 'text', content: { text: 'Hello' } }),
+      ]);
+    });
+
+    it('does not append when adapter returns empty array', () => {
+      capturedCallbacks.msg!({
+        type: 'agent_event',
+        sessionId: 'sess-1',
+        event: { type: 'unknown_event' },
+      });
+
+      expect(mockAppendAgentMessages).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('sidecar exit handling', () => {
+    beforeEach(async () => {
+      await startAgentDispatcher();
+    });
+
+    it('marks running sessions as errored on exit', async () => {
+      mockGetAgentSessions.mockReturnValue([
+        { id: 'sess-1', status: 'running' },
+        { id: 'sess-2', status: 'done' },
+        { id: 'sess-3', status: 'starting' },
+      ]);
+
+      // Trigger exit -- don't await, since it has internal setTimeout
+      const exitPromise = capturedCallbacks.exit!();
+      // Advance past the backoff delay (up to 4s)
+      await vi.advanceTimersByTimeAsync(5000);
+      await exitPromise;
+
+      expect(mockUpdateAgentStatus).toHaveBeenCalledWith('sess-1', 'error', 'Sidecar crashed');
+      expect(mockUpdateAgentStatus).toHaveBeenCalledWith('sess-3', 'error', 'Sidecar crashed');
+      // sess-2 (done) should not be updated with 'error'/'Sidecar crashed'
+      const calls = mockUpdateAgentStatus.mock.calls;
+      const sess2Calls = calls.filter((c: unknown[]) => c[0] === 'sess-2');
+      expect(sess2Calls).toHaveLength(0);
+    });
+
+    it('attempts auto-restart and notifies with warning', async () => {
+      const exitPromise = capturedCallbacks.exit!();
+      await vi.advanceTimersByTimeAsync(5000);
+      await exitPromise;
+
+      expect(mockRestartAgent).toHaveBeenCalled();
+      expect(mockNotify).toHaveBeenCalledWith('warning', expect.stringContaining('restarting'));
+    });
+  });
+
+  describe('stopAgentDispatcher', () => {
+    it('calls unlisten functions', async () => {
+      await startAgentDispatcher();
+      stopAgentDispatcher();
+
+      expect(mockUnlistenMsg).toHaveBeenCalled();
+      expect(mockUnlistenExit).toHaveBeenCalled();
+    });
+
+    it('allows re-registering after stop', async () => {
+      await startAgentDispatcher();
+      stopAgentDispatcher();
+      await startAgentDispatcher();
+
+      const { onSidecarMessage } = await import('./adapters/agent-bridge');
+      expect(onSidecarMessage).toHaveBeenCalledTimes(2);
+    });
+  });
+
+  describe('isSidecarAlive / setSidecarAlive', () => {
+    it('defaults to true after start', async () => {
+      await startAgentDispatcher();
+      expect(isSidecarAlive()).toBe(true);
+    });
+
+    it('can be set manually', () => {
+      setSidecarAlive(false);
+      expect(isSidecarAlive()).toBe(false);
+      setSidecarAlive(true);
+      expect(isSidecarAlive()).toBe(true);
+    });
+  });
+
+  describe('subagent routing', () => {
+    beforeEach(async () => {
+      await startAgentDispatcher();
+      mockGetPanes.mockReturnValue([
+        { id: 'sess-1', type: 'agent', title: 'Agent 1', focused: false },
+      ]);
+      mockFindChildByToolUseId.mockReturnValue(undefined);
+    });
+
+    it('spawns a subagent pane when Agent tool_call is detected', () => {
+      capturedCallbacks.msg!({
+        type: 'agent_event',
+        sessionId: 'sess-1',
+        event: { type: 'tool_call_agent', toolUseId: 'tu-agent-1', toolName: 'Agent', toolInput: { prompt: 'Research X', name: 'researcher' } },
+      });
+
+      expect(mockCreateAgentSession).toHaveBeenCalledWith(
+        expect.any(String),
+        'Research X',
+        { sessionId: 'sess-1', toolUseId: 'tu-agent-1' },
+      );
+      expect(mockUpdateAgentStatus).toHaveBeenCalledWith(expect.any(String), 'running');
+      expect(mockAddPane).toHaveBeenCalledWith(expect.objectContaining({
+        type: 'agent',
+        title: 'Sub: researcher',
+        group: 'Agent 1',
+      }));
+    });
+
+    it('spawns a subagent pane for Task tool_call', () => {
+      capturedCallbacks.msg!({
+        type: 'agent_event',
+        sessionId: 'sess-1',
+        event: { type: 'tool_call_agent', toolUseId: 'tu-task-1', toolName: 'Task', toolInput: { prompt: 'Build it', name: 'builder' } },
+      });
+
+      expect(mockCreateAgentSession).toHaveBeenCalled();
+      expect(mockAddPane).toHaveBeenCalledWith(expect.objectContaining({
+        title: 'Sub: builder',
+      }));
+    });
+
+    it('does not spawn pane for non-subagent tool_calls', () => {
+      capturedCallbacks.msg!({
+        type: 'agent_event',
+        sessionId: 'sess-1',
+        event: { type: 'tool_call_normal' },
+      });
+
+      expect(mockCreateAgentSession).not.toHaveBeenCalled();
+      expect(mockAddPane).not.toHaveBeenCalled();
+    });
+
+    it('does not spawn duplicate pane for same toolUseId', () => {
+      // First call — spawns pane
+      capturedCallbacks.msg!({
+        type: 'agent_event',
+        sessionId: 'sess-1',
+        event: { type: 'tool_call_agent', toolUseId: 'tu-dup', toolName: 'Agent', toolInput: { prompt: 'test', name: 'dup' } },
+      });
+
+      // Second call with same toolUseId — should not create another
+      capturedCallbacks.msg!({
+        type: 'agent_event',
+        sessionId: 'sess-1',
+        event: { type: 'tool_call_agent', toolUseId: 'tu-dup', toolName: 'Agent', toolInput: { prompt: 'test', name: 'dup' } },
+      });
+
+      expect(mockCreateAgentSession).toHaveBeenCalledTimes(1);
+      expect(mockAddPane).toHaveBeenCalledTimes(1);
+    });
+
+    it('reuses existing child session from findChildByToolUseId', () => {
+      mockFindChildByToolUseId.mockReturnValue({ id: 'existing-child' });
+
+      capturedCallbacks.msg!({
+        type: 'agent_event',
+        sessionId: 'sess-1',
+        event: { type: 'tool_call_agent', toolUseId: 'tu-existing', toolName: 'Agent', toolInput: { prompt: 'test' } },
+      });
+
+      // Should not create a new session or pane
+      expect(mockCreateAgentSession).not.toHaveBeenCalled();
+      expect(mockAddPane).not.toHaveBeenCalled();
+    });
+
+    it('routes messages with parentId to the child pane', () => {
+      // First spawn a subagent
+      capturedCallbacks.msg!({
+        type: 'agent_event',
+        sessionId: 'sess-1',
+        event: { type: 'tool_call_agent', toolUseId: 'tu-route', toolName: 'Agent', toolInput: { prompt: 'test', name: 'worker' } },
+      });
+
+      const childId = mockCreateAgentSession.mock.calls[0][0];
+
+      // Now send a message with parentId matching the toolUseId
+      capturedCallbacks.msg!({
+        type: 'agent_event',
+        sessionId: 'sess-1',
+        event: { type: 'child_message', parentId: 'tu-route' },
+      });
+
+      // The child message should go to child pane, not main session
+      expect(mockAppendAgentMessages).toHaveBeenCalledWith(
+        childId,
+        [expect.objectContaining({ type: 'text', content: { text: 'Child output' } })],
+      );
+    });
+
+    it('routes child init message and updates child session', () => {
+      // Spawn subagent
+      capturedCallbacks.msg!({
+        type: 'agent_event',
+        sessionId: 'sess-1',
+        event: { type: 'tool_call_agent', toolUseId: 'tu-cinit', toolName: 'Agent', toolInput: { prompt: 'test', name: 'init-test' } },
+      });
+
+      const childId = mockCreateAgentSession.mock.calls[0][0];
+      mockUpdateAgentStatus.mockClear();
+
+      // Send child init
+      capturedCallbacks.msg!({
+        type: 'agent_event',
+        sessionId: 'sess-1',
+        event: { type: 'child_init', parentId: 'tu-cinit' },
+      });
+
+      expect(mockSetAgentSdkSessionId).toHaveBeenCalledWith(childId, 'child-sdk-sess');
+      expect(mockSetAgentModel).toHaveBeenCalledWith(childId, 'claude-sonnet-4-20250514');
+      expect(mockUpdateAgentStatus).toHaveBeenCalledWith(childId, 'running');
+    });
+
+    it('routes child cost message and marks child done', () => {
+      // Spawn subagent
+      capturedCallbacks.msg!({
+        type: 'agent_event',
+        sessionId: 'sess-1',
+        event: { type: 'tool_call_agent', toolUseId: 'tu-ccost', toolName: 'Agent', toolInput: { prompt: 'test', name: 'cost-test' } },
+      });
+
+      const childId = mockCreateAgentSession.mock.calls[0][0];
+
+      // Send child cost
+      capturedCallbacks.msg!({
+        type: 'agent_event',
+        sessionId: 'sess-1',
+        event: { type: 'child_cost', parentId: 'tu-ccost' },
+      });
+
+      expect(mockUpdateAgentCost).toHaveBeenCalledWith(childId, {
+        costUsd: 0.02,
+        inputTokens: 200,
+        outputTokens: 100,
+        numTurns: 1,
+        durationMs: 2000,
+      });
+      expect(mockUpdateAgentStatus).toHaveBeenCalledWith(childId, 'done');
+    });
+
+    it('uses tool name as fallback when input has no prompt/name', () => {
+      capturedCallbacks.msg!({
+        type: 'agent_event',
+        sessionId: 'sess-1',
+        event: { type: 'tool_call_agent', toolUseId: 'tu-fallback', toolName: 'dispatch_agent', toolInput: 'raw string input' },
+      });
+
+      expect(mockCreateAgentSession).toHaveBeenCalledWith(
+        expect.any(String),
+        'dispatch_agent',
+        expect.any(Object),
+      );
+      expect(mockAddPane).toHaveBeenCalledWith(expect.objectContaining({
+        title: 'Sub: dispatch_agent',
+      }));
+    });
+
+    it('uses parent fallback title when parent pane not found', () => {
+      mockGetPanes.mockReturnValue([]); // no panes found
+
+      capturedCallbacks.msg!({
+        type: 'agent_event',
+        sessionId: 'sess-1',
+        event: { type: 'tool_call_agent', toolUseId: 'tu-noparent', toolName: 'Agent', toolInput: { prompt: 'test', name: 'orphan' } },
+      });
+
+      expect(mockAddPane).toHaveBeenCalledWith(expect.objectContaining({
+        group: 'Agent sess-1',
+      }));
+    });
+  });
+
+  describe('waitForPendingPersistence', () => {
+    it('resolves immediately when no persistence is in-flight', async () => {
+      vi.useRealTimers();
+      await expect(waitForPendingPersistence()).resolves.toBeUndefined();
+    });
+  });
+
+  describe('init event CWD worktree detection', () => {
+    beforeEach(async () => {
+      await startAgentDispatcher();
+    });
+
+    it('calls setSessionWorktree when init CWD contains worktree path', async () => {
+      const { setSessionWorktree } = await import('./stores/conflicts.svelte');
+
+      // Override the mock adapter to return init with worktree CWD
+      const { adaptMessage } = await import('./adapters/message-adapters');
+      (adaptMessage as ReturnType<typeof vi.fn>).mockReturnValueOnce([{
+        id: 'msg-wt',
+        type: 'init',
+        content: { sessionId: 'sdk-wt', model: 'claude-sonnet-4-20250514', cwd: '/home/user/repo/.claude/worktrees/my-session', tools: [] },
+        timestamp: Date.now(),
+      }]);
+
+      capturedCallbacks.msg!({
+        type: 'agent_event',
+        sessionId: 'sess-wt',
+        event: { type: 'system', subtype: 'init' },
+      });
+
+      expect(setSessionWorktree).toHaveBeenCalledWith('sess-wt', '/.claude/worktrees/my-session');
+    });
+
+    it('does not call setSessionWorktree for non-worktree CWD', async () => {
+      const { setSessionWorktree } = await import('./stores/conflicts.svelte');
+      (setSessionWorktree as ReturnType<typeof vi.fn>).mockClear();
+
+      capturedCallbacks.msg!({
+        type: 'agent_event',
+        sessionId: 'sess-normal',
+        event: { type: 'system', subtype: 'init' },
+      });
+
+      // The default mock returns cwd: '/tmp' which is not a worktree
+      expect(setSessionWorktree).not.toHaveBeenCalled();
+    });
+  });
+});
diff --git a/v2/src/lib/agent-dispatcher.ts b/v2/src/lib/agent-dispatcher.ts
new file mode 100644
index 0000000..dd1e5e6
--- /dev/null
+++ b/v2/src/lib/agent-dispatcher.ts
@@ -0,0 +1,364 @@
+// Agent Dispatcher — connects sidecar bridge events to agent store
+// Thin coordinator that routes sidecar messages to specialized modules
+
+import { SessionId, type SessionId as SessionIdType } from './types/ids';
+import { onSidecarMessage, onSidecarExited, restartAgent, type SidecarMessage } from './adapters/agent-bridge';
+import { adaptMessage } from './adapters/message-adapters';
+import type { InitContent, CostContent, ToolCallContent } from './adapters/claude-messages';
+import {
+  updateAgentStatus,
+  setAgentSdkSessionId,
+  setAgentModel,
+  appendAgentMessages,
+  updateAgentCost,
+  getAgentSessions,
+  getAgentSession,
+} from './stores/agents.svelte';
+import { notify, addNotification } from './stores/notifications.svelte';
+import { classifyError } from './utils/error-classifier';
+import { tel } from './adapters/telemetry-bridge';
+import { recordActivity, recordToolDone, recordTokenSnapshot } from './stores/health.svelte';
+import { recordFileWrite, clearSessionWrites, setSessionWorktree } from './stores/conflicts.svelte';
+import { extractWritePaths, extractWorktreePath } from './utils/tool-files';
+import { hasAutoAnchored, markAutoAnchored } from './stores/anchors.svelte';
+import { detectWorktreeFromCwd } from './utils/worktree-detection';
+import {
+  getSessionProjectId,
+  getSessionProvider,
+  recordSessionStart,
+  persistSessionForProject,
+  clearSessionMaps,
+} from './utils/session-persistence';
+import { triggerAutoAnchor } from './utils/auto-anchoring';
+import {
+  isSubagentToolCall,
+  getChildPaneId,
+  spawnSubagentPane,
+  clearSubagentRoutes,
+} from './utils/subagent-router';
+import { indexMessage } from './adapters/search-bridge';
+import { recordHeartbeat } from './adapters/btmsg-bridge';
+import { logAuditEvent } from './adapters/audit-bridge';
+import type { AgentId } from './types/ids';
+
+// Re-export public API consumed by other modules
+export { registerSessionProject, waitForPendingPersistence } from './utils/session-persistence';
+
+let unlistenMsg: (() => void) | null = null;
+let unlistenExit: (() => void) | null = null;
+
+// Sidecar liveness — checked by UI components
+let sidecarAlive = true;
+
+// Sidecar crash recovery state
+const MAX_RESTART_ATTEMPTS = 3;
+let restartAttempts = 0;
+let restarting = false;
+export function isSidecarAlive(): boolean {
+  return sidecarAlive;
+}
+export function setSidecarAlive(alive: boolean): void {
+  sidecarAlive = alive;
+}
+
+export async function startAgentDispatcher(): Promise<void> {
+  if (unlistenMsg) return;
+
+  sidecarAlive = true;
+
+  unlistenMsg = await onSidecarMessage((msg: SidecarMessage) => {
+    sidecarAlive = true;
+    // Reset restart counter on any successful message — sidecar recovered
+    if (restartAttempts > 0) {
+      notify('success', 'Sidecar recovered');
+      restartAttempts = 0;
+    }
+
+    if (!msg.sessionId) return;
+    const sessionId = SessionId(msg.sessionId);
+
+    // Record heartbeat on any agent activity (best-effort, fire-and-forget)
+    const hbProjectId = getSessionProjectId(sessionId);
+    if (hbProjectId) {
+      recordHeartbeat(hbProjectId as unknown as AgentId).catch(() => {});
+    }
+
+    switch (msg.type) {
+      case 'agent_started':
+        updateAgentStatus(sessionId, 'running');
+        recordSessionStart(sessionId);
+        tel.info('agent_started', { sessionId });
+        if (hbProjectId) {
+          logAuditEvent(hbProjectId as unknown as AgentId, 'status_change', `Agent started (session ${sessionId.slice(0, 8)})`).catch(() => {});
+        }
+        break;
+
+      case 'agent_event':
+        if (msg.event) handleAgentEvent(sessionId, msg.event);
+        break;
+
+      case 'agent_stopped':
+        updateAgentStatus(sessionId, 'done');
+        tel.info('agent_stopped', { sessionId });
+        notify('success', `Agent ${sessionId.slice(0, 8)} completed`);
+        addNotification('Agent complete', `Session ${sessionId.slice(0, 8)} finished`, 'agent_complete', getSessionProjectId(sessionId) ?? undefined);
+        if (hbProjectId) {
+          logAuditEvent(hbProjectId as unknown as AgentId, 'status_change', `Agent completed (session ${sessionId.slice(0, 8)})`).catch(() => {});
+        }
+        break;
+
+      case 'agent_error': {
+        const errorMsg = msg.message ?? 'Unknown';
+        const classified = classifyError(errorMsg);
+        updateAgentStatus(sessionId, 'error', errorMsg);
+        tel.error('agent_error', { sessionId, error: errorMsg, errorType: classified.type });
+
+        // Show type-specific toast
+        if (classified.type === 'rate_limit') {
+          notify('warning', `Rate limited. ${classified.retryDelaySec > 0 ? `Retrying in ~${classified.retryDelaySec}s...` : ''}`);
+        } else if (classified.type === 'auth') {
+          notify('error', 'API key invalid or expired. Check Settings.');
+        } else if (classified.type === 'quota') {
+          notify('error', 'API quota exceeded. Check your billing.');
+        } else if (classified.type === 'overloaded') {
+          notify('warning', 'API overloaded. Will retry shortly...');
+        } else if (classified.type === 'network') {
+          notify('error', 'Network error. Check your connection.');
+        } else {
+          notify('error', `Agent error: ${errorMsg}`);
+        }
+
+        addNotification('Agent error', classified.message, 'agent_error', getSessionProjectId(sessionId) ?? undefined);
+        if (hbProjectId) {
+          logAuditEvent(hbProjectId as unknown as AgentId, 'status_change', `Agent error (${classified.type}): ${errorMsg} (session ${sessionId.slice(0, 8)})`).catch(() => {});
+        }
+        break;
+      }
+
+      case 'agent_log':
+        break;
+    }
+  });
+
+  unlistenExit = await onSidecarExited(async () => {
+    sidecarAlive = false;
+    tel.error('sidecar_crashed', { restartAttempts });
+
+    // Guard against re-entrant exit handler (double-restart race)
+    if (restarting) return;
+    restarting = true;
+
+    // Mark all running sessions as errored
+    for (const session of getAgentSessions()) {
+      if (session.status === 'running' || session.status === 'starting') {
+        updateAgentStatus(session.id, 'error', 'Sidecar crashed');
+      }
+    }
+
+    // Attempt auto-restart with exponential backoff
+    try {
+      if (restartAttempts < MAX_RESTART_ATTEMPTS) {
+        restartAttempts++;
+        const delayMs = 1000 * Math.pow(2, restartAttempts - 1); // 1s, 2s, 4s
+        notify('warning', `Sidecar crashed, restarting (attempt ${restartAttempts}/${MAX_RESTART_ATTEMPTS})...`);
+        addNotification('Sidecar crashed', `Restarting (attempt ${restartAttempts}/${MAX_RESTART_ATTEMPTS})`, 'system');
+        await new Promise((resolve) => setTimeout(resolve, delayMs));
+        try {
+          await restartAgent();
+          sidecarAlive = true;
+          // Note: restartAttempts is reset when next sidecar message arrives
+        } catch {
+          if (restartAttempts >= MAX_RESTART_ATTEMPTS) {
+            notify('error', `Sidecar restart failed after ${MAX_RESTART_ATTEMPTS} attempts`);
+          }
+        }
+      } else {
+        notify('error', `Sidecar restart failed after ${MAX_RESTART_ATTEMPTS} attempts`);
+      }
+    } finally {
+      restarting = false;
+    }
+  });
+}
+
+function handleAgentEvent(sessionId: SessionIdType, event: Record<string, unknown>): void {
+  const provider = getSessionProvider(sessionId);
+  const messages = adaptMessage(provider, event);
+
+  // Route messages with parentId to the appropriate child pane
+  const mainMessages: typeof messages = [];
+  const childBuckets = new Map<string, typeof messages>();
+
+  for (const msg of messages) {
+    const childPaneId = msg.parentId ? getChildPaneId(msg.parentId) : undefined;
+    if (childPaneId) {
+      if (!childBuckets.has(childPaneId)) childBuckets.set(childPaneId, []);
+      childBuckets.get(childPaneId)!.push(msg);
+    } else {
+      mainMessages.push(msg);
+    }
+  }
+
+  // Process main session messages
+  for (const msg of mainMessages) {
+    switch (msg.type) {
+      case 'init': {
+        const init = msg.content as InitContent;
+        setAgentSdkSessionId(sessionId, init.sessionId);
+        setAgentModel(sessionId, init.model);
+        // CWD-based worktree detection for conflict suppression
+        if (init.cwd) {
+          const wtPath = detectWorktreeFromCwd(init.cwd);
+          if (wtPath) {
+            setSessionWorktree(sessionId, wtPath);
+          }
+        }
+        break;
+      }
+
+      case 'tool_call': {
+        const tc = msg.content as ToolCallContent;
+        if (isSubagentToolCall(tc.name)) {
+          spawnSubagentPane(sessionId, tc);
+        }
+        // Health: record tool start
+        const projId = getSessionProjectId(sessionId);
+        if (projId) {
+          recordActivity(projId, tc.name);
+          // Worktree tracking
+          const wtPath = extractWorktreePath(tc);
+          if (wtPath) {
+            setSessionWorktree(sessionId, wtPath);
+          }
+          // Conflict detection: track file writes
+          const writePaths = extractWritePaths(tc);
+          for (const filePath of writePaths) {
+            const isNewConflict = recordFileWrite(projId, sessionId, filePath);
+            if (isNewConflict) {
+              const shortName = filePath.split('/').pop() ?? filePath;
+              notify('warning', `File conflict: ${shortName} — multiple agents writing`);
+            }
+          }
+        }
+        break;
+      }
+
+      case 'compaction': {
+        // Auto-anchor on first compaction for this project
+        const compactProjId = getSessionProjectId(sessionId);
+        if (compactProjId && !hasAutoAnchored(compactProjId)) {
+          markAutoAnchored(compactProjId);
+          const session = getAgentSession(sessionId);
+          if (session) {
+            triggerAutoAnchor(compactProjId, session.messages, session.prompt);
+          }
+        }
+        break;
+      }
+
+      case 'cost': {
+        const cost = msg.content as CostContent;
+        updateAgentCost(sessionId, {
+          costUsd: cost.totalCostUsd,
+          inputTokens: cost.inputTokens,
+          outputTokens: cost.outputTokens,
+          numTurns: cost.numTurns,
+          durationMs: cost.durationMs,
+        });
+        tel.info('agent_cost', {
+          sessionId,
+          costUsd: cost.totalCostUsd,
+          inputTokens: cost.inputTokens,
+          outputTokens: cost.outputTokens,
+          numTurns: cost.numTurns,
+          durationMs: cost.durationMs,
+          isError: cost.isError,
+        });
+        if (cost.isError) {
+          const costErrorMsg = cost.errors?.join('; ') ?? 'Unknown error';
+          const costClassified = classifyError(costErrorMsg);
+          updateAgentStatus(sessionId, 'error', costErrorMsg);
+
+          if (costClassified.type === 'rate_limit') {
+            notify('warning', `Rate limited. ${costClassified.retryDelaySec > 0 ? `Retrying in ~${costClassified.retryDelaySec}s...` : ''}`);
+          } else if (costClassified.type === 'auth') {
+            notify('error', 'API key invalid or expired. Check Settings.');
+          } else if (costClassified.type === 'quota') {
+            notify('error', 'API quota exceeded. Check your billing.');
+          } else {
+            notify('error', `Agent failed: ${cost.errors?.[0] ?? 'Unknown error'}`);
+          }
+        } else {
+          updateAgentStatus(sessionId, 'done');
+          notify('success', `Agent done — $${cost.totalCostUsd.toFixed(4)}, ${cost.numTurns} turns`);
+        }
+        // Health: record token snapshot + tool done
+        const costProjId = getSessionProjectId(sessionId);
+        if (costProjId) {
+          recordTokenSnapshot(costProjId, cost.inputTokens + cost.outputTokens, cost.totalCostUsd);
+          recordToolDone(costProjId);
+          // Conflict tracking: clear session writes on completion
+          clearSessionWrites(costProjId, sessionId);
+        }
+        // Persist session state for project-scoped sessions
+        persistSessionForProject(sessionId);
+        break;
+      }
+    }
+  }
+
+  // Health: record general activity for non-tool messages (text, thinking)
+  if (mainMessages.length > 0) {
+    const actProjId = getSessionProjectId(sessionId);
+    if (actProjId) {
+      const hasToolResult = mainMessages.some(m => m.type === 'tool_result');
+      if (hasToolResult) recordToolDone(actProjId);
+      else recordActivity(actProjId);
+    }
+    appendAgentMessages(sessionId, mainMessages);
+
+    // Index searchable text content into FTS5 search database
+    for (const msg of mainMessages) {
+      if (msg.type === 'text' && typeof msg.content === 'string' && msg.content.trim()) {
+        indexMessage(sessionId, 'assistant', msg.content).catch(() => {});
+      }
+    }
+  }
+
+  // Append messages to child panes and update their status
+  for (const [childPaneId, childMsgs] of childBuckets) {
+    for (const msg of childMsgs) {
+      if (msg.type === 'init') {
+        const init = msg.content as InitContent;
+        setAgentSdkSessionId(childPaneId, init.sessionId);
+        setAgentModel(childPaneId, init.model);
+        updateAgentStatus(childPaneId, 'running');
+      } else if (msg.type === 'cost') {
+        const cost = msg.content as CostContent;
+        updateAgentCost(childPaneId, {
+          costUsd: cost.totalCostUsd,
+          inputTokens: cost.inputTokens,
+          outputTokens: cost.outputTokens,
+          numTurns: cost.numTurns,
+          durationMs: cost.durationMs,
+        });
+        updateAgentStatus(childPaneId, cost.isError ? 'error' : 'done');
+      }
+    }
+    appendAgentMessages(childPaneId, childMsgs);
+  }
+}
+
+export function stopAgentDispatcher(): void {
+  if (unlistenMsg) {
+    unlistenMsg();
+    unlistenMsg = null;
+  }
+  if (unlistenExit) {
+    unlistenExit();
+    unlistenExit = null;
+  }
+  // Clear routing maps to prevent unbounded memory growth
+  clearSubagentRoutes();
+  clearSessionMaps();
+}
diff --git a/v2/src/lib/components/Agent/AgentPane.svelte b/v2/src/lib/components/Agent/AgentPane.svelte
new file mode 100644
index 0000000..6031fbc
--- /dev/null
+++ b/v2/src/lib/components/Agent/AgentPane.svelte
@@ -0,0 +1,1556 @@
+<script lang="ts">
+  import { onMount } from 'svelte';
+  import { marked, Renderer } from 'marked';
+  import { queryAgent, stopAgent, isAgentReady, restartAgent } from '../../adapters/agent-bridge';
+  import {
+    getAgentSession,
+    createAgentSession,
+    getChildSessions,
+    getTotalCost,
+  } from '../../stores/agents.svelte';
+  import { focusPane } from '../../stores/layout.svelte';
+  import { isSidecarAlive, setSidecarAlive } from '../../agent-dispatcher';
+  import { listProfiles, listSkills, readSkill, type ClaudeProfile, type ClaudeSkill } from '../../adapters/claude-bridge';
+  import { getInjectableAnchors, getProjectAnchors, addAnchors, removeAnchor } from '../../stores/anchors.svelte';
+  import { estimateTokens } from '../../utils/anchor-serializer';
+  import type { SessionAnchor } from '../../types/anchors';
+
+  import AgentTree from './AgentTree.svelte';
+  import UsageMeter from './UsageMeter.svelte';
+  import { notify } from '../../stores/notifications.svelte';
+  import { getHighlighter, highlightCode, escapeHtml } from '../../utils/highlight';
+  import type {
+    TextContent,
+    ThinkingContent,
+    ToolCallContent,
+    ToolResultContent,
+    CostContent,
+    ErrorContent,
+    StatusContent,
+  } from '../../adapters/claude-messages';
+  import type { ProviderId, ProviderCapabilities } from '../../providers/types';
+
+  // Tool-aware truncation limits
+  const MAX_BASH_LINES = 500;
+  const MAX_READ_LINES = 50;
+  const MAX_GLOB_LINES = 20;
+  const MAX_DEFAULT_LINES = 30;
+
+  // Default capabilities (Claude — all enabled)
+  const DEFAULT_CAPABILITIES: ProviderCapabilities = {
+    hasProfiles: true,
+    hasSkills: true,
+    hasModelSelection: true,
+    hasSandbox: false,
+    supportsSubagents: true,
+    supportsCost: true,
+    supportsResume: true,
+  };
+
+  interface Props {
+    sessionId: string;
+    projectId?: string;
+    prompt?: string;
+    cwd?: string;
+    profile?: string;
+    provider?: ProviderId;
+    capabilities?: ProviderCapabilities;
+    useWorktrees?: boolean;
+    /** Prepended to system_prompt for agent role instructions */
+    agentSystemPrompt?: string;
+    /** Extra env vars injected into agent process (e.g. BTMSG_AGENT_ID) */
+    extraEnv?: Record<string, string>;
+    /** Auto-triggered prompt (e.g. periodic context refresh). Picked up when agent is idle. */
+    autoPrompt?: string;
+    /** Called when autoPrompt has been consumed */
+    onautopromptconsumed?: () => void;
+    onExit?: () => void;
+  }
+
+  let { sessionId, projectId, prompt: initialPrompt = '', cwd: initialCwd, profile: profileName, provider: providerId = 'claude', capabilities = DEFAULT_CAPABILITIES, useWorktrees = false, agentSystemPrompt, extraEnv, autoPrompt, onautopromptconsumed, onExit }: Props = $props();
+
+  let session = $derived(getAgentSession(sessionId));
+  let inputPrompt = $state(initialPrompt);
+  let scrollContainer: HTMLDivElement | undefined = $state();
+  let autoScroll = $state(true);
+  let restarting = $state(false);
+  let showTree = $state(false);
+  let hasToolCalls = $derived(session?.messages.some(m => m.type === 'tool_call') ?? false);
+  let parentSession = $derived(session?.parentSessionId ? getAgentSession(session.parentSessionId) : undefined);
+  let childSessions = $derived(session ? getChildSessions(session.id) : []);
+  let totalCost = $derived(session && childSessions.length > 0 ? getTotalCost(session.id) : null);
+  let isRunning = $derived(session?.status === 'running' || session?.status === 'starting');
+
+  // Tool result map — pairs tool_call with tool_result by toolUseId
+  // Cache guard: only rescan when user-role message count changes (tool_results come in user messages)
+  let _cachedResultMap: Record<string, ToolResultContent> = {};
+  let _cachedUserMsgCount = -1;
+  let toolResultMap = $derived.by((): Record<string, ToolResultContent> => {
+    if (!session) return {};
+    const userMsgCount = session.messages.filter(m => m.type === 'tool_result').length;
+    if (userMsgCount === _cachedUserMsgCount) return _cachedResultMap;
+    const map: Record<string, ToolResultContent> = {};
+    for (const msg of session.messages) {
+      if (msg.type === 'tool_result') {
+        const tr = msg.content as ToolResultContent;
+        map[tr.toolUseId] = tr;
+      }
+    }
+    _cachedUserMsgCount = userMsgCount;
+    _cachedResultMap = map;
+    return map;
+  });
+
+  // Profile list (for resolving profileName to config_dir)
+  let profiles = $state<ClaudeProfile[]>([]);
+
+  // Skill autocomplete
+  let skills = $state<ClaudeSkill[]>([]);
+  let showSkillMenu = $state(false);
+  let filteredSkills = $derived(
+    inputPrompt.startsWith('/')
+      ? skills.filter(s => s.name.toLowerCase().startsWith(inputPrompt.slice(1).toLowerCase()))
+      : []
+  );
+  let skillMenuIndex = $state(0);
+
+  // Track expanded state for tool truncation
+  let expandedTools = $state<Set<string>>(new Set());
+
+  const mdRenderer = new Renderer();
+  mdRenderer.code = function({ text, lang }: { text: string; lang?: string }) {
+    if (lang) {
+      const highlighted = highlightCode(text, lang);
+      if (highlighted !== escapeHtml(text)) return highlighted;
+    }
+    return `<pre><code>${escapeHtml(text)}</code></pre>`;
+  };
+
+  function renderMarkdown(source: string): string {
+    try {
+      return marked.parse(source, { renderer: mdRenderer, async: false }) as string;
+    } catch {
+      return escapeHtml(source);
+    }
+  }
+
+  onMount(async () => {
+    await getHighlighter();
+    // Only load profiles/skills for providers that support them
+    const [profileList, skillList] = await Promise.all([
+      capabilities.hasProfiles ? listProfiles().catch(() => []) : Promise.resolve([]),
+      capabilities.hasSkills ? listSkills().catch(() => []) : Promise.resolve([]),
+    ]);
+    profiles = profileList;
+    skills = skillList;
+    if (initialPrompt) {
+      await startQuery(initialPrompt);
+    }
+  });
+
+  // NOTE: Do NOT stop agents in onDestroy — it fires on layout changes/remounts,
+  // not just explicit close. Stop-on-close is handled by workspace teardown.
+
+  // Auto-prompt: pick up externally triggered prompts (e.g. periodic context refresh)
+  $effect(() => {
+    if (!autoPrompt || isRunning) return;
+    // Only trigger if session exists and is idle (done/error)
+    if (!session || (session.status !== 'done' && session.status !== 'error')) return;
+    const prompt = autoPrompt;
+    onautopromptconsumed?.();
+    startQuery(prompt, true); // resume session with context refresh
+  });
+
+  let promptRef = $state<HTMLTextAreaElement | undefined>();
+
+  async function startQuery(text: string, resume = false) {
+    if (!text.trim()) return;
+
+    const ready = await isAgentReady();
+    if (!ready) {
+      if (!resume) createAgentSession(sessionId, text);
+      const { updateAgentStatus } = await import('../../stores/agents.svelte');
+      updateAgentStatus(sessionId, 'error', 'Sidecar not ready — agent features unavailable');
+      return;
+    }
+
+    const resumeId = resume ? session?.sdkSessionId : undefined;
+
+    if (!resume) {
+      createAgentSession(sessionId, text);
+    } else {
+      const { updateAgentStatus } = await import('../../stores/agents.svelte');
+      updateAgentStatus(sessionId, 'starting');
+    }
+
+    const profile = profileName ? profiles.find(p => p.name === profileName) : undefined;
+
+    // Build system prompt: agent role instructions + anchor re-injection
+    const promptParts: string[] = [];
+    if (agentSystemPrompt) {
+      promptParts.push(agentSystemPrompt);
+    }
+    if (projectId) {
+      const anchors = getInjectableAnchors(projectId);
+      if (anchors.length > 0) {
+        promptParts.push(anchors.map(a => a.content).join('\n'));
+      }
+    }
+    const systemPrompt = promptParts.length > 0 ? promptParts.join('\n\n') : undefined;
+
+    await queryAgent({
+      provider: providerId,
+      session_id: sessionId,
+      prompt: text,
+      cwd: initialCwd || undefined,
+      max_turns: 50,
+      resume_session_id: resumeId,
+      setting_sources: ['user', 'project'],
+      claude_config_dir: profile?.config_dir,
+      system_prompt: systemPrompt,
+      worktree_name: useWorktrees ? sessionId : undefined,
+      extra_env: extraEnv,
+    });
+    inputPrompt = '';
+    if (promptRef) {
+      promptRef.style.height = 'auto';
+    }
+  }
+
+  async function expandSkillPrompt(text: string): Promise<string> {
+    if (!text.startsWith('/')) return text;
+    const skillName = text.slice(1).split(/\s+/)[0];
+    const skill = skills.find(s => s.name === skillName);
+    if (!skill) return text;
+    try {
+      const content = await readSkill(skill.source_path);
+      const args = text.slice(1 + skillName.length).trim();
+      return args ? `${content}\n\nUser input: ${args}` : content;
+    } catch {
+      return text;
+    }
+  }
+
+  async function handleUnifiedSubmit() {
+    if (!inputPrompt.trim() || isRunning) return;
+    const expanded = await expandSkillPrompt(inputPrompt);
+    showSkillMenu = false;
+    const isResume = !!(session?.sdkSessionId && session.messages.length > 0);
+    startQuery(expanded, isResume);
+  }
+
+  function handleNewSession() {
+    onExit?.();
+  }
+
+  function autoResizeTextarea(el: HTMLTextAreaElement) {
+    el.style.height = 'auto';
+    el.style.height = Math.min(el.scrollHeight, 150) + 'px';
+  }
+
+  function handleSkillSelect(skill: ClaudeSkill) {
+    inputPrompt = `/${skill.name} `;
+    showSkillMenu = false;
+  }
+
+  function handleStop() {
+    stopAgent(sessionId).catch(() => {});
+  }
+
+  async function handleRestart() {
+    restarting = true;
+    try {
+      await restartAgent();
+      setSidecarAlive(true);
+    } catch {
+      // Still dead
+    } finally {
+      restarting = false;
+    }
+  }
+
+  function handleScroll() {
+    if (!scrollContainer) return;
+    const { scrollTop, scrollHeight, clientHeight } = scrollContainer;
+    autoScroll = scrollHeight - scrollTop - clientHeight < 50;
+  }
+
+  function handleTreeNodeClick(nodeId: string) {
+    if (!scrollContainer || !session) return;
+    const msg = session.messages.find(
+      m => m.type === 'tool_call' && (m.content as ToolCallContent).toolUseId === nodeId
+    );
+    if (!msg) return;
+    autoScroll = false;
+    scrollContainer.querySelector('#msg-' + CSS.escape(msg.id))?.scrollIntoView({ behavior: 'smooth', block: 'center' });
+  }
+
+  // Scroll anchoring: two-phase pattern
+  let wasNearBottom = true;
+  $effect.pre(() => {
+    if (session?.messages.length !== undefined) {
+      wasNearBottom = scrollContainer
+        ? scrollContainer.scrollTop + scrollContainer.clientHeight >= scrollContainer.scrollHeight - 80
+        : true;
+    }
+  });
+  $effect(() => {
+    if (session?.messages.length !== undefined && wasNearBottom && autoScroll) {
+      scrollContainer?.querySelector('#message-end')?.scrollIntoView({ behavior: 'instant' as ScrollBehavior });
+    }
+  });
+
+  // --- Anchor pinning ---
+  let projectAnchorIds = $derived(
+    projectId ? new Set(getProjectAnchors(projectId).map(a => a.messageId)) : new Set<string>()
+  );
+
+  function isMessagePinned(msgId: string): boolean {
+    return projectAnchorIds.has(msgId);
+  }
+
+  async function togglePin(msgId: string, content: string) {
+    if (!projectId) return;
+    if (isMessagePinned(msgId)) {
+      const anchors = getProjectAnchors(projectId);
+      const anchor = anchors.find(a => a.messageId === msgId);
+      if (anchor) await removeAnchor(projectId, anchor.id);
+    } else {
+      const anchor: SessionAnchor = {
+        id: crypto.randomUUID(),
+        projectId,
+        messageId: msgId,
+        anchorType: 'pinned',
+        content,
+        estimatedTokens: estimateTokens(content),
+        turnIndex: -1, // Manual pins don't track turn index
+        createdAt: Math.floor(Date.now() / 1000),
+      };
+      await addAnchors(projectId, [anchor]);
+    }
+  }
+
+  function formatToolInput(input: unknown): string {
+    if (typeof input === 'string') return input;
+    try {
+      return JSON.stringify(input, null, 2);
+    } catch {
+      return String(input);
+    }
+  }
+
+  /** Get truncation limit for a tool name */
+  function getTruncationLimit(toolName: string): number {
+    const name = toolName.toLowerCase();
+    if (name === 'bash' || name.includes('bash')) return MAX_BASH_LINES;
+    if (name === 'read' || name === 'write' || name === 'edit') return MAX_READ_LINES;
+    if (name === 'glob' || name === 'grep' || name === 'ls') return MAX_GLOB_LINES;
+    return MAX_DEFAULT_LINES;
+  }
+
+  /** Truncate text by lines, return { text, truncated, totalLines } */
+  function truncateByLines(text: string, maxLines: number): { text: string; truncated: boolean; totalLines: number } {
+    const lines = text.split('\n');
+    if (lines.length <= maxLines) return { text, truncated: false, totalLines: lines.length };
+    return { text: lines.slice(0, maxLines).join('\n'), truncated: true, totalLines: lines.length };
+  }
+
+  /** Check if a status message is a hook event */
+  function isHookMessage(content: StatusContent): boolean {
+    return content.subtype === 'hook_started' || content.subtype === 'hook_response';
+  }
+
+  /** Get display name for hook subtype */
+  function hookDisplayName(subtype: string): string {
+    if (subtype === 'hook_started') return 'Hook started';
+    if (subtype === 'hook_response') return 'Hook response';
+    return subtype;
+  }
+
+  // Context meter: estimate percentage of context window used
+  const DEFAULT_CONTEXT_LIMIT = 200_000;
+  let contextPercent = $derived.by(() => {
+    if (!session) return 0;
+    const totalTokens = session.inputTokens + session.outputTokens;
+    if (totalTokens === 0) return 0;
+    return Math.min(100, Math.round((totalTokens / DEFAULT_CONTEXT_LIMIT) * 100));
+  });
+
+  // Context meter color class based on thresholds
+  let contextColorClass = $derived.by(() => {
+    if (contextPercent >= 90) return 'context-critical';
+    if (contextPercent >= 75) return 'context-high';
+    if (contextPercent >= 50) return 'context-medium';
+    return '';
+  });
+
+  // Session burn rate ($/hr)
+  let burnRatePerHr = $derived.by(() => {
+    if (!session || session.durationMs <= 0 || session.costUsd <= 0) return 0;
+    return (session.costUsd / session.durationMs) * 3_600_000;
+  });
+
+  // 90% context warning (fire once per session)
+  let contextWarningFired = $state(false);
+  $effect(() => {
+    if (contextPercent >= 90 && !contextWarningFired && session?.status === 'running') {
+      contextWarningFired = true;
+      notify('warning', `Context usage at ${contextPercent}% — approaching model limit`);
+    }
+  });
+  // Reset warning tracker when session changes
+  $effect(() => {
+    if (session?.id) {
+      contextWarningFired = false;
+    }
+  });
+</script>
+
+<div class="agent-pane" data-testid="agent-pane" data-agent-status={session?.status ?? 'idle'}>
+  {#if parentSession}
+    <div class="parent-link">
+      <span class="parent-badge">SUB</span>
+      <button class="parent-btn" onclick={() => focusPane(parentSession!.id)}>
+        ← {parentSession.prompt ? parentSession.prompt.slice(0, 40) : 'Parent agent'}
+      </button>
+    </div>
+  {/if}
+  {#if childSessions.length > 0}
+    <div class="children-bar">
+      <span class="children-label">{childSessions.length} subagent{childSessions.length > 1 ? 's' : ''}</span>
+      {#each childSessions as child (child.id)}
+        <button class="child-chip" class:running={child.status === 'running'} class:done={child.status === 'done'} class:error={child.status === 'error'} onclick={() => focusPane(child.id)}>
+          {child.prompt.slice(0, 20)}{child.prompt.length > 20 ? '...' : ''}
+        </button>
+      {/each}
+    </div>
+  {/if}
+  {#if hasToolCalls}
+    <div class="tree-toggle">
+      <button class="tree-btn" onclick={() => showTree = !showTree}>
+        {showTree ? '▼' : '▶'} Agent Tree
+      </button>
+    </div>
+    {#if showTree && session}
+      <AgentTree {session} onNodeClick={handleTreeNodeClick} />
+    {/if}
+  {/if}
+
+  <div class="agent-pane-scroll" data-testid="agent-messages" bind:this={scrollContainer} onscroll={handleScroll}>
+    {#if !session || session.messages.length === 0}
+      <div class="welcome-state">
+        <div class="welcome-icon">
+          <svg width="32" height="32" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round">
+            <path d="M21 15a2 2 0 0 1-2 2H7l-4 4V5a2 2 0 0 1 2-2h14a2 2 0 0 1 2 2z"></path>
+          </svg>
+        </div>
+        <span class="welcome-text">Ask Claude anything</span>
+        <span class="welcome-hint">Type / for skills • Shift+Enter for newline</span>
+      </div>
+    {:else}
+      {#each session.messages as msg (msg.id)}
+        <div class="message msg-{msg.type}" id="msg-{msg.id}">
+          {#if msg.type === 'init'}
+            <div class="msg-init">
+              <span class="label">Session started</span>
+              <span class="model">{(msg.content as import('../../adapters/claude-messages').InitContent).model}</span>
+            </div>
+          {:else if msg.type === 'text'}
+            {@const textContent = (msg.content as TextContent).text}
+            {@const firstLine = textContent.split('\n')[0].slice(0, 120)}
+            <details class="msg-text-collapsible" open>
+              <summary>
+                <span class="chevron" aria-hidden="true">▶</span>
+                <span class="text-preview">{firstLine}{firstLine.length >= 120 ? '...' : ''}</span>
+                {#if projectId}
+                  <button
+                    class="pin-btn"
+                    class:pinned={isMessagePinned(msg.id)}
+                    title={isMessagePinned(msg.id) ? 'Unpin message' : 'Pin as anchor'}
+                    onclick={(e: MouseEvent) => { e.stopPropagation(); togglePin(msg.id, textContent); }}
+                    aria-label={isMessagePinned(msg.id) ? 'Unpin message' : 'Pin as anchor'}
+                  >
+                    <svg width="12" height="12" viewBox="0 0 24 24" fill={isMessagePinned(msg.id) ? 'currentColor' : 'none'} stroke="currentColor" stroke-width="2">
+                      <path d="M12 2L12 12M12 12L8 8M12 12L16 8M5 21L12 15L19 21" />
+                    </svg>
+                  </button>
+                {/if}
+              </summary>
+              <div class="msg-text markdown-body">{@html renderMarkdown(textContent)}</div>
+            </details>
+          {:else if msg.type === 'thinking'}
+            <details class="msg-thinking">
+              <summary><span class="chevron" aria-hidden="true">▶</span> Thinking...</summary>
+              <pre>{(msg.content as ThinkingContent).text}</pre>
+            </details>
+          {:else if msg.type === 'tool_call'}
+            {@const tc = msg.content as ToolCallContent}
+            {@const pairedResult = toolResultMap[tc.toolUseId]}
+            <details class="msg-tool-group">
+              <summary>
+                <span class="chevron" aria-hidden="true">▶</span>
+                <span class="tool-name">{tc.name}</span>
+                {#if pairedResult}
+                  <span class="tool-status tool-status--done">✓</span>
+                {:else if isRunning}
+                  <span class="tool-status tool-status--pending">⋯</span>
+                {/if}
+              </summary>
+              <div class="tool-group-body">
+                <div class="tool-section">
+                  <div class="tool-section-label">Input</div>
+                  <pre class="tool-input">{formatToolInput(tc.input)}</pre>
+                </div>
+                {#if pairedResult}
+                  {@const outputStr = formatToolInput(pairedResult.output)}
+                  {@const limit = getTruncationLimit(tc.name)}
+                  {@const truncated = truncateByLines(outputStr, limit)}
+                  <div class="tool-section">
+                    <div class="tool-section-label">Output</div>
+                    {#if truncated.truncated && !expandedTools.has(tc.toolUseId)}
+                      <pre class="tool-output">{truncated.text}</pre>
+                      <button class="truncation-btn" onclick={() => { expandedTools = new Set([...expandedTools, tc.toolUseId]); }}>
+                        Show all ({truncated.totalLines} lines)
+                      </button>
+                    {:else}
+                      <pre class="tool-output">{outputStr}</pre>
+                    {/if}
+                  </div>
+                {:else if isRunning}
+                  <div class="tool-pending" role="status">
+                    <span aria-hidden="true">⋯</span>
+                    <span class="sr-only">Awaiting tool result</span>
+                  </div>
+                {/if}
+              </div>
+            </details>
+          {:else if msg.type === 'tool_result'}
+            <!-- Tool results rendered inline with their tool_call above; skip standalone rendering -->
+          {:else if msg.type === 'cost'}
+            {@const cost = msg.content as CostContent}
+            <div class="msg-cost">
+              <span class="cost-value">${cost.totalCostUsd.toFixed(4)}</span>
+              <span class="cost-detail">{cost.inputTokens + cost.outputTokens} tokens</span>
+              <span class="cost-detail">{cost.numTurns} turns</span>
+              <span class="cost-detail">{(cost.durationMs / 1000).toFixed(1)}s</span>
+            </div>
+            {#if cost.result}
+              <details class="msg-summary-collapsible">
+                <summary>
+                  <span class="chevron" aria-hidden="true">▶</span>
+                  <span class="summary-preview">{cost.result.split('\n')[0].slice(0, 80)}{cost.result.length > 80 ? '...' : ''}</span>
+                </summary>
+                <div class="msg-summary">{cost.result}</div>
+              </details>
+            {/if}
+          {:else if msg.type === 'error'}
+            <div class="msg-error">{(msg.content as ErrorContent).message}</div>
+          {:else if msg.type === 'status'}
+            {@const statusContent = msg.content as StatusContent}
+            {#if isHookMessage(statusContent)}
+              <details class="msg-hook">
+                <summary><span class="chevron" aria-hidden="true">▶</span> <span class="hook-icon">⚙</span> {hookDisplayName(statusContent.subtype)}</summary>
+                <pre>{statusContent.message || JSON.stringify(msg.content, null, 2)}</pre>
+              </details>
+            {:else}
+              <div class="msg-status">{statusContent.message || statusContent.subtype}</div>
+            {/if}
+          {/if}
+        </div>
+      {/each}
+      <div id="message-end"></div>
+    {/if}
+  </div>
+
+  <!-- Context meter + status strip -->
+  {#if session}
+    <div class="status-strip">
+      {#if session.status === 'running' || session.status === 'starting'}
+        <div class="running-indicator">
+          <span class="pulse"></span>
+          <span>Running...</span>
+          {#if capabilities.supportsCost && (session.inputTokens > 0 || session.outputTokens > 0)}
+            <UsageMeter inputTokens={session.inputTokens} outputTokens={session.outputTokens} contextLimit={DEFAULT_CONTEXT_LIMIT} />
+          {:else if contextPercent > 0}
+            <span class="context-meter {contextColorClass}" title="Context window usage">
+              <span class="context-fill context-streaming" style="width: {contextPercent}%"></span>
+              <span class="context-label">{contextPercent}%</span>
+            </span>
+          {/if}
+          {#if burnRatePerHr > 0}
+            <span class="burn-rate" title="Current session burn rate">${burnRatePerHr.toFixed(2)}/hr</span>
+          {/if}
+          {#if !autoScroll}
+            <button class="scroll-btn" onclick={() => { autoScroll = true; scrollContainer?.querySelector('#message-end')?.scrollIntoView({ behavior: 'instant' as ScrollBehavior }); }}>↓ Bottom</button>
+          {/if}
+          <button class="stop-btn" data-testid="agent-stop" onclick={handleStop}>Stop</button>
+        </div>
+      {:else if session.status === 'done'}
+        <div class="done-bar">
+          <span class="cost-value">${session.costUsd.toFixed(4)}</span>
+          {#if totalCost && totalCost.costUsd > session.costUsd}
+            <span class="total-cost">(total: ${totalCost.costUsd.toFixed(4)})</span>
+          {/if}
+          {#if capabilities.supportsCost}
+            <span class="cost-detail token-in" title="Input tokens">{session.inputTokens.toLocaleString()} in</span>
+            <span class="cost-detail token-out" title="Output tokens">{session.outputTokens.toLocaleString()} out</span>
+          {:else}
+            <span class="cost-detail">{session.inputTokens + session.outputTokens} tok</span>
+          {/if}
+          <span class="cost-detail">{(session.durationMs / 1000).toFixed(1)}s</span>
+          {#if burnRatePerHr > 0}
+            <span class="burn-rate" title="Session average burn rate">${burnRatePerHr.toFixed(2)}/hr</span>
+          {/if}
+          <UsageMeter inputTokens={session.inputTokens} outputTokens={session.outputTokens} contextLimit={DEFAULT_CONTEXT_LIMIT} />
+          {#if !autoScroll}
+            <button class="scroll-btn" onclick={() => { autoScroll = true; scrollContainer?.querySelector('#message-end')?.scrollIntoView({ behavior: 'instant' as ScrollBehavior }); }}>↓ Bottom</button>
+          {/if}
+        </div>
+      {:else if session.status === 'error'}
+        <div class="error-bar">
+          <span>Error: {session.error ?? 'Unknown'}</span>
+          {#if session.error?.includes('Sidecar') || session.error?.includes('crashed')}
+            <button class="restart-btn" onclick={handleRestart} disabled={restarting}>
+              {restarting ? 'Restarting...' : 'Restart Sidecar'}
+            </button>
+          {/if}
+        </div>
+      {/if}
+    </div>
+  {/if}
+
+  <!-- Session controls (new / continue) -->
+  {#if session && (session.status === 'done' || session.status === 'error') && session.sdkSessionId}
+    <div class="session-controls">
+      <button class="session-btn session-btn-new" onclick={handleNewSession}>
+        <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+          <line x1="12" y1="5" x2="12" y2="19"></line>
+          <line x1="5" y1="12" x2="19" y2="12"></line>
+        </svg>
+        New Session
+      </button>
+      {#if capabilities.supportsResume}
+        <button class="session-btn session-btn-continue" onclick={() => promptRef?.focus()}>
+          <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+            <polyline points="9 18 15 12 9 6"></polyline>
+          </svg>
+          Continue
+        </button>
+      {/if}
+    </div>
+  {/if}
+
+  <!-- Unified prompt input -->
+  <div class="prompt-container" class:disabled={isRunning}>
+    <div class="prompt-wrapper">
+      {#if capabilities.hasSkills && showSkillMenu && filteredSkills.length > 0}
+        <div class="skill-menu">
+          {#each filteredSkills as skill, i (skill.name)}
+            <button
+              class="skill-item"
+              class:active={i === skillMenuIndex}
+              onmousedown={(e) => { e.preventDefault(); handleSkillSelect(skill); }}
+            >
+              <span class="skill-name">/{skill.name}</span>
+              <span class="skill-desc">{skill.description}</span>
+            </button>
+          {/each}
+        </div>
+      {/if}
+      <textarea
+        bind:this={promptRef}
+        bind:value={inputPrompt}
+        placeholder={isRunning ? 'Agent is running...' : 'Ask Claude something... (/ for skills)'}
+        class="prompt-input"
+        data-testid="agent-prompt"
+        rows="1"
+        disabled={isRunning}
+        oninput={(e) => {
+          showSkillMenu = inputPrompt.startsWith('/') && filteredSkills.length > 0;
+          skillMenuIndex = 0;
+          autoResizeTextarea(e.currentTarget as HTMLTextAreaElement);
+        }}
+        onkeydown={async (e) => {
+          if (showSkillMenu && filteredSkills.length > 0) {
+            if (e.key === 'ArrowDown') {
+              e.preventDefault();
+              skillMenuIndex = Math.min(skillMenuIndex + 1, filteredSkills.length - 1);
+              return;
+            }
+            if (e.key === 'ArrowUp') {
+              e.preventDefault();
+              skillMenuIndex = Math.max(skillMenuIndex - 1, 0);
+              return;
+            }
+            if (e.key === 'Tab' || (e.key === 'Enter' && !e.shiftKey)) {
+              e.preventDefault();
+              handleSkillSelect(filteredSkills[skillMenuIndex]);
+              return;
+            }
+            if (e.key === 'Escape') {
+              showSkillMenu = false;
+              return;
+            }
+          }
+          if (e.key === 'Enter' && !e.shiftKey) {
+            e.preventDefault();
+            handleUnifiedSubmit();
+          }
+        }}
+      ></textarea>
+      <button
+        class="submit-icon-btn"
+        data-testid="agent-submit"
+        onclick={handleUnifiedSubmit}
+        disabled={!inputPrompt.trim() || isRunning}
+        aria-label="Send message"
+      >
+        <svg width="16" height="16" viewBox="0 0 24 24" fill="currentColor">
+          <path d="M3.478 2.405a.75.75 0 0 0-.926.94l2.432 7.905H13.5a.75.75 0 0 1 0 1.5H4.984l-2.432 7.905a.75.75 0 0 0 .926.94 60.519 60.519 0 0 0 18.445-8.986.75.75 0 0 0 0-1.218A60.517 60.517 0 0 0 3.478 2.405Z" />
+        </svg>
+      </button>
+    </div>
+  </div>
+</div>
+
+<style>
+  /* === Root === */
+  .agent-pane {
+    display: flex;
+    flex-direction: column;
+    height: 100%;
+    background: var(--ctp-base);
+    color: var(--ctp-text);
+    font-family: system-ui, -apple-system, sans-serif;
+    font-size: 0.875rem;
+    line-height: 1.6;
+  }
+
+  /* === Scroll wrapper with container queries === */
+  .agent-pane-scroll {
+    flex: 1;
+    overflow-y: auto;
+    container-type: inline-size;
+    padding: 0.5rem var(--bterminal-pane-padding-inline, 0.75rem);
+    display: flex;
+    flex-direction: column;
+    gap: 0.125rem;
+    min-height: 0;
+  }
+
+  /* === Screen reader only === */
+  .sr-only {
+    position: absolute;
+    width: 1px;
+    height: 1px;
+    padding: 0;
+    margin: -1px;
+    overflow: hidden;
+    clip: rect(0, 0, 0, 0);
+    white-space: nowrap;
+    border-width: 0;
+  }
+
+  /* === Subagent bars === */
+  .parent-link {
+    display: flex;
+    align-items: center;
+    gap: 0.375rem;
+    padding: 0.25rem 0.75rem;
+    border-bottom: 1px solid var(--ctp-surface0);
+    flex-shrink: 0;
+    font-size: 0.75rem;
+  }
+
+  .parent-badge {
+    background: var(--ctp-mauve);
+    color: var(--ctp-crust);
+    padding: 0.0625rem 0.3125rem;
+    border-radius: 0.1875rem;
+    font-size: 0.625rem;
+    font-weight: 700;
+    letter-spacing: 0.03em;
+  }
+
+  .parent-btn {
+    background: none;
+    border: none;
+    color: var(--ctp-mauve);
+    cursor: pointer;
+    font-size: 0.75rem;
+    padding: 0;
+    font-family: inherit;
+  }
+
+  .parent-btn:hover { color: var(--ctp-text); text-decoration: underline; }
+
+  .children-bar {
+    display: flex;
+    align-items: center;
+    gap: 0.25rem;
+    padding: 0.25rem 0.75rem;
+    border-bottom: 1px solid var(--ctp-surface0);
+    flex-shrink: 0;
+    flex-wrap: wrap;
+    font-size: 0.75rem;
+  }
+
+  .children-label {
+    color: var(--ctp-overlay0);
+    font-size: 0.6875rem;
+    margin-right: 0.25rem;
+  }
+
+  .child-chip {
+    background: var(--ctp-surface0);
+    border: 1px solid var(--ctp-surface1);
+    color: var(--ctp-subtext0);
+    padding: 0.0625rem 0.375rem;
+    border-radius: 0.1875rem;
+    font-size: 0.6875rem;
+    cursor: pointer;
+    font-family: inherit;
+  }
+
+  .child-chip:hover { color: var(--ctp-text); border-color: var(--accent); }
+  .child-chip.running { border-color: var(--ctp-blue); color: var(--ctp-blue); }
+  .child-chip.done { border-color: var(--ctp-green); color: var(--ctp-green); }
+  .child-chip.error { border-color: var(--ctp-red); color: var(--ctp-red); }
+
+  .tree-toggle {
+    padding: 0.25rem 0.75rem;
+    border-bottom: 1px solid var(--ctp-surface0);
+    flex-shrink: 0;
+  }
+
+  .tree-btn {
+    background: none;
+    border: none;
+    color: var(--ctp-mauve);
+    font-size: 0.75rem;
+    cursor: pointer;
+    font-family: var(--term-font-family, monospace);
+    padding: 0.125rem 0.25rem;
+  }
+
+  .tree-btn:hover { color: var(--ctp-text); }
+
+  /* === Welcome state === */
+  .welcome-state {
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    justify-content: center;
+    height: 100%;
+    gap: 0.5rem;
+    color: var(--ctp-overlay1);
+  }
+
+  .welcome-icon { color: var(--ctp-overlay0); opacity: 0.6; }
+  .welcome-text { font-size: 0.9375rem; font-weight: 500; color: var(--ctp-subtext1); }
+  .welcome-hint { font-size: 0.75rem; color: var(--ctp-overlay0); }
+
+  /* === Messages === */
+  .message { padding: 0.1875rem 0; }
+
+  .msg-init {
+    display: flex;
+    align-items: center;
+    gap: 0.5rem;
+    color: var(--ctp-overlay0);
+    font-size: 0.75rem;
+  }
+
+  .msg-init .model {
+    background: var(--ctp-surface0);
+    padding: 0.0625rem 0.375rem;
+    border-radius: 0.1875rem;
+    font-family: var(--term-font-family, monospace);
+    font-size: 0.6875rem;
+  }
+
+  /* === Text collapsible wrapper === */
+  .msg-text-collapsible summary {
+    color: var(--ctp-subtext0);
+    font-size: 0.8125rem;
+  }
+
+  .msg-text-collapsible summary .text-preview {
+    color: var(--ctp-subtext1);
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+    flex: 1;
+    min-width: 0;
+  }
+
+  .msg-text-collapsible[open] > summary .text-preview {
+    display: none;
+  }
+
+  /* === Pin button === */
+  .pin-btn {
+    opacity: 0;
+    background: none;
+    border: none;
+    padding: 0.125em 0.25em;
+    cursor: pointer;
+    color: var(--ctp-overlay0);
+    transition: opacity 0.15s, color 0.15s;
+    flex-shrink: 0;
+    line-height: 1;
+  }
+
+  .pin-btn.pinned {
+    opacity: 1;
+    color: var(--ctp-yellow);
+  }
+
+  .msg-text-collapsible summary:hover .pin-btn,
+  .pin-btn:focus-visible {
+    opacity: 1;
+  }
+
+  .pin-btn:hover {
+    color: var(--ctp-yellow);
+  }
+
+  /* === Text messages (markdown) === */
+  .msg-text {
+    word-break: break-word;
+    line-height: 1.65;
+  }
+
+  .msg-text.markdown-body :global(h1) {
+    font-size: 1.4em;
+    font-weight: 700;
+    margin: 0.75em 0 0.35em;
+    color: var(--ctp-lavender);
+    line-height: 1.25;
+  }
+
+  .msg-text.markdown-body :global(h2) {
+    font-size: 1.2em;
+    font-weight: 600;
+    margin: 0.6em 0 0.3em;
+    color: var(--ctp-blue);
+    line-height: 1.3;
+  }
+
+  .msg-text.markdown-body :global(h3) {
+    font-size: 1.05em;
+    font-weight: 600;
+    margin: 0.5em 0 0.25em;
+    color: var(--ctp-sapphire);
+  }
+
+  .msg-text.markdown-body :global(p) { margin: 0.5em 0; }
+
+  .msg-text.markdown-body :global(code) {
+    background: var(--ctp-surface0);
+    padding: 0.1em 0.3em;
+    border-radius: 0.2em;
+    font-family: var(--term-font-family, monospace);
+    font-size: 0.85em;
+    color: var(--ctp-green);
+  }
+
+  .msg-text.markdown-body :global(pre) {
+    background: var(--ctp-mantle);
+    padding: 0.75rem 0.875rem;
+    border-radius: 0.25rem;
+    border: 1px solid var(--ctp-surface0);
+    overflow-x: auto;
+    font-size: 0.8rem;
+    line-height: 1.5;
+    margin: 0.625em 0;
+    direction: ltr;
+    unicode-bidi: embed;
+  }
+
+  .msg-text.markdown-body :global(pre code) {
+    background: none;
+    padding: 0;
+    color: var(--ctp-text);
+    font-size: inherit;
+  }
+
+  .msg-text.markdown-body :global(.shiki) {
+    background: var(--ctp-mantle) !important;
+    padding: 0.75rem 0.875rem;
+    border-radius: 0.25rem;
+    border: 1px solid var(--ctp-surface0);
+    overflow-x: auto;
+    font-size: 0.8rem;
+    line-height: 1.5;
+    margin: 0.625em 0;
+  }
+
+  .msg-text.markdown-body :global(.shiki code) {
+    background: none !important;
+    padding: 0;
+  }
+
+  .msg-text.markdown-body :global(blockquote) {
+    border-left: 3px solid var(--ctp-mauve);
+    margin: 0.5em 0;
+    padding: 0.125rem 0.75rem;
+    color: var(--ctp-subtext0);
+    background: color-mix(in srgb, var(--ctp-surface0) 20%, transparent);
+    border-radius: 0 0.25rem 0.25rem 0;
+  }
+
+  .msg-text.markdown-body :global(ul), .msg-text.markdown-body :global(ol) {
+    padding-left: 1.5rem;
+    margin: 0.4em 0;
+  }
+
+  .msg-text.markdown-body :global(li) { margin: 0.2em 0; }
+
+  .msg-text.markdown-body :global(a) { color: var(--ctp-blue); text-decoration: none; }
+  .msg-text.markdown-body :global(a:hover) { text-decoration: underline; }
+
+  .msg-text.markdown-body :global(table) {
+    border-collapse: collapse;
+    width: 100%;
+    margin: 0.5em 0;
+    font-size: 0.8rem;
+  }
+
+  .msg-text.markdown-body :global(th), .msg-text.markdown-body :global(td) {
+    border: 1px solid var(--ctp-surface0);
+    padding: 0.25rem 0.5rem;
+    text-align: left;
+  }
+
+  .msg-text.markdown-body :global(th) {
+    background: var(--ctp-surface0);
+    font-weight: 600;
+  }
+
+  /* === Shared collapsible styles === */
+  .chevron {
+    display: inline-block;
+    font-size: 0.625rem;
+    transition: transform 0.15s ease;
+    margin-right: 0.25rem;
+  }
+
+  details[open] > summary > .chevron {
+    transform: rotate(90deg);
+  }
+
+  details summary {
+    cursor: pointer;
+    list-style: none;
+    display: flex;
+    align-items: center;
+    gap: 0.25rem;
+  }
+
+  details summary::-webkit-details-marker { display: none; }
+
+  details summary:focus-visible {
+    outline: 0.125rem solid var(--ctp-blue);
+    outline-offset: 0.125rem;
+    border-radius: 0.25rem;
+  }
+
+  /* === Thinking === */
+  .msg-thinking {
+    color: var(--ctp-overlay1);
+    font-size: 0.8125rem;
+  }
+
+  .msg-thinking summary {
+    color: color-mix(in srgb, var(--ctp-mauve) 65%, var(--ctp-surface1) 35%);
+    font-size: 0.8125rem;
+  }
+
+  .msg-thinking pre {
+    margin: 0.25rem 0 0 1rem;
+    white-space: pre-wrap;
+    font-size: 0.75rem;
+    font-family: var(--term-font-family, monospace);
+    max-height: 12.5rem;
+    overflow-y: auto;
+    direction: ltr;
+    unicode-bidi: embed;
+  }
+
+  /* === Tool groups (paired call + result) === */
+  .msg-tool-group {
+    border-left: 2px solid color-mix(in srgb, var(--ctp-blue) 50%, var(--ctp-surface1) 50%);
+    padding-left: 0.625rem;
+    font-size: 0.8125rem;
+  }
+
+  .msg-tool-group summary {
+    color: var(--ctp-subtext0);
+  }
+
+  .tool-name {
+    font-weight: 600;
+    font-family: var(--term-font-family, monospace);
+    font-size: 0.75rem;
+    color: color-mix(in srgb, var(--ctp-green) 65%, var(--ctp-surface1) 35%);
+  }
+
+  .tool-status {
+    font-size: 0.6875rem;
+    margin-left: 0.25rem;
+  }
+
+  .tool-status--done { color: color-mix(in srgb, var(--ctp-green) 65%, var(--ctp-surface1) 35%); }
+  .tool-status--pending { color: var(--ctp-overlay0); animation: pulse 1.5s ease-in-out infinite; }
+
+  .tool-group-body {
+    margin-top: 0.25rem;
+    display: flex;
+    flex-direction: column;
+    gap: 0.25rem;
+  }
+
+  .tool-section-label {
+    font-size: 0.6875rem;
+    font-weight: 500;
+    color: var(--ctp-overlay0);
+    text-transform: uppercase;
+    letter-spacing: 0.04em;
+    margin-bottom: 0.125rem;
+  }
+
+  .tool-input, .tool-output {
+    margin: 0;
+    white-space: pre-wrap;
+    font-size: 0.75rem;
+    font-family: var(--term-font-family, monospace);
+    max-height: 18.75rem;
+    overflow-y: auto;
+    background: var(--ctp-mantle);
+    padding: 0.375rem 0.5rem;
+    border-radius: 0.1875rem;
+    color: var(--ctp-subtext0);
+    border: 1px solid var(--ctp-surface0);
+    direction: ltr;
+    unicode-bidi: embed;
+  }
+
+  .tool-pending {
+    color: var(--ctp-overlay0);
+    font-size: 0.75rem;
+    padding: 0.25rem 0;
+    animation: pulse 1.5s ease-in-out infinite;
+  }
+
+  .truncation-btn {
+    background: none;
+    border: none;
+    color: var(--ctp-blue);
+    font-size: 0.6875rem;
+    cursor: pointer;
+    padding: 0.125rem 0;
+    font-family: inherit;
+  }
+
+  .truncation-btn:hover { text-decoration: underline; }
+
+  /* === Hook messages === */
+  .msg-hook {
+    font-size: 0.75rem;
+    color: var(--ctp-overlay0);
+  }
+
+  .msg-hook summary {
+    color: var(--ctp-overlay1);
+    font-size: 0.75rem;
+  }
+
+  .hook-icon { opacity: 0.7; }
+
+  .msg-hook pre {
+    margin: 0.25rem 0 0 1rem;
+    white-space: pre-wrap;
+    font-size: 0.6875rem;
+    font-family: var(--term-font-family, monospace);
+    color: var(--ctp-overlay0);
+    max-height: 6.25rem;
+    overflow-y: auto;
+    direction: ltr;
+    unicode-bidi: embed;
+  }
+
+  /* === Cost message (inline in chat) === */
+  .msg-cost {
+    display: flex;
+    gap: 0.625rem;
+    padding: 0.25rem 0;
+    font-size: 0.8125rem;
+    color: var(--ctp-subtext0);
+    border-top: 1px solid var(--ctp-surface1);
+    align-items: baseline;
+  }
+
+  .cost-value {
+    font-family: var(--term-font-family, monospace);
+    font-size: 0.75rem;
+    color: var(--ctp-subtext1);
+  }
+
+  .cost-detail {
+    font-size: 0.6875rem;
+    color: var(--ctp-overlay0);
+  }
+
+  /* === Session summary (collapsible) === */
+  .msg-summary-collapsible {
+    font-size: 0.8125rem;
+  }
+
+  .msg-summary-collapsible summary {
+    color: var(--ctp-overlay1);
+    font-size: 0.75rem;
+  }
+
+  .msg-summary-collapsible summary .summary-preview {
+    color: var(--ctp-overlay0);
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+    flex: 1;
+    min-width: 0;
+  }
+
+  .msg-summary-collapsible[open] > summary .summary-preview {
+    display: none;
+  }
+
+  .msg-summary {
+    background: color-mix(in srgb, var(--ctp-surface0) 60%, var(--ctp-base) 40%);
+    border-top: 0.125rem solid var(--ctp-surface2);
+    padding: 0.5rem 0.625rem;
+    border-radius: 0 0 0.25rem 0.25rem;
+    font-size: 0.8125rem;
+    line-height: 1.5;
+    color: var(--ctp-subtext1);
+  }
+
+  /* === Error === */
+  .msg-error {
+    color: var(--ctp-red);
+    background: color-mix(in srgb, var(--ctp-red) 10%, transparent);
+    padding: 0.375rem 0.5rem;
+    border-radius: 0.1875rem;
+    font-size: 0.8125rem;
+  }
+
+  /* === Status (non-hook) === */
+  .msg-status {
+    color: var(--ctp-overlay0);
+    font-size: 0.75rem;
+    font-style: italic;
+  }
+
+  /* === Status strip === */
+  .status-strip {
+    padding: 0.25rem var(--bterminal-pane-padding-inline, 0.75rem);
+    border-top: 1px solid var(--ctp-surface1);
+    flex-shrink: 0;
+    font-size: 0.8125rem;
+  }
+
+  .running-indicator {
+    display: flex;
+    align-items: center;
+    gap: 0.5rem;
+    font-size: 0.8125rem;
+    color: var(--ctp-subtext0);
+  }
+
+  .pulse {
+    width: 8px;
+    height: 8px;
+    border-radius: 50%;
+    background: var(--ctp-blue);
+    animation: pulse 1.5s ease-in-out infinite;
+  }
+
+  @keyframes pulse {
+    0%, 100% { opacity: 1; }
+    50% { opacity: 0.3; }
+  }
+
+  /* === Context meter === */
+  .context-meter {
+    position: relative;
+    width: 3.5rem;
+    height: 0.375rem;
+    background: var(--ctp-surface0);
+    border-radius: 0.1875rem;
+    overflow: hidden;
+    display: inline-flex;
+    align-items: center;
+  }
+
+  .context-fill {
+    position: absolute;
+    left: 0;
+    top: 0;
+    height: 100%;
+    background: var(--ctp-blue);
+    border-radius: 0.1875rem;
+    transition: width 0.3s ease;
+  }
+
+  .context-fill.context-streaming {
+    animation: ctx-pulse 1.2s ease-in-out infinite;
+  }
+
+  @keyframes ctx-pulse {
+    0%, 100% { opacity: 1; }
+    50% { opacity: 0.6; }
+  }
+
+  .context-label {
+    position: relative;
+    z-index: 1;
+    font-size: 0.5rem;
+    font-family: var(--term-font-family, monospace);
+    color: var(--ctp-text);
+    width: 100%;
+    text-align: center;
+    line-height: 0.375rem;
+  }
+
+  .stop-btn {
+    margin-left: auto;
+    background: var(--ctp-red);
+    color: var(--ctp-crust);
+    border: none;
+    border-radius: 0.1875rem;
+    padding: 0.125rem 0.625rem;
+    font-size: 0.6875rem;
+    cursor: pointer;
+  }
+
+  .stop-btn:hover { opacity: 0.9; }
+
+  .scroll-btn {
+    background: var(--ctp-surface0);
+    border: 1px solid var(--ctp-surface1);
+    color: var(--ctp-subtext0);
+    border-radius: 0.1875rem;
+    padding: 0.125rem 0.5rem;
+    font-size: 0.625rem;
+    cursor: pointer;
+  }
+
+  .scroll-btn:hover { color: var(--ctp-text); }
+
+  .restart-btn {
+    margin-left: auto;
+    background: var(--ctp-peach);
+    color: var(--ctp-crust);
+    border: none;
+    border-radius: 0.1875rem;
+    padding: 0.125rem 0.625rem;
+    font-size: 0.6875rem;
+    cursor: pointer;
+  }
+
+  .restart-btn:hover { opacity: 0.9; }
+  .restart-btn:disabled { opacity: 0.4; cursor: not-allowed; }
+
+  .done-bar, .error-bar {
+    display: flex;
+    gap: 0.625rem;
+    font-size: 0.8125rem;
+    align-items: center;
+  }
+
+  .done-bar { color: var(--ctp-subtext0); }
+  .total-cost { color: var(--ctp-overlay1); font-size: 0.6875rem; }
+  .error-bar { color: var(--ctp-red); }
+
+  .burn-rate {
+    font-size: 0.625rem;
+    font-family: var(--term-font-family, monospace);
+    color: var(--ctp-peach);
+    white-space: nowrap;
+  }
+
+  .token-in { color: var(--ctp-blue); }
+  .token-out { color: var(--ctp-green); }
+
+  /* Context meter threshold colors */
+  .context-medium .context-fill { background: var(--ctp-yellow); }
+  .context-high .context-fill { background: var(--ctp-peach); }
+  .context-critical .context-fill { background: var(--ctp-red); }
+
+  /* === Session controls === */
+  .session-controls {
+    display: flex;
+    gap: 0.5rem;
+    padding: 0.375rem var(--bterminal-pane-padding-inline, 0.75rem);
+    justify-content: center;
+    flex-shrink: 0;
+  }
+
+  .session-btn {
+    display: inline-flex;
+    align-items: center;
+    gap: 0.375rem;
+    padding: 0.25rem 0.75rem;
+    border-radius: 0.25rem;
+    font-size: 0.75rem;
+    font-weight: 500;
+    cursor: pointer;
+    font-family: inherit;
+    transition: background 0.12s ease, color 0.12s ease;
+  }
+
+  .session-btn-new {
+    background: transparent;
+    border: 1px solid var(--ctp-surface1);
+    color: var(--ctp-subtext0);
+  }
+
+  .session-btn-new:hover {
+    background: var(--ctp-surface0);
+    color: var(--ctp-text);
+    border-color: var(--ctp-surface2);
+  }
+
+  .session-btn-continue {
+    background: var(--ctp-surface0);
+    border: 1px solid var(--ctp-surface1);
+    color: var(--ctp-blue);
+  }
+
+  .session-btn-continue:hover {
+    background: var(--ctp-surface1);
+    color: var(--ctp-sapphire);
+  }
+
+  /* === Prompt container === */
+  .prompt-container {
+    padding: 0.5rem var(--bterminal-pane-padding-inline, 0.75rem);
+    flex-shrink: 0;
+    border-top: 1px solid var(--ctp-surface0);
+  }
+
+  .prompt-container.disabled { opacity: 0.6; }
+
+  .prompt-wrapper {
+    position: relative;
+    display: flex;
+    align-items: flex-end;
+    background: var(--ctp-mantle);
+    border: 1px solid var(--ctp-surface1);
+    border-radius: 0.5rem;
+    transition: border-color 0.15s ease;
+  }
+
+  .prompt-wrapper:focus-within { border-color: var(--ctp-blue); }
+
+  .prompt-input {
+    flex: 1;
+    background: transparent;
+    border: none;
+    color: var(--ctp-text);
+    font-family: inherit;
+    font-size: 0.875rem;
+    padding: 0.5rem 0.625rem;
+    resize: none;
+    min-height: 1.25rem;
+    max-height: 9.375rem;
+    line-height: 1.4;
+    overflow-y: auto;
+  }
+
+  .prompt-input:focus { outline: none; }
+  .prompt-input::placeholder { color: var(--ctp-overlay0); }
+  .prompt-input:disabled { cursor: not-allowed; }
+
+  .submit-icon-btn {
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    width: 1.75rem;
+    height: 1.75rem;
+    margin: 0.25rem;
+    border: none;
+    border-radius: 0.375rem;
+    background: var(--ctp-blue);
+    color: var(--ctp-crust);
+    cursor: pointer;
+    flex-shrink: 0;
+    transition: background 0.12s ease, opacity 0.12s ease;
+  }
+
+  .submit-icon-btn:hover:not(:disabled) { background: var(--ctp-sapphire); }
+
+  .submit-icon-btn:disabled {
+    background: var(--ctp-surface1);
+    color: var(--ctp-overlay0);
+    cursor: not-allowed;
+  }
+
+  /* === Skill autocomplete === */
+  .skill-menu {
+    position: absolute;
+    bottom: 100%;
+    left: 0;
+    right: 0;
+    background: var(--ctp-surface0);
+    border: 1px solid var(--ctp-surface1);
+    border-radius: 0.375rem;
+    max-height: 12.5rem;
+    overflow-y: auto;
+    z-index: 10;
+    margin-bottom: 0.25rem;
+  }
+
+  .skill-item {
+    display: flex;
+    gap: 0.5rem;
+    align-items: baseline;
+    padding: 0.375rem 0.625rem;
+    width: 100%;
+    text-align: left;
+    background: none;
+    border: none;
+    color: var(--ctp-text);
+    font-size: 0.8125rem;
+    cursor: pointer;
+    font-family: inherit;
+  }
+
+  .skill-item:hover, .skill-item.active {
+    background: var(--ctp-blue);
+    color: var(--ctp-crust);
+  }
+
+  .skill-name {
+    font-weight: 600;
+    font-family: var(--term-font-family, monospace);
+    color: var(--ctp-green);
+    flex-shrink: 0;
+    font-size: 0.75rem;
+  }
+
+  .skill-item:hover .skill-name, .skill-item.active .skill-name { color: var(--ctp-crust); }
+
+  .skill-desc {
+    color: var(--ctp-overlay1);
+    font-size: 0.75rem;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+  }
+
+  .skill-item:hover .skill-desc, .skill-item.active .skill-desc {
+    color: var(--ctp-crust);
+    opacity: 0.8;
+  }
+</style>
diff --git a/v2/src/lib/components/Agent/AgentTree.svelte b/v2/src/lib/components/Agent/AgentTree.svelte
new file mode 100644
index 0000000..8b3e8bb
--- /dev/null
+++ b/v2/src/lib/components/Agent/AgentTree.svelte
@@ -0,0 +1,173 @@
+<script lang="ts">
+  import { buildAgentTree, subtreeCost, type AgentTreeNode } from '../../utils/agent-tree';
+  import type { AgentSession } from '../../stores/agents.svelte';
+
+  interface Props {
+    session: AgentSession;
+    onNodeClick?: (nodeId: string) => void;
+  }
+
+  let { session, onNodeClick }: Props = $props();
+
+  let tree = $derived(buildAgentTree(
+    session.id,
+    session.messages,
+    session.status,
+    session.costUsd,
+    session.inputTokens + session.outputTokens,
+  ));
+
+  // Layout constants
+  const NODE_W = 100;
+  const NODE_H = 40;
+  const H_GAP = 24;
+  const V_GAP = 12;
+
+  interface LayoutNode {
+    node: AgentTreeNode;
+    x: number;
+    y: number;
+    children: LayoutNode[];
+  }
+
+  function layoutTree(node: AgentTreeNode, x: number, y: number): { layout: LayoutNode; height: number } {
+    if (node.children.length === 0) {
+      return {
+        layout: { node, x, y, children: [] },
+        height: NODE_H,
+      };
+    }
+
+    const childLayouts: LayoutNode[] = [];
+    let childY = y;
+    let totalHeight = 0;
+
+    for (const child of node.children) {
+      const result = layoutTree(child, x + NODE_W + H_GAP, childY);
+      childLayouts.push(result.layout);
+      childY += result.height + V_GAP;
+      totalHeight += result.height + V_GAP;
+    }
+    totalHeight -= V_GAP; // remove trailing gap
+
+    // Center parent vertically relative to children
+    const parentY = childLayouts.length > 0
+      ? (childLayouts[0].y + childLayouts[childLayouts.length - 1].y) / 2
+      : y;
+
+    return {
+      layout: { node, x, y: parentY, children: childLayouts },
+      height: Math.max(NODE_H, totalHeight),
+    };
+  }
+
+  let layoutResult = $derived(layoutTree(tree, 8, 8));
+  let svgHeight = $derived(Math.max(80, layoutResult.height + 24));
+  let svgWidth = $derived(computeWidth(layoutResult.layout));
+
+  function computeWidth(layout: LayoutNode): number {
+    let maxX = layout.x + NODE_W;
+    for (const child of layout.children) {
+      maxX = Math.max(maxX, computeWidth(child));
+    }
+    return maxX + 16;
+  }
+
+  function statusColor(status: string): string {
+    switch (status) {
+      case 'running': return 'var(--ctp-blue)';
+      case 'done': return 'var(--ctp-green)';
+      case 'error': return 'var(--ctp-red)';
+      default: return 'var(--ctp-overlay1)';
+    }
+  }
+
+  function truncateLabel(text: string, maxLen: number): string {
+    return text.length > maxLen ? text.slice(0, maxLen - 1) + '…' : text;
+  }
+</script>
+
+<div class="agent-tree">
+  <svg width={svgWidth} height={svgHeight}>
+    {#snippet renderNode(layout: LayoutNode)}
+      <!-- Edges to children -->
+      {#each layout.children as child}
+        <path
+          d="M {layout.x + NODE_W} {layout.y + NODE_H / 2}
+             C {layout.x + NODE_W + H_GAP / 2} {layout.y + NODE_H / 2},
+               {child.x - H_GAP / 2} {child.y + NODE_H / 2},
+               {child.x} {child.y + NODE_H / 2}"
+          fill="none"
+          stroke="var(--border)"
+          stroke-width="1.5"
+        />
+      {/each}
+
+      <!-- Node rectangle -->
+      <!-- svelte-ignore a11y_click_events_have_key_events -->
+      <!-- svelte-ignore a11y_no_static_element_interactions -->
+      <g
+        class="tree-node"
+        onclick={() => onNodeClick?.(layout.node.id)}
+        style="cursor: {onNodeClick ? 'pointer' : 'default'}"
+      >
+        <rect
+          x={layout.x}
+          y={layout.y}
+          width={NODE_W}
+          height={NODE_H}
+          rx="4"
+          fill="var(--bg-surface)"
+          stroke={statusColor(layout.node.status)}
+          stroke-width="1.5"
+        />
+        <!-- Status dot -->
+        <circle
+          cx={layout.x + 10}
+          cy={layout.y + NODE_H / 2 - 4}
+          r="3"
+          fill={statusColor(layout.node.status)}
+        />
+        <!-- Label -->
+        <text
+          x={layout.x + 18}
+          y={layout.y + NODE_H / 2 - 4}
+          fill="var(--text-primary)"
+          font-size="10"
+          font-family="var(--font-mono)"
+          dominant-baseline="middle"
+        >{truncateLabel(layout.node.label, 10)}</text>
+        <!-- Subtree cost -->
+        {#if subtreeCost(layout.node) > 0}
+          <text
+            x={layout.x + 18}
+            y={layout.y + NODE_H / 2 + 9}
+            fill="var(--ctp-yellow)"
+            font-size="8"
+            font-family="var(--font-mono)"
+            dominant-baseline="middle"
+          >${subtreeCost(layout.node).toFixed(4)}</text>
+        {/if}
+      </g>
+
+      <!-- Recurse children -->
+      {#each layout.children as child}
+        {@render renderNode(child)}
+      {/each}
+    {/snippet}
+
+    {@render renderNode(layoutResult.layout)}
+  </svg>
+</div>
+
+<style>
+  .agent-tree {
+    overflow: auto;
+    padding: 0.25rem;
+    background: var(--bg-primary);
+  }
+
+  .tree-node:hover rect {
+    fill: var(--bg-surface-hover, var(--ctp-surface1));
+  }
+</style>
diff --git a/v2/src/lib/components/Agent/UsageMeter.svelte b/v2/src/lib/components/Agent/UsageMeter.svelte
new file mode 100644
index 0000000..86c8b9a
--- /dev/null
+++ b/v2/src/lib/components/Agent/UsageMeter.svelte
@@ -0,0 +1,146 @@
+<script lang="ts">
+  interface Props {
+    inputTokens: number;
+    outputTokens: number;
+    contextLimit?: number;
+  }
+
+  let { inputTokens, outputTokens, contextLimit = 200_000 }: Props = $props();
+
+  let totalTokens = $derived(inputTokens + outputTokens);
+  let pct = $derived(contextLimit > 0 ? Math.min((totalTokens / contextLimit) * 100, 100) : 0);
+
+  let thresholdClass = $derived.by(() => {
+    if (pct >= 90) return 'critical';
+    if (pct >= 75) return 'high';
+    if (pct >= 50) return 'medium';
+    return 'low';
+  });
+
+  function formatTokens(n: number): string {
+    if (n >= 1_000_000) return `${(n / 1_000_000).toFixed(1)}M`;
+    if (n >= 1_000) return `${(n / 1_000).toFixed(1)}k`;
+    return String(n);
+  }
+
+  let showTooltip = $state(false);
+</script>
+
+{#if totalTokens > 0}
+  <!-- svelte-ignore a11y_no_static_element_interactions -->
+  <div
+    class="usage-meter"
+    class:critical={thresholdClass === 'critical'}
+    class:high={thresholdClass === 'high'}
+    class:medium={thresholdClass === 'medium'}
+    class:low={thresholdClass === 'low'}
+    onmouseenter={() => showTooltip = true}
+    onmouseleave={() => showTooltip = false}
+  >
+    <div class="meter-track">
+      <div class="meter-fill" style="width: {pct}%"></div>
+    </div>
+    <span class="meter-label">{formatTokens(totalTokens)}</span>
+
+    {#if showTooltip}
+      <div class="meter-tooltip">
+        <div class="tooltip-row">
+          <span class="tooltip-key">Input</span>
+          <span class="tooltip-val">{formatTokens(inputTokens)}</span>
+        </div>
+        <div class="tooltip-row">
+          <span class="tooltip-key">Output</span>
+          <span class="tooltip-val">{formatTokens(outputTokens)}</span>
+        </div>
+        <div class="tooltip-row">
+          <span class="tooltip-key">Total</span>
+          <span class="tooltip-val">{formatTokens(totalTokens)}</span>
+        </div>
+        <div class="tooltip-divider"></div>
+        <div class="tooltip-row">
+          <span class="tooltip-key">Limit</span>
+          <span class="tooltip-val">{formatTokens(contextLimit)}</span>
+        </div>
+        <div class="tooltip-row">
+          <span class="tooltip-key">Used</span>
+          <span class="tooltip-val">{pct.toFixed(1)}%</span>
+        </div>
+      </div>
+    {/if}
+  </div>
+{/if}
+
+<style>
+  .usage-meter {
+    display: inline-flex;
+    align-items: center;
+    gap: 0.375rem;
+    position: relative;
+  }
+
+  .meter-track {
+    width: 3rem;
+    height: 0.375rem;
+    background: var(--ctp-surface0);
+    border-radius: 0.1875rem;
+    overflow: hidden;
+    flex-shrink: 0;
+  }
+
+  .meter-fill {
+    height: 100%;
+    border-radius: 0.1875rem;
+    transition: width 0.3s ease, background 0.3s ease;
+  }
+
+  .low .meter-fill { background: var(--ctp-green); }
+  .medium .meter-fill { background: var(--ctp-yellow); }
+  .high .meter-fill { background: var(--ctp-peach); }
+  .critical .meter-fill { background: var(--ctp-red); }
+
+  .meter-label {
+    font-size: 0.625rem;
+    font-family: var(--term-font-family, monospace);
+    color: var(--ctp-overlay1);
+    white-space: nowrap;
+  }
+
+  .meter-tooltip {
+    position: absolute;
+    bottom: calc(100% + 0.375rem);
+    left: 50%;
+    transform: translateX(-50%);
+    background: var(--ctp-surface0);
+    border: 1px solid var(--ctp-surface1);
+    border-radius: 0.25rem;
+    padding: 0.375rem 0.5rem;
+    min-width: 7.5rem;
+    z-index: 100;
+    box-shadow: 0 0.125rem 0.5rem color-mix(in srgb, var(--ctp-crust) 40%, transparent);
+  }
+
+  .tooltip-row {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    gap: 0.75rem;
+    padding: 0.0625rem 0;
+  }
+
+  .tooltip-key {
+    font-size: 0.625rem;
+    color: var(--ctp-overlay0);
+  }
+
+  .tooltip-val {
+    font-size: 0.625rem;
+    font-family: var(--term-font-family, monospace);
+    color: var(--ctp-text);
+  }
+
+  .tooltip-divider {
+    height: 1px;
+    background: var(--ctp-surface1);
+    margin: 0.1875rem 0;
+  }
+</style>
diff --git a/v2/src/lib/components/Context/ContextPane.svelte b/v2/src/lib/components/Context/ContextPane.svelte
new file mode 100644
index 0000000..d7d2834
--- /dev/null
+++ b/v2/src/lib/components/Context/ContextPane.svelte
@@ -0,0 +1,396 @@
+<script lang="ts">
+  import { onMount } from 'svelte';
+  import {
+    ctxInitDb,
+    ctxRegisterProject,
+    ctxGetContext,
+    ctxGetShared,
+    ctxGetSummaries,
+    ctxSearch,
+    type CtxEntry,
+    type CtxSummary,
+  } from '../../adapters/ctx-bridge';
+
+  interface Props {
+    projectName: string;
+    projectCwd: string;
+  }
+
+  let { projectName, projectCwd }: Props = $props();
+
+  let entries = $state<CtxEntry[]>([]);
+  let sharedEntries = $state<CtxEntry[]>([]);
+  let summaries = $state<CtxSummary[]>([]);
+  let searchQuery = $state('');
+  let searchResults = $state<CtxEntry[]>([]);
+  let error = $state('');
+  let loading = $state(false);
+  let dbMissing = $state(false);
+  let initializing = $state(false);
+
+  async function loadProjectContext() {
+    loading = true;
+    try {
+      // Register project if not already (INSERT OR IGNORE)
+      await ctxRegisterProject(projectName, `BTerminal project: ${projectName}`, projectCwd);
+
+      const [ctx, shared, sums] = await Promise.all([
+        ctxGetContext(projectName),
+        ctxGetShared(),
+        ctxGetSummaries(projectName, 5),
+      ]);
+      entries = ctx;
+      sharedEntries = shared;
+      summaries = sums;
+      error = '';
+      dbMissing = false;
+    } catch (e) {
+      error = `${e}`;
+      dbMissing = error.includes('not found'); // Coupled to Rust error text "ctx database not found"
+    } finally {
+      loading = false;
+    }
+  }
+
+  async function handleInitDb() {
+    initializing = true;
+    try {
+      await ctxInitDb();
+      await loadProjectContext();
+    } catch (e) {
+      error = `Failed to initialize database: ${e}`;
+    } finally {
+      initializing = false;
+    }
+  }
+
+  async function handleSearch() {
+    if (!searchQuery.trim()) {
+      searchResults = [];
+      return;
+    }
+    try {
+      searchResults = await ctxSearch(searchQuery);
+    } catch (e) {
+      error = `Search failed: ${e}`;
+    }
+  }
+
+  onMount(loadProjectContext);
+</script>
+
+<div class="context-pane">
+  <div class="ctx-header">
+    <h3>{projectName}</h3>
+    <input
+      type="text"
+      class="search-input"
+      placeholder="Search contexts..."
+      bind:value={searchQuery}
+      onkeydown={(e) => { if (e.key === 'Enter') handleSearch(); }}
+    />
+  </div>
+
+  {#if error}
+    <div class="ctx-error-box">
+      <div class="ctx-error-icon">
+        <svg width="20" height="20" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+          <circle cx="12" cy="12" r="10"></circle>
+          <line x1="12" y1="8" x2="12" y2="12"></line>
+          <line x1="12" y1="16" x2="12.01" y2="16"></line>
+        </svg>
+      </div>
+      {#if dbMissing}
+        <div class="ctx-error-text">Context database not found</div>
+        <div class="ctx-error-hint">
+          Create the database at <code>~/.claude-context/context.db</code> to get started.
+        </div>
+        <button class="init-btn" onclick={handleInitDb} disabled={initializing}>
+          {#if initializing}
+            Initializing...
+          {:else}
+            Initialize Database
+          {/if}
+        </button>
+      {:else}
+        <div class="ctx-error-text">{error}</div>
+      {/if}
+    </div>
+  {/if}
+
+  {#if !error}
+    <div class="ctx-body">
+      {#if loading}
+        <div class="loading">Loading...</div>
+      {:else if searchResults.length > 0}
+        <div class="section">
+          <h4>Search Results</h4>
+          {#each searchResults as result}
+            <div class="entry">
+              <div class="entry-header">
+                <span class="entry-project">{result.project}</span>
+                <span class="entry-key">{result.key}</span>
+              </div>
+              <pre class="entry-value">{result.value}</pre>
+            </div>
+          {/each}
+          <button class="clear-btn" onclick={() => { searchResults = []; searchQuery = ''; }}>Clear search</button>
+        </div>
+      {:else}
+        {#if entries.length > 0}
+          <div class="section">
+            <h4>Project Context</h4>
+            {#each entries as entry}
+              <div class="entry">
+                <div class="entry-header">
+                  <span class="entry-key">{entry.key}</span>
+                  <span class="entry-date">{entry.updated_at}</span>
+                </div>
+                <pre class="entry-value">{entry.value}</pre>
+              </div>
+            {/each}
+          </div>
+        {/if}
+
+        {#if sharedEntries.length > 0}
+          <div class="section">
+            <h4>Shared Context</h4>
+            {#each sharedEntries as entry}
+              <div class="entry">
+                <div class="entry-header">
+                  <span class="entry-key">{entry.key}</span>
+                </div>
+                <pre class="entry-value">{entry.value}</pre>
+              </div>
+            {/each}
+          </div>
+        {/if}
+
+        {#if summaries.length > 0}
+          <div class="section">
+            <h4>Recent Sessions</h4>
+            {#each summaries as summary}
+              <div class="entry">
+                <div class="entry-header">
+                  <span class="entry-date">{summary.created_at}</span>
+                </div>
+                <pre class="entry-value">{summary.summary}</pre>
+              </div>
+            {/each}
+          </div>
+        {/if}
+
+        {#if entries.length === 0 && sharedEntries.length === 0 && summaries.length === 0}
+          <div class="empty-state">
+            <p class="empty">No context stored yet.</p>
+            <p class="empty">Use <code>ctx set {projectName} &lt;key&gt; &lt;value&gt;</code> to add context entries.</p>
+          </div>
+        {/if}
+      {/if}
+    </div>
+  {/if}
+</div>
+
+<style>
+  .context-pane {
+    display: flex;
+    flex-direction: column;
+    height: 100%;
+    background: var(--ctp-base);
+    color: var(--ctp-text);
+    font-size: 0.8rem;
+  }
+
+  .ctx-header {
+    padding: 0.5rem 0.75rem;
+    border-bottom: 1px solid var(--ctp-surface0);
+    display: flex;
+    align-items: center;
+    gap: 0.75rem;
+    flex-shrink: 0;
+    white-space: nowrap;
+  }
+
+  .ctx-header h3 {
+    font-size: 0.8rem;
+    font-weight: 600;
+    white-space: nowrap;
+    color: var(--ctp-blue);
+  }
+
+  .search-input {
+    flex: 1;
+    min-width: 10em;
+    background: var(--ctp-surface0);
+    border: 1px solid var(--ctp-surface0);
+    border-radius: 0.25rem;
+    color: var(--ctp-text);
+    font-family: var(--term-font-family, monospace);
+    font-size: 0.7rem;
+    padding: 0.25rem 0.5rem;
+  }
+
+  .search-input:focus {
+    outline: none;
+    border-color: var(--ctp-blue);
+  }
+
+  .ctx-error-box {
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    gap: 0.5rem;
+    padding: 1.5rem 1rem;
+    text-align: center;
+  }
+
+  .ctx-error-icon {
+    color: var(--ctp-overlay0);
+  }
+
+  .ctx-error-text {
+    color: var(--ctp-red);
+    font-size: 0.75rem;
+  }
+
+  .ctx-error-hint {
+    color: var(--ctp-overlay1);
+    font-size: 0.7rem;
+  }
+
+  .ctx-error-hint code {
+    background: var(--ctp-surface0);
+    padding: 0.0625rem 0.3125rem;
+    border-radius: 0.1875rem;
+    font-family: var(--term-font-family, monospace);
+    color: var(--ctp-green);
+  }
+
+  .init-btn {
+    margin-top: 0.5rem;
+    padding: 0.375rem 1rem;
+    background: var(--ctp-blue);
+    color: var(--ctp-base);
+    border: none;
+    border-radius: 0.25rem;
+    font-size: 0.75rem;
+    font-weight: 600;
+    cursor: pointer;
+    transition: opacity 0.15s;
+  }
+
+  .init-btn:hover:not(:disabled) {
+    opacity: 0.85;
+  }
+
+  .init-btn:disabled {
+    opacity: 0.5;
+    cursor: not-allowed;
+  }
+
+  .ctx-body {
+    flex: 1;
+    overflow-y: auto;
+    padding: 0.5rem 0.75rem;
+  }
+
+  h4 {
+    font-size: 0.7rem;
+    font-weight: 600;
+    color: var(--ctp-mauve);
+    text-transform: uppercase;
+    letter-spacing: 0.03em;
+    margin-bottom: 0.375rem;
+  }
+
+  .section {
+    margin-bottom: 1rem;
+  }
+
+  .entry {
+    background: var(--ctp-surface0);
+    border-radius: 0.25rem;
+    padding: 0.375rem 0.5rem;
+    margin-bottom: 0.25rem;
+  }
+
+  .entry-header {
+    display: flex;
+    align-items: center;
+    gap: 0.5rem;
+    margin-bottom: 0.25rem;
+  }
+
+  .entry-project {
+    font-size: 0.625rem;
+    color: var(--ctp-blue);
+    font-weight: 600;
+  }
+
+  .entry-key {
+    font-size: 0.6875rem;
+    font-weight: 600;
+    color: var(--ctp-green);
+  }
+
+  .entry-date {
+    font-size: 0.5625rem;
+    color: var(--ctp-overlay0);
+    margin-left: auto;
+  }
+
+  .entry-value {
+    font-size: 0.6875rem;
+    white-space: pre-wrap;
+    word-break: break-word;
+    color: var(--ctp-subtext0);
+    max-height: 12.5rem;
+    overflow-y: auto;
+    margin: 0;
+  }
+
+  .empty-state {
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    justify-content: center;
+    padding: 2rem 1rem;
+    gap: 0.25rem;
+  }
+
+  .empty {
+    color: var(--ctp-overlay0);
+    font-size: 0.6875rem;
+    font-style: italic;
+    margin: 0;
+  }
+
+  .empty code {
+    background: var(--ctp-surface0);
+    padding: 0.0625rem 0.3125rem;
+    border-radius: 0.1875rem;
+    font-family: var(--term-font-family, monospace);
+    color: var(--ctp-green);
+    font-style: normal;
+  }
+
+  .clear-btn {
+    background: var(--ctp-surface0);
+    border: 1px solid var(--ctp-surface0);
+    color: var(--ctp-subtext0);
+    border-radius: 0.25rem;
+    padding: 0.25rem 0.625rem;
+    font-size: 0.6875rem;
+    cursor: pointer;
+    margin-top: 0.25rem;
+  }
+
+  .clear-btn:hover { color: var(--ctp-text); }
+
+  .loading {
+    color: var(--ctp-overlay0);
+    font-size: 0.75rem;
+    text-align: center;
+    padding: 1rem;
+  }
+</style>
diff --git a/v2/src/lib/components/Markdown/MarkdownPane.svelte b/v2/src/lib/components/Markdown/MarkdownPane.svelte
new file mode 100644
index 0000000..0d03a03
--- /dev/null
+++ b/v2/src/lib/components/Markdown/MarkdownPane.svelte
@@ -0,0 +1,428 @@
+<script lang="ts">
+  import { onMount, onDestroy } from 'svelte';
+  import { marked, Renderer } from 'marked';
+  import { watchFile, unwatchFile, onFileChanged, type FileChangedPayload } from '../../adapters/file-bridge';
+  import { getHighlighter, highlightCode, escapeHtml } from '../../utils/highlight';
+
+  interface Props {
+    filePath: string;
+    paneId: string;
+    onExit?: () => void;
+    onNavigate?: (absolutePath: string) => void;
+  }
+
+  let { filePath, paneId, onExit, onNavigate }: Props = $props();
+
+  let renderedHtml = $state('');
+  let error = $state('');
+  let unlisten: (() => void) | undefined;
+  let currentWatchPath = $state<string | null>(null);
+  let highlighterReady = $state(false);
+
+  const renderer = new Renderer();
+  renderer.code = function({ text, lang }: { text: string; lang?: string }) {
+    if (lang) {
+      const highlighted = highlightCode(text, lang);
+      if (highlighted !== escapeHtml(text)) return highlighted;
+    }
+    return `<pre><code>${escapeHtml(text)}</code></pre>`;
+  };
+
+  function renderMarkdown(source: string): void {
+    try {
+      renderedHtml = marked.parse(source, { renderer, async: false }) as string;
+      error = '';
+    } catch (e) {
+      error = `Render error: ${e}`;
+    }
+  }
+
+  // React to filePath changes — re-watch the new file
+  $effect(() => {
+    if (!highlighterReady) return;
+    const path = filePath;
+    if (path === currentWatchPath) return;
+
+    // Unwatch previous file
+    if (currentWatchPath) {
+      unwatchFile(paneId).catch(() => {});
+    }
+
+    currentWatchPath = path;
+    watchFile(paneId, path)
+      .then(content => renderMarkdown(content))
+      .catch(e => { error = `Failed to open file: ${e}`; });
+  });
+
+  onMount(async () => {
+    try {
+      await getHighlighter();
+      highlighterReady = true;
+
+      unlisten = await onFileChanged((payload: FileChangedPayload) => {
+        if (payload.pane_id === paneId) {
+          renderMarkdown(payload.content);
+        }
+      });
+    } catch (e) {
+      error = `Failed to initialize: ${e}`;
+    }
+  });
+
+  onDestroy(() => {
+    unlisten?.();
+    unwatchFile(paneId).catch(() => {});
+  });
+
+  function handleLinkClick(event: MouseEvent) {
+    const anchor = (event.target as HTMLElement).closest('a');
+    if (!anchor) return;
+
+    const href = anchor.getAttribute('href');
+    if (!href) return;
+
+    // Anchor links — scroll within page
+    if (href.startsWith('#')) return;
+
+    event.preventDefault();
+
+    // External URLs — open in system browser
+    if (/^https?:\/\//.test(href)) {
+      import('@tauri-apps/api/core').then(({ invoke }) => {
+        invoke('open_url', { url: href }).catch(() => {
+          // Fallback: do nothing (no shell plugin)
+        });
+      });
+      return;
+    }
+
+    // Relative file link — resolve against current file's directory
+    if (onNavigate) {
+      const dir = filePath.replace(/\/[^/]*$/, '');
+      const resolved = resolveRelativePath(dir, href);
+      onNavigate(resolved);
+    }
+  }
+
+  function resolveRelativePath(base: string, relative: string): string {
+    // Strip any anchor or query from the link
+    const cleanRelative = relative.split('#')[0].split('?')[0];
+    const parts = base.split('/');
+    for (const segment of cleanRelative.split('/')) {
+      if (segment === '..') {
+        parts.pop();
+      } else if (segment !== '.' && segment !== '') {
+        parts.push(segment);
+      }
+    }
+    return parts.join('/');
+  }
+</script>
+
+<div class="markdown-pane">
+  {#if error}
+    <div class="error">{error}</div>
+  {:else}
+    <!-- svelte-ignore a11y_click_events_have_key_events -->
+    <!-- svelte-ignore a11y_no_static_element_interactions -->
+    <div class="markdown-pane-scroll" onclick={handleLinkClick}>
+      <div class="markdown-body">
+        {@html renderedHtml}
+      </div>
+    </div>
+  {/if}
+  <div class="file-path">{filePath}</div>
+</div>
+
+<style>
+  .markdown-pane {
+    display: flex;
+    flex-direction: column;
+    height: 100%;
+    background: var(--ctp-base);
+    color: var(--ctp-text);
+  }
+
+  .markdown-pane-scroll {
+    flex: 1;
+    overflow-y: auto;
+    container-type: inline-size;
+  }
+
+  .markdown-body {
+    padding: 1.5rem var(--bterminal-pane-padding-inline, 2rem);
+    font-family: 'Inter', system-ui, -apple-system, 'Segoe UI', sans-serif;
+    font-size: 0.9rem;
+    line-height: 1.7;
+    color: var(--ctp-subtext1);
+    text-rendering: optimizeLegibility;
+    -webkit-font-smoothing: antialiased;
+    -moz-osx-font-smoothing: grayscale;
+    font-feature-settings: 'cv01', 'cv02', 'cv03', 'cv04', 'ss01';
+  }
+
+  /* --- Headings --- */
+
+  .markdown-body :global(h1) {
+    font-size: 1.75em;
+    font-weight: 700;
+    line-height: 1.2;
+    margin: 1.5em 0 0.6em;
+    color: var(--ctp-lavender);
+    padding-bottom: 0.35em;
+    border-bottom: 1px solid color-mix(in srgb, var(--ctp-surface1) 60%, transparent);
+    letter-spacing: -0.01em;
+  }
+
+  .markdown-body :global(h1:first-child) {
+    margin-top: 0;
+  }
+
+  .markdown-body :global(h2) {
+    font-size: 1.4em;
+    font-weight: 650;
+    line-height: 1.25;
+    margin: 1.75em 0 0.5em;
+    color: var(--ctp-blue);
+    letter-spacing: -0.005em;
+  }
+
+  .markdown-body :global(h3) {
+    font-size: 1.15em;
+    font-weight: 600;
+    line-height: 1.3;
+    margin: 1.5em 0 0.4em;
+    color: var(--ctp-sapphire);
+  }
+
+  .markdown-body :global(h4) {
+    font-size: 1em;
+    font-weight: 600;
+    line-height: 1.4;
+    margin: 1.25em 0 0.35em;
+    color: var(--ctp-teal);
+    text-transform: none;
+  }
+
+  .markdown-body :global(h5) {
+    font-size: 0.875em;
+    font-weight: 600;
+    line-height: 1.4;
+    margin: 1.25em 0 0.3em;
+    color: var(--ctp-subtext1);
+    text-transform: uppercase;
+    letter-spacing: 0.04em;
+  }
+
+  .markdown-body :global(h6) {
+    font-size: 0.8em;
+    font-weight: 600;
+    line-height: 1.4;
+    margin: 1em 0 0.25em;
+    color: var(--ctp-overlay2);
+    text-transform: uppercase;
+    letter-spacing: 0.04em;
+  }
+
+  /* --- Prose --- */
+
+  .markdown-body :global(p) {
+    margin: 1.15em 0;
+  }
+
+  .markdown-body :global(strong) {
+    color: var(--ctp-text);
+    font-weight: 600;
+  }
+
+  .markdown-body :global(em) {
+    color: var(--ctp-subtext0);
+    font-style: italic;
+  }
+
+  /* --- Links --- */
+
+  .markdown-body :global(a) {
+    color: var(--ctp-blue);
+    text-decoration: underline;
+    text-decoration-color: color-mix(in srgb, var(--ctp-blue) 30%, transparent);
+    text-underline-offset: 0.2em;
+    text-decoration-thickness: 1px;
+    transition: text-decoration-color 0.2s ease;
+  }
+
+  .markdown-body :global(a:hover) {
+    text-decoration-color: var(--ctp-blue);
+  }
+
+  /* --- Inline code --- */
+
+  .markdown-body :global(code) {
+    background: color-mix(in srgb, var(--ctp-surface0) 70%, transparent);
+    padding: 0.175em 0.4em;
+    border-radius: 0.25em;
+    font-family: var(--term-font-family, 'JetBrains Mono', monospace);
+    font-size: 0.85em;
+    color: var(--ctp-green);
+    font-variant-ligatures: none;
+  }
+
+  /* --- Code blocks --- */
+
+  .markdown-body :global(pre) {
+    background: var(--ctp-mantle);
+    padding: 1rem 1.125rem;
+    border-radius: 0.375rem;
+    border: 1px solid var(--ctp-surface0);
+    overflow-x: auto;
+    font-size: 0.8rem;
+    line-height: 1.6;
+    margin: 1.25em 0;
+    box-shadow: inset 0 1px 0 color-mix(in srgb, var(--ctp-surface1) 20%, transparent);
+    direction: ltr;
+    unicode-bidi: embed;
+  }
+
+  .markdown-body :global(pre code) {
+    background: none;
+    padding: 0;
+    color: var(--ctp-text);
+    font-size: inherit;
+    border-radius: 0;
+  }
+
+  .markdown-body :global(.shiki) {
+    background: var(--ctp-mantle) !important;
+    padding: 1rem 1.125rem;
+    border-radius: 0.375rem;
+    border: 1px solid var(--ctp-surface0);
+    overflow-x: auto;
+    font-size: 0.8rem;
+    line-height: 1.6;
+    margin: 1.25em 0;
+    box-shadow: inset 0 1px 0 color-mix(in srgb, var(--ctp-surface1) 20%, transparent);
+  }
+
+  .markdown-body :global(.shiki code) {
+    background: none !important;
+    padding: 0;
+  }
+
+  /* --- Blockquote --- */
+
+  .markdown-body :global(blockquote) {
+    position: relative;
+    border-left: 3px solid var(--ctp-mauve);
+    margin: 1.5em 0;
+    padding: 0.5rem 1.125rem;
+    color: var(--ctp-overlay2);
+    background: color-mix(in srgb, var(--ctp-surface0) 20%, transparent);
+    border-radius: 0 0.25rem 0.25rem 0;
+    font-style: italic;
+  }
+
+  .markdown-body :global(blockquote p) {
+    margin: 0.5em 0;
+  }
+
+  .markdown-body :global(blockquote p:first-child) {
+    margin-top: 0;
+  }
+
+  .markdown-body :global(blockquote p:last-child) {
+    margin-bottom: 0;
+  }
+
+  /* --- Lists --- */
+
+  .markdown-body :global(ul), .markdown-body :global(ol) {
+    padding-left: 1.625em;
+    margin: 1em 0;
+  }
+
+  .markdown-body :global(li) {
+    margin: 0.35em 0;
+  }
+
+  .markdown-body :global(li::marker) {
+    color: var(--ctp-overlay1);
+  }
+
+  .markdown-body :global(ol > li::marker) {
+    color: var(--ctp-overlay2);
+    font-variant-numeric: tabular-nums;
+  }
+
+  .markdown-body :global(li > ul), .markdown-body :global(li > ol) {
+    margin: 0.25em 0;
+  }
+
+  /* --- Tables --- */
+
+  .markdown-body :global(table) {
+    border-collapse: collapse;
+    width: 100%;
+    margin: 1.5em 0;
+    font-size: 0.85em;
+    line-height: 1.5;
+  }
+
+  .markdown-body :global(th), .markdown-body :global(td) {
+    border: 1px solid var(--ctp-surface1);
+    padding: 0.5rem 0.75rem;
+    text-align: left;
+  }
+
+  .markdown-body :global(th) {
+    background: color-mix(in srgb, var(--ctp-surface0) 60%, transparent);
+    font-weight: 600;
+    color: var(--ctp-subtext1);
+    font-size: 0.9em;
+    text-transform: none;
+  }
+
+  .markdown-body :global(tr:hover td) {
+    background: color-mix(in srgb, var(--ctp-surface0) 30%, transparent);
+  }
+
+  /* --- Horizontal rule --- */
+
+  .markdown-body :global(hr) {
+    border: none;
+    height: 1px;
+    margin: 2em 0;
+    background: linear-gradient(
+      to right,
+      transparent,
+      var(--ctp-surface1) 15%,
+      var(--ctp-surface1) 85%,
+      transparent
+    );
+  }
+
+  /* --- Images --- */
+
+  .markdown-body :global(img) {
+    max-width: 100%;
+    border-radius: 0.375rem;
+    margin: 1.25em 0;
+  }
+
+  /* --- Status bar --- */
+
+  .file-path {
+    border-top: 1px solid var(--ctp-surface0);
+    padding: 0.25rem 0.75rem;
+    font-size: 0.65rem;
+    font-family: var(--term-font-family, monospace);
+    color: var(--ctp-overlay0);
+    flex-shrink: 0;
+  }
+
+  .error {
+    color: var(--ctp-red);
+    padding: 1.5rem 2rem;
+    font-size: 0.85rem;
+    font-family: 'Inter', system-ui, sans-serif;
+  }
+</style>
diff --git a/v2/src/lib/components/Notifications/NotificationCenter.svelte b/v2/src/lib/components/Notifications/NotificationCenter.svelte
new file mode 100644
index 0000000..ace5ee3
--- /dev/null
+++ b/v2/src/lib/components/Notifications/NotificationCenter.svelte
@@ -0,0 +1,300 @@
+<script lang="ts">
+  import {
+    getNotificationHistory,
+    getUnreadCount,
+    markRead,
+    markAllRead,
+    clearHistory,
+    type NotificationType,
+  } from '../../stores/notifications.svelte';
+
+  let history = $derived(getNotificationHistory());
+  let unreadCount = $derived(getUnreadCount());
+  let open = $state(false);
+
+  function toggle() {
+    open = !open;
+  }
+
+  function close() {
+    open = false;
+  }
+
+  function handleKeydown(e: KeyboardEvent) {
+    if (e.key === 'Escape' && open) {
+      close();
+    }
+  }
+
+  function handleClickNotification(id: string) {
+    markRead(id);
+  }
+
+  function typeIcon(type: NotificationType): string {
+    switch (type) {
+      case 'agent_complete': return '\u2713'; // checkmark
+      case 'agent_error': return '\u2715'; // x
+      case 'task_review': return '\u2691'; // flag
+      case 'wake_event': return '\u23F0'; // alarm
+      case 'conflict': return '\u26A0'; // warning
+      case 'system': return '\u2139'; // info
+    }
+  }
+
+  function typeColor(type: NotificationType): string {
+    switch (type) {
+      case 'agent_complete': return 'var(--ctp-green)';
+      case 'agent_error': return 'var(--ctp-red)';
+      case 'task_review': return 'var(--ctp-blue)';
+      case 'wake_event': return 'var(--ctp-teal)';
+      case 'conflict': return 'var(--ctp-yellow)';
+      case 'system': return 'var(--ctp-overlay1)';
+    }
+  }
+
+  function relativeTime(ts: number): string {
+    const diff = Math.floor((Date.now() - ts) / 1000);
+    if (diff < 60) return `${diff}s ago`;
+    if (diff < 3600) return `${Math.floor(diff / 60)}m ago`;
+    if (diff < 86400) return `${Math.floor(diff / 3600)}h ago`;
+    return `${Math.floor(diff / 86400)}d ago`;
+  }
+</script>
+
+<svelte:window onkeydown={handleKeydown} />
+
+<div class="notification-center" data-testid="notification-center">
+  <button
+    class="bell-btn"
+    class:has-unread={unreadCount > 0}
+    onclick={toggle}
+    title="Notifications"
+    data-testid="notification-bell"
+  >
+    <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+      <path d="M18 8A6 6 0 0 0 6 8c0 7-3 9-3 9h18s-3-2-3-9" />
+      <path d="M13.73 21a2 2 0 0 1-3.46 0" />
+    </svg>
+    {#if unreadCount > 0}
+      <span class="badge">{unreadCount > 99 ? '99+' : unreadCount}</span>
+    {/if}
+  </button>
+
+  {#if open}
+    <!-- svelte-ignore a11y_no_static_element_interactions -->
+    <div class="backdrop" onclick={close}></div>
+    <div class="panel" data-testid="notification-panel">
+      <div class="panel-header">
+        <span class="panel-title">Notifications</span>
+        <div class="panel-actions">
+          {#if unreadCount > 0}
+            <button class="action-btn" onclick={() => markAllRead()}>Mark all read</button>
+          {/if}
+          {#if history.length > 0}
+            <button class="action-btn" onclick={() => { clearHistory(); close(); }}>Clear</button>
+          {/if}
+        </div>
+      </div>
+      <div class="panel-list">
+        {#if history.length === 0}
+          <div class="empty">No notifications</div>
+        {:else}
+          {#each [...history].reverse() as item (item.id)}
+            <button
+              class="notification-item"
+              class:unread={!item.read}
+              onclick={() => handleClickNotification(item.id)}
+            >
+              <span class="notif-icon" style="color: {typeColor(item.type)}">{typeIcon(item.type)}</span>
+              <div class="notif-content">
+                <span class="notif-title">{item.title}</span>
+                <span class="notif-body">{item.body}</span>
+              </div>
+              <span class="notif-time">{relativeTime(item.timestamp)}</span>
+            </button>
+          {/each}
+        {/if}
+      </div>
+    </div>
+  {/if}
+</div>
+
+<style>
+  .notification-center {
+    position: relative;
+    display: flex;
+    align-items: center;
+  }
+
+  .bell-btn {
+    position: relative;
+    background: none;
+    border: none;
+    color: var(--ctp-overlay1);
+    cursor: pointer;
+    padding: 0.125rem;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+  }
+
+  .bell-btn:hover {
+    color: var(--ctp-text);
+  }
+
+  .bell-btn.has-unread {
+    color: var(--ctp-peach);
+  }
+
+  .badge {
+    position: absolute;
+    top: -0.25rem;
+    right: -0.375rem;
+    background: var(--ctp-red);
+    color: var(--ctp-crust);
+    font-size: 0.5rem;
+    font-weight: 700;
+    min-width: 0.875rem;
+    height: 0.875rem;
+    border-radius: 0.4375rem;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    padding: 0 0.1875rem;
+    line-height: 1;
+  }
+
+  .backdrop {
+    position: fixed;
+    inset: 0;
+    z-index: 199;
+  }
+
+  .panel {
+    position: absolute;
+    bottom: 1.75rem;
+    right: 0;
+    width: 20rem;
+    max-height: 25rem;
+    background: var(--ctp-surface0);
+    border: 1px solid var(--ctp-surface1);
+    border-radius: 0.375rem;
+    box-shadow: 0 0.5rem 1.5rem rgba(0, 0, 0, 0.4);
+    z-index: 200;
+    display: flex;
+    flex-direction: column;
+    overflow: hidden;
+  }
+
+  .panel-header {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    padding: 0.5rem 0.75rem;
+    border-bottom: 1px solid var(--ctp-surface1);
+  }
+
+  .panel-title {
+    font-size: 0.75rem;
+    font-weight: 600;
+    color: var(--ctp-text);
+  }
+
+  .panel-actions {
+    display: flex;
+    gap: 0.5rem;
+  }
+
+  .action-btn {
+    background: none;
+    border: none;
+    color: var(--ctp-blue);
+    font-size: 0.625rem;
+    cursor: pointer;
+    padding: 0;
+  }
+
+  .action-btn:hover {
+    color: var(--ctp-sapphire);
+    text-decoration: underline;
+  }
+
+  .panel-list {
+    overflow-y: auto;
+    flex: 1;
+  }
+
+  .empty {
+    padding: 1.5rem;
+    text-align: center;
+    font-size: 0.6875rem;
+    color: var(--ctp-overlay0);
+  }
+
+  .notification-item {
+    display: flex;
+    align-items: flex-start;
+    gap: 0.5rem;
+    padding: 0.5rem 0.75rem;
+    border: none;
+    border-bottom: 1px solid color-mix(in srgb, var(--ctp-surface1) 50%, transparent);
+    background: transparent;
+    width: 100%;
+    text-align: left;
+    cursor: pointer;
+    font: inherit;
+    color: var(--ctp-subtext0);
+    transition: background 0.1s;
+  }
+
+  .notification-item:hover {
+    background: color-mix(in srgb, var(--ctp-surface1) 40%, transparent);
+  }
+
+  .notification-item.unread {
+    background: color-mix(in srgb, var(--ctp-blue) 5%, transparent);
+    color: var(--ctp-text);
+  }
+
+  .notif-icon {
+    font-size: 0.75rem;
+    flex-shrink: 0;
+    width: 1rem;
+    text-align: center;
+    padding-top: 0.0625rem;
+  }
+
+  .notif-content {
+    flex: 1;
+    min-width: 0;
+    display: flex;
+    flex-direction: column;
+    gap: 0.125rem;
+  }
+
+  .notif-title {
+    font-size: 0.6875rem;
+    font-weight: 600;
+    color: inherit;
+  }
+
+  .notif-body {
+    font-size: 0.625rem;
+    color: var(--ctp-subtext0);
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+  }
+
+  .unread .notif-body {
+    color: var(--ctp-overlay1);
+  }
+
+  .notif-time {
+    font-size: 0.5625rem;
+    color: var(--ctp-overlay0);
+    white-space: nowrap;
+    flex-shrink: 0;
+    padding-top: 0.0625rem;
+  }
+</style>
diff --git a/v2/src/lib/components/Notifications/ToastContainer.svelte b/v2/src/lib/components/Notifications/ToastContainer.svelte
new file mode 100644
index 0000000..2602b16
--- /dev/null
+++ b/v2/src/lib/components/Notifications/ToastContainer.svelte
@@ -0,0 +1,94 @@
+<script lang="ts">
+  import { getNotifications, dismissNotification } from '../../stores/notifications.svelte';
+
+  let toasts = $derived(getNotifications());
+</script>
+
+{#if toasts.length > 0}
+  <div class="toast-container">
+    {#each toasts as toast (toast.id)}
+      <div class="toast toast-{toast.type}" role="alert">
+        <span class="toast-icon">
+          {#if toast.type === 'success'}✓
+          {:else if toast.type === 'error'}✕
+          {:else if toast.type === 'warning'}!
+          {:else}i
+          {/if}
+        </span>
+        <span class="toast-message">{toast.message}</span>
+        <button class="toast-close" onclick={() => dismissNotification(toast.id)}>&times;</button>
+      </div>
+    {/each}
+  </div>
+{/if}
+
+<style>
+  .toast-container {
+    position: fixed;
+    top: 0.75rem;
+    right: 0.75rem;
+    z-index: 9999;
+    display: flex;
+    flex-direction: column;
+    gap: 0.375rem;
+    max-width: 22.5rem;
+  }
+
+  .toast {
+    display: flex;
+    align-items: center;
+    gap: 0.5rem;
+    padding: 0.5rem 0.75rem;
+    border-radius: var(--border-radius);
+    font-size: 0.75rem;
+    color: var(--text-primary);
+    background: var(--bg-surface);
+    border: 1px solid var(--border);
+    box-shadow: 0 4px 12px rgba(0, 0, 0, 0.3);
+    animation: slide-in 0.2s ease-out;
+  }
+
+  @keyframes slide-in {
+    from { opacity: 0; transform: translateX(20px); }
+    to { opacity: 1; transform: translateX(0); }
+  }
+
+  .toast-icon {
+    width: 18px;
+    height: 18px;
+    border-radius: 50%;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    font-size: 0.625rem;
+    font-weight: 700;
+    flex-shrink: 0;
+  }
+
+  .toast-success .toast-icon { background: var(--ctp-green); color: var(--ctp-crust); }
+  .toast-error .toast-icon { background: var(--ctp-red); color: var(--ctp-crust); }
+  .toast-warning .toast-icon { background: var(--ctp-yellow); color: var(--ctp-crust); }
+  .toast-info .toast-icon { background: var(--ctp-blue); color: var(--ctp-crust); }
+
+  .toast-success { border-color: color-mix(in srgb, var(--ctp-green) 30%, transparent); }
+  .toast-error { border-color: color-mix(in srgb, var(--ctp-red) 30%, transparent); }
+  .toast-warning { border-color: color-mix(in srgb, var(--ctp-yellow) 30%, transparent); }
+  .toast-info { border-color: color-mix(in srgb, var(--ctp-blue) 30%, transparent); }
+
+  .toast-message {
+    flex: 1;
+    line-height: 1.3;
+  }
+
+  .toast-close {
+    background: none;
+    border: none;
+    color: var(--text-muted);
+    cursor: pointer;
+    font-size: 0.875rem;
+    padding: 0 0.125rem;
+    flex-shrink: 0;
+  }
+
+  .toast-close:hover { color: var(--text-primary); }
+</style>
diff --git a/v2/src/lib/components/StatusBar/StatusBar.svelte b/v2/src/lib/components/StatusBar/StatusBar.svelte
new file mode 100644
index 0000000..fd33dd6
--- /dev/null
+++ b/v2/src/lib/components/StatusBar/StatusBar.svelte
@@ -0,0 +1,375 @@
+<script lang="ts">
+  import { getAgentSessions } from '../../stores/agents.svelte';
+  import { getActiveGroup, getEnabledProjects, setActiveProject } from '../../stores/workspace.svelte';
+  import { getHealthAggregates, getAttentionQueue, type ProjectHealth } from '../../stores/health.svelte';
+  import { getTotalConflictCount } from '../../stores/conflicts.svelte';
+  import { onMount } from 'svelte';
+  import { checkForUpdates, installUpdate, type UpdateInfo } from '../../utils/updater';
+  import { message as dialogMessage, confirm } from '@tauri-apps/plugin-dialog';
+  import NotificationCenter from '../Notifications/NotificationCenter.svelte';
+
+  let agentSessions = $derived(getAgentSessions());
+  let activeGroup = $derived(getActiveGroup());
+  let enabledProjects = $derived(getEnabledProjects());
+
+  let totalCost = $derived(agentSessions.reduce((sum, s) => sum + s.costUsd, 0));
+  let totalTokens = $derived(agentSessions.reduce((sum, s) => sum + s.inputTokens + s.outputTokens, 0));
+  let projectCount = $derived(enabledProjects.length);
+
+  // Health-derived signals
+  let health = $derived(getHealthAggregates());
+  let attentionQueue = $derived(getAttentionQueue(5));
+
+  let totalConflicts = $derived(getTotalConflictCount());
+  let showAttention = $state(false);
+
+  // Auto-update state
+  let updateInfo = $state<UpdateInfo | null>(null);
+  let installing = $state(false);
+
+  onMount(() => {
+    // Check for updates 10s after startup
+    const timer = setTimeout(async () => {
+      const info = await checkForUpdates();
+      if (info.available) updateInfo = info;
+    }, 10_000);
+    return () => clearTimeout(timer);
+  });
+
+  async function handleUpdateClick() {
+    if (!updateInfo) return;
+    const notes = updateInfo.notes
+      ? `Release notes:\n\n${updateInfo.notes}\n\nInstall and restart?`
+      : `Install v${updateInfo.version} and restart?`;
+    const confirmed = await confirm(notes, { title: `Update available: v${updateInfo.version}`, kind: 'info' });
+    if (confirmed) {
+      installing = true;
+      try {
+        await installUpdate();
+      } catch {
+        installing = false;
+      }
+    }
+  }
+
+  function projectName(projectId: string): string {
+    return enabledProjects.find(p => p.id === projectId)?.name ?? projectId.slice(0, 8);
+  }
+
+  function focusProject(projectId: string) {
+    setActiveProject(projectId);
+    showAttention = false;
+  }
+
+  function formatRate(rate: number): string {
+    if (rate < 0.01) return '$0/hr';
+    if (rate < 1) return `$${rate.toFixed(2)}/hr`;
+    return `$${rate.toFixed(1)}/hr`;
+  }
+
+  function attentionColor(item: ProjectHealth): string {
+    if (item.attentionScore >= 90) return 'var(--ctp-red)';
+    if (item.attentionScore >= 70) return 'var(--ctp-peach)';
+    if (item.attentionScore >= 40) return 'var(--ctp-yellow)';
+    return 'var(--ctp-overlay1)';
+  }
+</script>
+
+<div class="status-bar" data-testid="status-bar">
+  <div class="left">
+    {#if activeGroup}
+      <span class="item group-name" title="Active group">{activeGroup.name}</span>
+      <span class="sep"></span>
+    {/if}
+    <span class="item" title="Enabled projects">{projectCount} projects</span>
+    <span class="sep"></span>
+
+    <!-- Agent states from health store -->
+    {#if health.running > 0}
+      <span class="item state-running" title="Running agents">
+        <span class="pulse"></span>
+        {health.running} running
+      </span>
+      <span class="sep"></span>
+    {/if}
+    {#if health.idle > 0}
+      <span class="item state-idle" title="Idle agents">{health.idle} idle</span>
+      <span class="sep"></span>
+    {/if}
+    {#if health.stalled > 0}
+      <span class="item state-stalled" title="Stalled agents (>15 min inactive)">
+        {health.stalled} stalled
+      </span>
+      <span class="sep"></span>
+    {/if}
+    {#if totalConflicts > 0}
+      <span class="item state-conflict" title="{totalConflicts} file conflict{totalConflicts > 1 ? 's' : ''} — multiple agents writing same file">
+        ⚠ {totalConflicts} conflict{totalConflicts > 1 ? 's' : ''}
+      </span>
+      <span class="sep"></span>
+    {/if}
+
+    <!-- Attention queue toggle -->
+    {#if attentionQueue.length > 0}
+      <button
+        class="item attention-btn"
+        class:attention-open={showAttention}
+        onclick={() => showAttention = !showAttention}
+        title="Needs attention — click to expand"
+      >
+        <span class="attention-dot"></span>
+        {attentionQueue.length} need attention
+      </button>
+    {/if}
+  </div>
+
+  <div class="right">
+    {#if health.totalBurnRatePerHour > 0}
+      <span class="item burn-rate" title="Total burn rate across active sessions">
+        {formatRate(health.totalBurnRatePerHour)}
+      </span>
+      <span class="sep"></span>
+    {/if}
+    {#if totalTokens > 0}
+      <span class="item tokens">{totalTokens.toLocaleString()} tok</span>
+      <span class="sep"></span>
+    {/if}
+    {#if totalCost > 0}
+      <span class="item cost">${totalCost.toFixed(4)}</span>
+      <span class="sep"></span>
+    {/if}
+    <NotificationCenter />
+    <span class="sep"></span>
+    {#if updateInfo?.available}
+      <button
+        class="item update-btn"
+        onclick={handleUpdateClick}
+        disabled={installing}
+        title="Click to install v{updateInfo.version}"
+      >
+        {#if installing}
+          Installing...
+        {:else}
+          Update v{updateInfo.version}
+        {/if}
+      </button>
+      <span class="sep"></span>
+    {/if}
+    <span class="item version">BTerminal v3</span>
+  </div>
+</div>
+
+<!-- Attention queue dropdown -->
+{#if showAttention && attentionQueue.length > 0}
+  <div class="attention-panel">
+    {#each attentionQueue as item (item.projectId)}
+      <button
+        class="attention-card"
+        onclick={() => focusProject(item.projectId)}
+      >
+        <span class="card-name">{projectName(item.projectId)}</span>
+        <span class="card-reason" style="color: {attentionColor(item)}">{item.attentionReason}</span>
+        {#if item.contextPressure !== null && item.contextPressure > 0.5}
+          <span class="card-ctx" title="Context usage">ctx {Math.round(item.contextPressure * 100)}%</span>
+        {/if}
+      </button>
+    {/each}
+  </div>
+{/if}
+
+<style>
+  .status-bar {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    height: 1.5rem;
+    padding: 0 0.625rem;
+    background: var(--ctp-mantle);
+    border-top: 1px solid var(--ctp-surface0);
+    font-size: 0.6875rem;
+    color: var(--ctp-overlay1);
+    font-family: 'JetBrains Mono', monospace;
+    user-select: none;
+    flex-shrink: 0;
+    position: relative;
+  }
+
+  .left, .right {
+    display: flex;
+    align-items: center;
+    gap: 0.375rem;
+  }
+
+  .sep {
+    width: 1px;
+    height: 0.625rem;
+    background: var(--ctp-surface1);
+  }
+
+  .item {
+    display: flex;
+    align-items: center;
+    gap: 0.25rem;
+  }
+
+  .group-name {
+    color: var(--ctp-blue);
+    font-weight: 600;
+  }
+
+  /* Agent state indicators */
+  .state-running {
+    color: var(--ctp-green);
+  }
+
+  .state-idle {
+    color: var(--ctp-overlay1);
+  }
+
+  .state-stalled {
+    color: var(--ctp-peach);
+    font-weight: 600;
+  }
+
+  .state-conflict {
+    color: var(--ctp-red);
+    font-weight: 600;
+  }
+
+  .pulse {
+    width: 6px;
+    height: 6px;
+    border-radius: 50%;
+    background: var(--ctp-green);
+    animation: pulse 1.5s ease-in-out infinite;
+  }
+
+  @keyframes pulse {
+    0%, 100% { opacity: 1; }
+    50% { opacity: 0.3; }
+  }
+
+  /* Attention button */
+  .attention-btn {
+    background: none;
+    border: none;
+    color: var(--ctp-peach);
+    font: inherit;
+    cursor: pointer;
+    display: flex;
+    align-items: center;
+    gap: 0.25rem;
+    padding: 0;
+    font-weight: 600;
+  }
+
+  .attention-btn:hover {
+    color: var(--ctp-red);
+  }
+
+  .attention-btn.attention-open {
+    color: var(--ctp-red);
+  }
+
+  .attention-dot {
+    width: 6px;
+    height: 6px;
+    border-radius: 50%;
+    background: var(--ctp-peach);
+    animation: pulse 1.5s ease-in-out infinite;
+  }
+
+  .attention-btn.attention-open .attention-dot,
+  .attention-btn:hover .attention-dot {
+    background: var(--ctp-red);
+  }
+
+  /* Burn rate */
+  .burn-rate {
+    color: var(--ctp-mauve);
+    font-weight: 600;
+  }
+
+  .tokens { color: var(--ctp-overlay1); }
+  .cost { color: var(--ctp-yellow); }
+  .version { color: var(--ctp-overlay0); }
+
+  /* Update badge */
+  .update-btn {
+    background: color-mix(in srgb, var(--ctp-green) 15%, transparent);
+    border: 1px solid var(--ctp-green);
+    border-radius: 0.25rem;
+    color: var(--ctp-green);
+    font: inherit;
+    font-size: 0.625rem;
+    font-weight: 600;
+    padding: 0 0.375rem;
+    cursor: pointer;
+    display: flex;
+    align-items: center;
+    gap: 0.25rem;
+    line-height: 1.25rem;
+  }
+
+  .update-btn:hover {
+    background: color-mix(in srgb, var(--ctp-green) 25%, transparent);
+  }
+
+  .update-btn:disabled {
+    opacity: 0.5;
+    cursor: default;
+  }
+
+  /* Attention panel dropdown */
+  .attention-panel {
+    position: absolute;
+    bottom: 1.5rem;
+    left: 0;
+    right: 0;
+    background: var(--ctp-surface0);
+    border-top: 1px solid var(--ctp-surface1);
+    display: flex;
+    gap: 1px;
+    padding: 0.25rem 0.5rem;
+    z-index: 100;
+    overflow-x: auto;
+  }
+
+  .attention-card {
+    display: flex;
+    align-items: center;
+    gap: 0.5rem;
+    padding: 0.25rem 0.5rem;
+    background: var(--ctp-base);
+    border: 1px solid var(--ctp-surface1);
+    border-radius: 0.25rem;
+    color: var(--ctp-text);
+    font: inherit;
+    font-size: 0.6875rem;
+    cursor: pointer;
+    white-space: nowrap;
+    flex-shrink: 0;
+  }
+
+  .attention-card:hover {
+    background: var(--ctp-surface0);
+    border-color: var(--ctp-surface2);
+  }
+
+  .card-name {
+    font-weight: 600;
+    color: var(--ctp-text);
+  }
+
+  .card-reason {
+    font-size: 0.625rem;
+  }
+
+  .card-ctx {
+    font-size: 0.5625rem;
+    color: var(--ctp-overlay0);
+    background: color-mix(in srgb, var(--ctp-yellow) 10%, transparent);
+    padding: 0 0.25rem;
+    border-radius: 0.125rem;
+  }
+</style>
diff --git a/v2/src/lib/components/Terminal/AgentPreviewPane.svelte b/v2/src/lib/components/Terminal/AgentPreviewPane.svelte
new file mode 100644
index 0000000..f65bb90
--- /dev/null
+++ b/v2/src/lib/components/Terminal/AgentPreviewPane.svelte
@@ -0,0 +1,197 @@
+<script lang="ts">
+  import { onMount, onDestroy } from 'svelte';
+  import { Terminal } from '@xterm/xterm';
+  import { CanvasAddon } from '@xterm/addon-canvas';
+  import { FitAddon } from '@xterm/addon-fit';
+  import { getXtermTheme, onThemeChange } from '../../stores/theme.svelte';
+  import { getAgentSession } from '../../stores/agents.svelte';
+  import type {
+    ToolCallContent,
+    ToolResultContent,
+    InitContent,
+    CostContent,
+    ErrorContent,
+    TextContent,
+    AgentMessage,
+  } from '../../adapters/claude-messages';
+  import '@xterm/xterm/css/xterm.css';
+
+  interface Props {
+    sessionId: string;
+  }
+
+  let { sessionId }: Props = $props();
+
+  let terminalEl: HTMLDivElement;
+  let term: Terminal;
+  let fitAddon: FitAddon;
+  let resizeObserver: ResizeObserver | null = null;
+  let unsubTheme: (() => void) | null = null;
+
+  /** Track how many messages we've already rendered */
+  let renderedCount = 0;
+
+  let session = $derived(getAgentSession(sessionId));
+
+  // Watch for new messages and render them
+  $effect(() => {
+    if (!session || !term) return;
+    const msgs = session.messages;
+    if (msgs.length <= renderedCount) return;
+
+    const newMsgs = msgs.slice(renderedCount);
+    for (const msg of newMsgs) {
+      renderMessage(msg);
+    }
+    renderedCount = msgs.length;
+  });
+
+  // Reset when sessionId changes
+  $effect(() => {
+    // Access sessionId to track it
+    void sessionId;
+    renderedCount = 0;
+    if (term) {
+      term.clear();
+      term.write('\x1b[90m● Watching agent activity...\x1b[0m\r\n');
+    }
+  });
+
+  function renderMessage(msg: AgentMessage) {
+    switch (msg.type) {
+      case 'init': {
+        const c = msg.content as InitContent;
+        term.write(`\x1b[32m● Session started\x1b[0m \x1b[90m(${c.model})\x1b[0m\r\n`);
+        break;
+      }
+      case 'tool_call': {
+        const tc = msg.content as ToolCallContent;
+        if (tc.name === 'Bash') {
+          const cmd = (tc.input as { command?: string })?.command ?? '';
+          term.write(`\r\n\x1b[36m❯ ${escapeForTerminal(cmd)}\x1b[0m\r\n`);
+        } else if (tc.name === 'Read' || tc.name === 'Write' || tc.name === 'Edit') {
+          const input = tc.input as { file_path?: string };
+          const path = input?.file_path ?? '';
+          term.write(`\x1b[33m[${tc.name}]\x1b[0m \x1b[90m${escapeForTerminal(path)}\x1b[0m\r\n`);
+        } else if (tc.name === 'Grep' || tc.name === 'Glob') {
+          const input = tc.input as { pattern?: string };
+          const pattern = input?.pattern ?? '';
+          term.write(`\x1b[33m[${tc.name}]\x1b[0m \x1b[90m${escapeForTerminal(pattern)}\x1b[0m\r\n`);
+        } else {
+          term.write(`\x1b[33m[${tc.name}]\x1b[0m\r\n`);
+        }
+        break;
+      }
+      case 'tool_result': {
+        const tr = msg.content as ToolResultContent;
+        const output = typeof tr.output === 'string'
+          ? tr.output
+          : JSON.stringify(tr.output, null, 2);
+        if (output) {
+          // Truncate long outputs (show first 80 lines)
+          const lines = output.split('\n');
+          const truncated = lines.length > 80;
+          const display = truncated ? lines.slice(0, 80).join('\n') : output;
+          term.write(escapeForTerminal(display));
+          if (!display.endsWith('\n')) term.write('\r\n');
+          if (truncated) {
+            term.write(`\x1b[90m... (${lines.length - 80} more lines)\x1b[0m\r\n`);
+          }
+        }
+        break;
+      }
+      case 'text': {
+        const tc = msg.content as TextContent;
+        // Show brief text indicator (first line only)
+        const firstLine = tc.text.split('\n')[0].slice(0, 120);
+        term.write(`\x1b[37m${escapeForTerminal(firstLine)}\x1b[0m\r\n`);
+        break;
+      }
+      case 'error': {
+        const ec = msg.content as ErrorContent;
+        term.write(`\x1b[31m✗ ${escapeForTerminal(ec.message)}\x1b[0m\r\n`);
+        break;
+      }
+      case 'cost': {
+        const cc = msg.content as CostContent;
+        const cost = cc.totalCostUsd.toFixed(4);
+        const dur = (cc.durationMs / 1000).toFixed(1);
+        term.write(`\r\n\x1b[90m● Session complete ($${cost}, ${dur}s, ${cc.numTurns} turns)\x1b[0m\r\n`);
+        break;
+      }
+      // Skip thinking, status, unknown
+    }
+  }
+
+  /** Escape text for xterm — convert \n to \r\n */
+  function escapeForTerminal(text: string): string {
+    return text.replace(/\r?\n/g, '\r\n');
+  }
+
+  onMount(() => {
+    term = new Terminal({
+      theme: getXtermTheme(),
+      fontFamily: "'JetBrains Mono', 'Fira Code', 'Cascadia Code', monospace",
+      fontSize: 13,
+      lineHeight: 1.2,
+      cursorBlink: false,
+      cursorStyle: 'underline',
+      scrollback: 10000,
+      allowProposedApi: true,
+      disableStdin: true,
+    });
+
+    fitAddon = new FitAddon();
+    term.loadAddon(fitAddon);
+    term.loadAddon(new CanvasAddon());
+    term.open(terminalEl);
+    fitAddon.fit();
+
+    term.write('\x1b[90m● Watching agent activity...\x1b[0m\r\n');
+
+    // If session already has messages, render them
+    const s = getAgentSession(sessionId);
+    if (s && s.messages.length > 0) {
+      for (const msg of s.messages) {
+        renderMessage(msg);
+      }
+      renderedCount = s.messages.length;
+    }
+
+    // Resize handling with debounce
+    let resizeTimer: ReturnType<typeof setTimeout>;
+    resizeObserver = new ResizeObserver(() => {
+      clearTimeout(resizeTimer);
+      resizeTimer = setTimeout(() => {
+        fitAddon.fit();
+      }, 100);
+    });
+    resizeObserver.observe(terminalEl);
+
+    // Hot-swap theme
+    unsubTheme = onThemeChange(() => {
+      term.options.theme = getXtermTheme();
+    });
+  });
+
+  onDestroy(() => {
+    resizeObserver?.disconnect();
+    unsubTheme?.();
+    term?.dispose();
+  });
+</script>
+
+<div class="agent-preview-container" bind:this={terminalEl}></div>
+
+<style>
+  .agent-preview-container {
+    width: 100%;
+    height: 100%;
+    overflow: hidden;
+  }
+
+  .agent-preview-container :global(.xterm) {
+    height: 100%;
+    padding: 0.25rem;
+  }
+</style>
diff --git a/v2/src/lib/components/Terminal/TerminalPane.svelte b/v2/src/lib/components/Terminal/TerminalPane.svelte
new file mode 100644
index 0000000..258c352
--- /dev/null
+++ b/v2/src/lib/components/Terminal/TerminalPane.svelte
@@ -0,0 +1,134 @@
+<script lang="ts">
+  import { onMount, onDestroy } from 'svelte';
+  import { Terminal } from '@xterm/xterm';
+  import { CanvasAddon } from '@xterm/addon-canvas';
+  import { FitAddon } from '@xterm/addon-fit';
+  import { spawnPty, writePty, resizePty, killPty, onPtyData, onPtyExit } from '../../adapters/pty-bridge';
+  import { getXtermTheme, onThemeChange } from '../../stores/theme.svelte';
+  import type { UnlistenFn } from '@tauri-apps/api/event';
+  import '@xterm/xterm/css/xterm.css';
+
+  interface Props {
+    shell?: string;
+    cwd?: string;
+    args?: string[];
+    onExit?: () => void;
+  }
+
+  let { shell, cwd, args, onExit }: Props = $props();
+
+  let terminalEl: HTMLDivElement;
+  let term: Terminal;
+  let fitAddon: FitAddon;
+  let ptyId: string | null = null;
+  let unlistenData: UnlistenFn | null = null;
+  let unlistenExit: UnlistenFn | null = null;
+  let resizeObserver: ResizeObserver | null = null;
+  let unsubTheme: (() => void) | null = null;
+
+  onMount(async () => {
+    term = new Terminal({
+      theme: getXtermTheme(),
+      fontFamily: "'JetBrains Mono', 'Fira Code', 'Cascadia Code', monospace",
+      fontSize: 13,
+      lineHeight: 1.2,
+      cursorBlink: true,
+      cursorStyle: 'block',
+      scrollback: 10000,
+      allowProposedApi: true,
+    });
+
+    fitAddon = new FitAddon();
+    term.loadAddon(fitAddon);
+    term.loadAddon(new CanvasAddon());
+    term.open(terminalEl);
+    fitAddon.fit();
+
+    const { cols, rows } = term;
+
+    // Spawn PTY
+    try {
+      ptyId = await spawnPty({ shell, cwd, args, cols, rows });
+
+      // Listen for PTY output
+      unlistenData = await onPtyData(ptyId, (data) => {
+        term.write(data);
+      });
+
+      unlistenExit = await onPtyExit(ptyId, () => {
+        term.write('\r\n\x1b[90m[Process exited]\x1b[0m\r\n');
+        onExit?.();
+      });
+
+      // Copy/paste via Ctrl+Shift+C/V
+      term.attachCustomKeyEventHandler((e: KeyboardEvent) => {
+        if (e.ctrlKey && e.shiftKey && e.type === 'keydown') {
+          if (e.key === 'C') {
+            const selection = term.getSelection();
+            if (selection) navigator.clipboard.writeText(selection);
+            return false;
+          }
+          if (e.key === 'V') {
+            navigator.clipboard.readText().then(text => {
+              if (text && ptyId) writePty(ptyId, text);
+            });
+            return false;
+          }
+        }
+        return true;
+      });
+
+      // Forward keyboard input to PTY
+      term.onData((data) => {
+        if (ptyId) writePty(ptyId, data);
+      });
+    } catch (e) {
+      term.write(`\x1b[31mFailed to spawn terminal: ${e}\x1b[0m\r\n`);
+    }
+
+    // Resize handling with debounce
+    let resizeTimer: ReturnType<typeof setTimeout>;
+    resizeObserver = new ResizeObserver(() => {
+      clearTimeout(resizeTimer);
+      resizeTimer = setTimeout(() => {
+        fitAddon.fit();
+        if (ptyId) {
+          const { cols, rows } = term;
+          resizePty(ptyId, cols, rows);
+        }
+      }, 100);
+    });
+    resizeObserver.observe(terminalEl);
+
+    // Hot-swap theme when flavor changes
+    unsubTheme = onThemeChange(() => {
+      term.options.theme = getXtermTheme();
+    });
+  });
+
+  onDestroy(async () => {
+    resizeObserver?.disconnect();
+    unsubTheme?.();
+    unlistenData?.();
+    unlistenExit?.();
+    if (ptyId) {
+      try { await killPty(ptyId); } catch { /* already dead */ }
+    }
+    term?.dispose();
+  });
+</script>
+
+<div class="terminal-container" bind:this={terminalEl}></div>
+
+<style>
+  .terminal-container {
+    width: 100%;
+    height: 100%;
+    overflow: hidden;
+  }
+
+  .terminal-container :global(.xterm) {
+    height: 100%;
+    padding: 0.25rem;
+  }
+</style>
diff --git a/v2/src/lib/components/Workspace/AgentCard.svelte b/v2/src/lib/components/Workspace/AgentCard.svelte
new file mode 100644
index 0000000..e511f5e
--- /dev/null
+++ b/v2/src/lib/components/Workspace/AgentCard.svelte
@@ -0,0 +1,100 @@
+<script lang="ts">
+  import type { AgentSession } from '../../stores/agents.svelte';
+
+  interface Props {
+    session: AgentSession;
+    onclick?: () => void;
+  }
+
+  let { session, onclick }: Props = $props();
+
+  let statusColor = $derived(
+    session.status === 'running' ? 'var(--ctp-green)' :
+    session.status === 'done' ? 'var(--ctp-blue)' :
+    session.status === 'error' ? 'var(--ctp-red)' :
+    'var(--ctp-overlay0)'
+  );
+
+  let truncatedPrompt = $derived(
+    session.prompt.length > 60
+      ? session.prompt.slice(0, 60) + '...'
+      : session.prompt
+  );
+</script>
+
+<div class="agent-card" role="button" tabindex="0" {onclick} onkeydown={e => e.key === 'Enter' && onclick?.()}>
+  <div class="card-header">
+    <span class="status-dot" style="background: {statusColor}"></span>
+    <span class="agent-status">{session.status}</span>
+    {#if session.costUsd > 0}
+      <span class="agent-cost">${session.costUsd.toFixed(4)}</span>
+    {/if}
+  </div>
+  <div class="card-prompt">{truncatedPrompt}</div>
+  {#if session.status === 'running'}
+    <div class="card-progress">
+      <span class="turns">{session.numTurns} turns</span>
+    </div>
+  {/if}
+</div>
+
+<style>
+  .agent-card {
+    padding: 0.375rem 0.5rem;
+    background: var(--ctp-surface0);
+    border-radius: 0.25rem;
+    cursor: pointer;
+    transition: background 0.1s;
+    border-left: 2px solid transparent;
+  }
+
+  .agent-card:hover {
+    background: var(--ctp-surface1);
+  }
+
+  .card-header {
+    display: flex;
+    align-items: center;
+    gap: 0.25rem;
+    margin-bottom: 0.1875rem;
+  }
+
+  .status-dot {
+    width: 6px;
+    height: 6px;
+    border-radius: 50%;
+    flex-shrink: 0;
+  }
+
+  .agent-status {
+    font-size: 0.65rem;
+    color: var(--ctp-overlay1);
+    text-transform: uppercase;
+    letter-spacing: 0.03em;
+  }
+
+  .agent-cost {
+    margin-left: auto;
+    font-size: 0.65rem;
+    color: var(--ctp-overlay0);
+    font-family: monospace;
+  }
+
+  .card-prompt {
+    font-size: 0.72rem;
+    color: var(--ctp-subtext0);
+    line-height: 1.3;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+  }
+
+  .card-progress {
+    margin-top: 0.1875rem;
+  }
+
+  .turns {
+    font-size: 0.65rem;
+    color: var(--ctp-overlay0);
+  }
+</style>
diff --git a/v2/src/lib/components/Workspace/AgentSession.svelte b/v2/src/lib/components/Workspace/AgentSession.svelte
new file mode 100644
index 0000000..73cd65c
--- /dev/null
+++ b/v2/src/lib/components/Workspace/AgentSession.svelte
@@ -0,0 +1,276 @@
+<script lang="ts">
+  import { onDestroy } from 'svelte';
+  import type { ProjectConfig, GroupAgentRole } from '../../types/groups';
+  import { generateAgentPrompt } from '../../utils/agent-prompts';
+  import { getActiveGroup } from '../../stores/workspace.svelte';
+  import { logAuditEvent } from '../../adapters/audit-bridge';
+  import type { AgentId } from '../../types/ids';
+  import {
+    loadProjectAgentState,
+    loadAgentMessages,
+    type ProjectAgentState,
+    type AgentMessageRecord,
+  } from '../../adapters/groups-bridge';
+  import { registerSessionProject } from '../../agent-dispatcher';
+  import { trackProject, updateProjectSession } from '../../stores/health.svelte';
+  import {
+    createAgentSession,
+    appendAgentMessages,
+    updateAgentCost,
+    updateAgentStatus,
+    setAgentSdkSessionId,
+    getAgentSession,
+  } from '../../stores/agents.svelte';
+  import type { AgentMessage } from '../../adapters/claude-messages';
+  import { getProvider, getDefaultProviderId } from '../../providers/registry.svelte';
+  import { loadAnchorsForProject } from '../../stores/anchors.svelte';
+  import { getWakeEvent, consumeWakeEvent, updateManagerSession } from '../../stores/wake-scheduler.svelte';
+  import { SessionId, ProjectId } from '../../types/ids';
+  import AgentPane from '../Agent/AgentPane.svelte';
+
+  /** How often to re-inject the system prompt (default 1 hour) */
+  const REINJECTION_INTERVAL_MS = 60 * 60 * 1000;
+
+  interface Props {
+    project: ProjectConfig;
+    onsessionid?: (id: string) => void;
+  }
+
+  let { project, onsessionid }: Props = $props();
+
+  let providerId = $derived(project.provider ?? getDefaultProviderId());
+  let providerMeta = $derived(getProvider(providerId));
+  let group = $derived(getActiveGroup());
+  // Build system prompt: full agent prompt for Tier 1, custom context for Tier 2
+  let agentPrompt = $derived.by(() => {
+    if (project.isAgent && project.agentRole && group) {
+      return generateAgentPrompt({
+        role: project.agentRole as GroupAgentRole,
+        agentId: project.id,
+        agentName: project.name,
+        group,
+        customPrompt: project.systemPrompt,
+      });
+    }
+    // Tier 2: pass custom context directly (if set)
+    return project.systemPrompt || undefined;
+  });
+
+  // Inject BTMSG_AGENT_ID for agent projects so they can use btmsg/bttask CLIs
+  // Manager agents also get CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS to enable subagent delegation
+  let agentEnv = $derived.by(() => {
+    if (!project.isAgent) return undefined;
+    const env: Record<string, string> = { BTMSG_AGENT_ID: project.id };
+    if (project.agentRole === 'manager') {
+      env.CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS = '1';
+    }
+    return env;
+  });
+
+  // Periodic context re-injection timer
+  let lastPromptTime = $state(Date.now());
+  let contextRefreshPrompt = $state<string | undefined>(undefined);
+  let reinjectionTimer: ReturnType<typeof setInterval> | null = null;
+
+  function startReinjectionTimer() {
+    if (reinjectionTimer) clearInterval(reinjectionTimer);
+    lastPromptTime = Date.now();
+    reinjectionTimer = setInterval(() => {
+      const elapsed = Date.now() - lastPromptTime;
+      if (elapsed >= REINJECTION_INTERVAL_MS && !contextRefreshPrompt) {
+        const refreshMsg = project.isAgent
+          ? '[Context Refresh] Review your role and available tools above. Check your inbox with `btmsg inbox` and review the task board with `bttask board`.'
+          : '[Context Refresh] Review the instructions above and continue your work.';
+        contextRefreshPrompt = refreshMsg;
+        // Audit: log prompt injection event
+        logAuditEvent(
+          project.id as unknown as AgentId,
+          'prompt_injection',
+          `Context refresh triggered after ${Math.floor(elapsed / 60_000)} min idle`,
+        ).catch(() => {});
+      }
+    }, 60_000); // Check every minute
+  }
+
+  function handleAutoPromptConsumed() {
+    contextRefreshPrompt = undefined;
+    lastPromptTime = Date.now();
+  }
+
+  // Start timer and clean up
+  startReinjectionTimer();
+  onDestroy(() => {
+    if (reinjectionTimer) clearInterval(reinjectionTimer);
+    if (wakeCheckTimer) clearInterval(wakeCheckTimer);
+  });
+
+  // Wake scheduler integration — poll for wake events (Manager agents only)
+  let wakeCheckTimer: ReturnType<typeof setInterval> | null = null;
+  const isManager = $derived(project.isAgent && project.agentRole === 'manager');
+
+  function startWakeCheck() {
+    if (wakeCheckTimer) clearInterval(wakeCheckTimer);
+    if (!isManager) return;
+    wakeCheckTimer = setInterval(() => {
+      if (contextRefreshPrompt) return; // Don't queue if already has a pending prompt
+      const event = getWakeEvent(project.id);
+      if (!event) return;
+
+      if (event.mode === 'fresh') {
+        // On-demand / Smart: reset session, inject wake context as initial prompt
+        handleNewSession();
+        contextRefreshPrompt = buildWakePrompt(event.context.evaluation.summary);
+      } else {
+        // Persistent: resume existing session with wake context
+        contextRefreshPrompt = buildWakePrompt(event.context.evaluation.summary);
+      }
+
+      consumeWakeEvent(project.id);
+    }, 5_000); // Check every 5s
+  }
+
+  function buildWakePrompt(summary: string): string {
+    return `[Auto-Wake] You have been woken by the auto-wake scheduler. Here is the current fleet status:\n\n${summary}\n\nCheck your inbox with \`btmsg inbox\` and review the task board with \`bttask board\`. Take action on any urgent items above.`;
+  }
+
+  // Start wake check when component mounts (for managers)
+  $effect(() => {
+    if (isManager) {
+      startWakeCheck();
+    } else if (wakeCheckTimer) {
+      clearInterval(wakeCheckTimer);
+      wakeCheckTimer = null;
+    }
+  });
+
+  let sessionId = $state(SessionId(crypto.randomUUID()));
+  let lastState = $state<ProjectAgentState | null>(null);
+  let loading = $state(true);
+  let hasRestoredHistory = $state(false);
+
+  function handleNewSession() {
+    sessionId = SessionId(crypto.randomUUID());
+    hasRestoredHistory = false;
+    lastState = null;
+    lastPromptTime = Date.now();
+    contextRefreshPrompt = undefined;
+    registerSessionProject(sessionId, ProjectId(project.id), providerId);
+    trackProject(ProjectId(project.id), sessionId);
+    // Notify wake scheduler of new session ID
+    if (isManager) updateManagerSession(project.id, sessionId);
+    onsessionid?.(sessionId);
+  }
+
+  // Load previous session state when project changes
+  $effect(() => {
+    const pid = project.id;
+    loadPreviousState(pid);
+  });
+
+  async function loadPreviousState(projectId: string) {
+    loading = true;
+    hasRestoredHistory = false;
+    try {
+      const state = await loadProjectAgentState(projectId);
+      lastState = state;
+      if (state?.last_session_id) {
+        sessionId = SessionId(state.last_session_id);
+
+        // Restore cached messages into the agent store
+        const records = await loadAgentMessages(projectId);
+        if (records.length > 0) {
+          restoreMessagesFromRecords(sessionId, state, records);
+          hasRestoredHistory = true;
+        }
+      } else {
+        sessionId = SessionId(crypto.randomUUID());
+      }
+    } catch (e) {
+      console.warn('Failed to load project agent state:', e);
+      sessionId = SessionId(crypto.randomUUID());
+    } finally {
+      loading = false;
+      // Load persisted anchors for this project
+      loadAnchorsForProject(ProjectId(project.id));
+      // Register session -> project mapping for persistence + health tracking
+      registerSessionProject(sessionId, ProjectId(project.id), providerId);
+      trackProject(ProjectId(project.id), sessionId);
+      onsessionid?.(sessionId);
+    }
+  }
+
+  function restoreMessagesFromRecords(
+    sid: string,
+    state: ProjectAgentState,
+    records: AgentMessageRecord[],
+  ) {
+    // Don't re-create if already exists
+    if (getAgentSession(sid)) return;
+
+    createAgentSession(sid, state.last_prompt ?? '');
+    if (state.sdk_session_id) {
+      setAgentSdkSessionId(sid, state.sdk_session_id);
+    }
+
+    // Convert records back to AgentMessage format
+    const messages: AgentMessage[] = records.map(r => ({
+      id: `restored-${r.id}`,
+      type: r.message_type as AgentMessage['type'],
+      content: JSON.parse(r.content),
+      parentId: r.parent_id ?? undefined,
+      timestamp: r.created_at ?? Date.now(),
+    }));
+
+    appendAgentMessages(sid, messages);
+    updateAgentCost(sid, {
+      costUsd: state.cost_usd,
+      inputTokens: state.input_tokens,
+      outputTokens: state.output_tokens,
+      numTurns: 0,
+      durationMs: 0,
+    });
+
+    // Mark as done (it's a restored completed session)
+    updateAgentStatus(sid, state.status === 'error' ? 'error' : 'done');
+  }
+</script>
+
+<div class="agent-session" data-testid="agent-session">
+  {#if loading}
+    <div class="loading-state">Loading session...</div>
+  {:else}
+    <AgentPane
+      {sessionId}
+      projectId={project.id}
+      cwd={project.cwd}
+      profile={project.profile || undefined}
+      provider={providerId}
+      capabilities={providerMeta?.capabilities}
+      useWorktrees={project.useWorktrees ?? false}
+      agentSystemPrompt={agentPrompt}
+      extraEnv={agentEnv}
+      autoPrompt={contextRefreshPrompt}
+      onautopromptconsumed={handleAutoPromptConsumed}
+      onExit={handleNewSession}
+    />
+  {/if}
+</div>
+
+<style>
+  .agent-session {
+    height: 100%;
+    overflow: hidden;
+    display: flex;
+    flex-direction: column;
+    flex: 1;
+  }
+
+  .loading-state {
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    height: 100%;
+    color: var(--ctp-overlay0);
+    font-size: 0.85rem;
+  }
+</style>
diff --git a/v2/src/lib/components/Workspace/ArchitectureTab.svelte b/v2/src/lib/components/Workspace/ArchitectureTab.svelte
new file mode 100644
index 0000000..ce2ef79
--- /dev/null
+++ b/v2/src/lib/components/Workspace/ArchitectureTab.svelte
@@ -0,0 +1,479 @@
+<script lang="ts">
+  import { onMount } from 'svelte';
+  import { listDirectoryChildren, readFileContent, writeFileContent, type DirEntry } from '../../adapters/files-bridge';
+
+  interface Props {
+    cwd: string;
+  }
+
+  let { cwd }: Props = $props();
+
+  /** Directory where .puml files are stored */
+  const ARCH_DIR = '.architecture';
+
+  let diagrams = $state<DirEntry[]>([]);
+  let selectedFile = $state<string | null>(null);
+  let pumlSource = $state('');
+  let svgUrl = $state<string | null>(null);
+  let loading = $state(false);
+  let error = $state<string | null>(null);
+  let editing = $state(false);
+
+  // New diagram form
+  let showNewForm = $state(false);
+  let newName = $state('');
+
+  const DIAGRAM_TEMPLATES: Record<string, string> = {
+    'Class Diagram': `@startuml
+title Class Diagram
+
+class Service {
+  +start()
+  +stop()
+}
+
+class Database {
+  +query()
+  +connect()
+}
+
+Service --> Database : uses
+
+@enduml`,
+    'Sequence Diagram': `@startuml
+title Sequence Diagram
+
+actor User
+participant "Frontend" as FE
+participant "Backend" as BE
+participant "Database" as DB
+
+User -> FE: action
+FE -> BE: request
+BE -> DB: query
+DB --> BE: result
+BE --> FE: response
+FE --> User: display
+
+@enduml`,
+    'State Diagram': `@startuml
+title State Diagram
+
+[*] --> Idle
+Idle --> Running : start
+Running --> Idle : stop
+Running --> Error : failure
+Error --> Idle : reset
+
+@enduml`,
+    'Component Diagram': `@startuml
+title Component Diagram
+
+package "Frontend" {
+  [UI Components]
+  [State Store]
+}
+
+package "Backend" {
+  [API Server]
+  [Database]
+}
+
+[UI Components] --> [State Store]
+[State Store] --> [API Server]
+[API Server] --> [Database]
+
+@enduml`,
+  };
+
+  let archPath = $derived(`${cwd}/${ARCH_DIR}`);
+
+  async function loadDiagrams() {
+    try {
+      const entries = await listDirectoryChildren(archPath);
+      diagrams = entries.filter(e => e.name.endsWith('.puml') || e.name.endsWith('.plantuml'));
+    } catch {
+      // Directory might not exist yet
+      diagrams = [];
+    }
+  }
+
+  onMount(() => {
+    loadDiagrams();
+  });
+
+  async function selectDiagram(filePath: string) {
+    selectedFile = filePath;
+    loading = true;
+    error = null;
+    editing = false;
+    try {
+      const content = await readFileContent(filePath);
+      if (content.type === 'Text') {
+        pumlSource = content.content;
+        renderPlantUml(content.content);
+      } else {
+        error = 'Not a text file';
+      }
+    } catch (e) {
+      error = String(e);
+    } finally {
+      loading = false;
+    }
+  }
+
+  function renderPlantUml(source: string) {
+    // Encode PlantUML source for the server renderer
+    const encoded = plantumlEncode(source);
+    svgUrl = `https://www.plantuml.com/plantuml/svg/${encoded}`;
+  }
+
+  async function handleSave() {
+    if (!selectedFile) return;
+    try {
+      await writeFileContent(selectedFile, pumlSource);
+      renderPlantUml(pumlSource);
+      editing = false;
+    } catch (e) {
+      error = String(e);
+    }
+  }
+
+  async function handleCreate(template: string) {
+    if (!newName.trim()) return;
+    const fileName = newName.trim().replace(/\s+/g, '-').toLowerCase();
+    const filePath = `${archPath}/${fileName}.puml`;
+    try {
+      await writeFileContent(filePath, template);
+      showNewForm = false;
+      newName = '';
+      await loadDiagrams();
+      await selectDiagram(filePath);
+    } catch (e) {
+      error = String(e);
+    }
+  }
+
+  // PlantUML hex encoding — uses the ~h prefix supported by plantuml.com
+  // See: https://plantuml.com/text-encoding
+  function plantumlEncode(text: string): string {
+    const bytes = unescape(encodeURIComponent(text));
+    let hex = '~h';
+    for (let i = 0; i < bytes.length; i++) {
+      hex += bytes.charCodeAt(i).toString(16).padStart(2, '0');
+    }
+    return hex;
+  }
+</script>
+
+<div class="architecture-tab">
+  <div class="arch-sidebar">
+    <div class="sidebar-header">
+      <span class="sidebar-title">Diagrams</span>
+      <button class="btn-new" onclick={() => showNewForm = !showNewForm}>
+        {showNewForm ? '✕' : '+'}
+      </button>
+    </div>
+
+    {#if showNewForm}
+      <div class="new-form">
+        <input
+          class="new-name-input"
+          bind:value={newName}
+          placeholder="Diagram name"
+        />
+        <div class="template-list">
+          {#each Object.entries(DIAGRAM_TEMPLATES) as [name, template]}
+            <button
+              class="template-btn"
+              onclick={() => handleCreate(template)}
+              disabled={!newName.trim()}
+            >{name}</button>
+          {/each}
+        </div>
+      </div>
+    {/if}
+
+    <div class="diagram-list">
+      {#each diagrams as file (file.path)}
+        <button
+          class="diagram-item"
+          class:active={selectedFile === file.path}
+          onclick={() => selectDiagram(file.path)}
+        >
+          <span class="diagram-icon">📐</span>
+          <span class="diagram-name">{file.name.replace(/\.(puml|plantuml)$/, '')}</span>
+        </button>
+      {/each}
+      {#if diagrams.length === 0 && !showNewForm}
+        <div class="empty-hint">
+          No diagrams yet. The Architect agent creates .puml files in <code>{ARCH_DIR}/</code>
+        </div>
+      {/if}
+    </div>
+  </div>
+
+  <div class="arch-content">
+    {#if !selectedFile}
+      <div class="empty-state">
+        Select a diagram or create a new one
+      </div>
+    {:else if loading}
+      <div class="empty-state">Loading...</div>
+    {:else if error}
+      <div class="empty-state error-text">{error}</div>
+    {:else}
+      <div class="content-header">
+        <span class="file-name">{selectedFile?.split('/').pop()}</span>
+        <button class="btn-toggle-edit" onclick={() => editing = !editing}>
+          {editing ? 'Preview' : 'Edit'}
+        </button>
+        {#if editing}
+          <button class="btn-save" onclick={handleSave}>Save</button>
+        {/if}
+      </div>
+
+      {#if editing}
+        <textarea
+          class="puml-editor"
+          bind:value={pumlSource}
+        ></textarea>
+      {:else if svgUrl}
+        <div class="diagram-preview">
+          <img src={svgUrl} alt="PlantUML diagram" class="diagram-img" />
+        </div>
+      {/if}
+    {/if}
+  </div>
+</div>
+
+<style>
+  .architecture-tab {
+    display: flex;
+    height: 100%;
+    overflow: hidden;
+  }
+
+  .arch-sidebar {
+    width: 10rem;
+    flex-shrink: 0;
+    border-right: 1px solid var(--ctp-surface0);
+    display: flex;
+    flex-direction: column;
+    overflow: hidden;
+  }
+
+  .sidebar-header {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    padding: 0.375rem 0.5rem;
+    border-bottom: 1px solid var(--ctp-surface0);
+  }
+
+  .sidebar-title {
+    font-size: 0.7rem;
+    font-weight: 600;
+    color: var(--ctp-subtext0);
+    text-transform: uppercase;
+    letter-spacing: 0.04em;
+  }
+
+  .btn-new {
+    padding: 0.125rem 0.375rem;
+    background: var(--ctp-surface0);
+    border: 1px solid var(--ctp-surface1);
+    border-radius: 0.25rem;
+    color: var(--ctp-subtext0);
+    font-size: 0.7rem;
+    cursor: pointer;
+  }
+
+  .btn-new:hover {
+    background: var(--ctp-surface1);
+    color: var(--ctp-text);
+  }
+
+  .new-form {
+    padding: 0.375rem 0.5rem;
+    border-bottom: 1px solid var(--ctp-surface0);
+    display: flex;
+    flex-direction: column;
+    gap: 0.25rem;
+  }
+
+  .new-name-input {
+    padding: 0.25rem 0.375rem;
+    background: var(--ctp-base);
+    border: 1px solid var(--ctp-surface1);
+    border-radius: 0.25rem;
+    color: var(--ctp-text);
+    font-size: 0.7rem;
+  }
+
+  .template-list {
+    display: flex;
+    flex-direction: column;
+    gap: 0.125rem;
+  }
+
+  .template-btn {
+    padding: 0.2rem 0.375rem;
+    background: var(--ctp-surface0);
+    border: 1px solid var(--ctp-surface1);
+    border-radius: 0.125rem;
+    color: var(--ctp-subtext0);
+    font-size: 0.6rem;
+    text-align: left;
+    cursor: pointer;
+  }
+
+  .template-btn:hover:not(:disabled) {
+    background: var(--ctp-surface1);
+    color: var(--ctp-text);
+  }
+
+  .template-btn:disabled {
+    opacity: 0.4;
+    cursor: default;
+  }
+
+  .diagram-list {
+    flex: 1;
+    overflow-y: auto;
+    display: flex;
+    flex-direction: column;
+  }
+
+  .diagram-item {
+    display: flex;
+    align-items: center;
+    gap: 0.25rem;
+    padding: 0.3125rem 0.5rem;
+    background: transparent;
+    border: none;
+    color: var(--ctp-subtext0);
+    font-size: 0.7rem;
+    text-align: left;
+    cursor: pointer;
+    transition: background 0.1s;
+  }
+
+  .diagram-item:hover {
+    background: var(--ctp-surface0);
+    color: var(--ctp-text);
+  }
+
+  .diagram-item.active {
+    background: var(--ctp-surface0);
+    color: var(--ctp-text);
+    font-weight: 600;
+  }
+
+  .diagram-icon { font-size: 0.8rem; }
+
+  .diagram-name {
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+  }
+
+  .empty-hint {
+    padding: 0.5rem;
+    font-size: 0.65rem;
+    color: var(--ctp-overlay0);
+    line-height: 1.4;
+  }
+
+  .empty-hint code {
+    background: var(--ctp-surface0);
+    padding: 0.0625rem 0.25rem;
+    border-radius: 0.125rem;
+    font-size: 0.6rem;
+  }
+
+  .arch-content {
+    flex: 1;
+    display: flex;
+    flex-direction: column;
+    overflow: hidden;
+  }
+
+  .empty-state {
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    height: 100%;
+    color: var(--ctp-overlay0);
+    font-size: 0.8rem;
+  }
+
+  .error-text { color: var(--ctp-red); }
+
+  .content-header {
+    display: flex;
+    align-items: center;
+    gap: 0.5rem;
+    padding: 0.375rem 0.5rem;
+    border-bottom: 1px solid var(--ctp-surface0);
+    flex-shrink: 0;
+  }
+
+  .file-name {
+    font-size: 0.75rem;
+    font-weight: 600;
+    color: var(--ctp-text);
+    flex: 1;
+  }
+
+  .btn-toggle-edit, .btn-save {
+    padding: 0.2rem 0.5rem;
+    background: var(--ctp-surface0);
+    border: 1px solid var(--ctp-surface1);
+    border-radius: 0.25rem;
+    color: var(--ctp-subtext0);
+    font-size: 0.65rem;
+    cursor: pointer;
+  }
+
+  .btn-toggle-edit:hover, .btn-save:hover {
+    background: var(--ctp-surface1);
+    color: var(--ctp-text);
+  }
+
+  .btn-save {
+    background: var(--ctp-green);
+    color: var(--ctp-base);
+    border-color: var(--ctp-green);
+  }
+
+  .puml-editor {
+    flex: 1;
+    padding: 0.5rem;
+    background: var(--ctp-mantle);
+    border: none;
+    color: var(--ctp-text);
+    font-family: var(--term-font-family, monospace);
+    font-size: 0.75rem;
+    line-height: 1.5;
+    resize: none;
+  }
+
+  .puml-editor:focus { outline: none; }
+
+  .diagram-preview {
+    flex: 1;
+    overflow: auto;
+    display: flex;
+    align-items: flex-start;
+    justify-content: center;
+    padding: 0.5rem;
+    background: var(--ctp-mantle);
+  }
+
+  .diagram-img {
+    max-width: 100%;
+    height: auto;
+    border-radius: 0.25rem;
+  }
+</style>
diff --git a/v2/src/lib/components/Workspace/AuditLogTab.svelte b/v2/src/lib/components/Workspace/AuditLogTab.svelte
new file mode 100644
index 0000000..ef73761
--- /dev/null
+++ b/v2/src/lib/components/Workspace/AuditLogTab.svelte
@@ -0,0 +1,300 @@
+<script lang="ts">
+  import { onMount, onDestroy } from 'svelte';
+  import { getAuditLog, type AuditEntry, type AuditEventType } from '../../adapters/audit-bridge';
+  import { getGroupAgents, type BtmsgAgent } from '../../adapters/btmsg-bridge';
+  import type { GroupId, AgentId } from '../../types/ids';
+
+  interface Props {
+    groupId: GroupId;
+  }
+
+  let { groupId }: Props = $props();
+
+  const EVENT_TYPES: AuditEventType[] = [
+    'prompt_injection',
+    'wake_event',
+    'btmsg_sent',
+    'btmsg_received',
+    'status_change',
+    'heartbeat_missed',
+    'dead_letter',
+  ];
+
+  const EVENT_COLORS: Record<string, string> = {
+    prompt_injection: 'var(--ctp-mauve)',
+    wake_event: 'var(--ctp-peach)',
+    btmsg_sent: 'var(--ctp-blue)',
+    btmsg_received: 'var(--ctp-teal)',
+    status_change: 'var(--ctp-green)',
+    heartbeat_missed: 'var(--ctp-yellow)',
+    dead_letter: 'var(--ctp-red)',
+  };
+
+  const ROLE_COLORS: Record<string, string> = {
+    manager: 'var(--ctp-mauve)',
+    architect: 'var(--ctp-blue)',
+    tester: 'var(--ctp-green)',
+    reviewer: 'var(--ctp-peach)',
+    project: 'var(--ctp-text)',
+    admin: 'var(--ctp-overlay1)',
+  };
+
+  let entries = $state<AuditEntry[]>([]);
+  let agents = $state<BtmsgAgent[]>([]);
+  let loading = $state(true);
+  let error = $state<string | null>(null);
+  let pollTimer: ReturnType<typeof setInterval> | null = null;
+
+  // Filters
+  let enabledTypes = $state<Set<string>>(new Set(EVENT_TYPES));
+  let selectedAgent = $state<string>('all');
+
+  let filteredEntries = $derived.by(() => {
+    return entries
+      .filter(e => enabledTypes.has(e.eventType))
+      .filter(e => selectedAgent === 'all' || e.agentId === selectedAgent)
+      .slice(0, 200);
+  });
+
+  function agentName(agentId: string): string {
+    const agent = agents.find(a => a.id === agentId);
+    return agent?.name ?? agentId;
+  }
+
+  function agentRole(agentId: string): string {
+    const agent = agents.find(a => a.id === agentId);
+    return agent?.role ?? 'unknown';
+  }
+
+  function toggleType(type: string) {
+    const next = new Set(enabledTypes);
+    if (next.has(type)) {
+      next.delete(type);
+    } else {
+      next.add(type);
+    }
+    enabledTypes = next;
+  }
+
+  function formatTime(createdAt: string): string {
+    try {
+      const d = new Date(createdAt + 'Z');
+      return d.toLocaleTimeString([], { hour: '2-digit', minute: '2-digit', second: '2-digit' });
+    } catch {
+      return createdAt;
+    }
+  }
+
+  async function fetchData() {
+    try {
+      const [auditData, agentData] = await Promise.all([
+        getAuditLog(groupId, 200, 0),
+        getGroupAgents(groupId),
+      ]);
+      entries = auditData;
+      agents = agentData;
+      error = null;
+    } catch (e) {
+      error = String(e);
+    } finally {
+      loading = false;
+    }
+  }
+
+  onMount(() => {
+    fetchData();
+    pollTimer = setInterval(fetchData, 5_000);
+  });
+
+  onDestroy(() => {
+    if (pollTimer) clearInterval(pollTimer);
+  });
+</script>
+
+<div class="audit-log-tab">
+  <div class="audit-toolbar">
+    <div class="filter-types">
+      {#each EVENT_TYPES as type}
+        <button
+          class="type-chip"
+          class:active={enabledTypes.has(type)}
+          style="--chip-color: {EVENT_COLORS[type] ?? 'var(--ctp-overlay1)'}"
+          onclick={() => toggleType(type)}
+        >
+          {type.replace(/_/g, ' ')}
+        </button>
+      {/each}
+    </div>
+    <select
+      class="agent-select"
+      bind:value={selectedAgent}
+    >
+      <option value="all">All agents</option>
+      {#each agents.filter(a => a.id !== 'admin') as agent}
+        <option value={agent.id}>{agent.name} ({agent.role})</option>
+      {/each}
+    </select>
+  </div>
+
+  <div class="audit-entries">
+    {#if loading}
+      <div class="audit-empty">Loading audit log...</div>
+    {:else if error}
+      <div class="audit-empty audit-error">Error: {error}</div>
+    {:else if filteredEntries.length === 0}
+      <div class="audit-empty">No audit events yet</div>
+    {:else}
+      {#each filteredEntries as entry (entry.id)}
+        <div class="audit-entry">
+          <span class="entry-time">{formatTime(entry.createdAt)}</span>
+          <span
+            class="entry-agent"
+            style="color: {ROLE_COLORS[agentRole(entry.agentId)] ?? 'var(--ctp-text)'}"
+          >
+            {agentName(entry.agentId)}
+          </span>
+          <span
+            class="entry-type"
+            style="--badge-color: {EVENT_COLORS[entry.eventType] ?? 'var(--ctp-overlay1)'}"
+          >
+            {entry.eventType.replace(/_/g, ' ')}
+          </span>
+          <span class="entry-detail">{entry.detail}</span>
+        </div>
+      {/each}
+    {/if}
+  </div>
+</div>
+
+<style>
+  .audit-log-tab {
+    display: flex;
+    flex-direction: column;
+    height: 100%;
+    overflow: hidden;
+    font-size: 0.8rem;
+    flex: 1;
+  }
+
+  .audit-toolbar {
+    display: flex;
+    align-items: center;
+    gap: 0.5rem;
+    padding: 0.375rem 0.5rem;
+    border-bottom: 1px solid var(--ctp-surface0);
+    background: var(--ctp-mantle);
+    flex-shrink: 0;
+    flex-wrap: wrap;
+  }
+
+  .filter-types {
+    display: flex;
+    gap: 0.25rem;
+    flex-wrap: wrap;
+    flex: 1;
+  }
+
+  .type-chip {
+    font-size: 0.6rem;
+    padding: 0.125rem 0.375rem;
+    border: 1px solid var(--chip-color);
+    border-radius: 0.25rem;
+    background: transparent;
+    color: var(--chip-color);
+    cursor: pointer;
+    text-transform: capitalize;
+    transition: background 0.12s, color 0.12s;
+    font-family: inherit;
+    opacity: 0.4;
+  }
+
+  .type-chip.active {
+    background: color-mix(in srgb, var(--chip-color) 15%, transparent);
+    opacity: 1;
+  }
+
+  .type-chip:hover {
+    background: color-mix(in srgb, var(--chip-color) 25%, transparent);
+    opacity: 1;
+  }
+
+  .agent-select {
+    font-size: 0.7rem;
+    padding: 0.125rem 0.375rem;
+    border: 1px solid var(--ctp-surface1);
+    border-radius: 0.25rem;
+    background: var(--ctp-surface0);
+    color: var(--ctp-text);
+    cursor: pointer;
+    font-family: inherit;
+  }
+
+  .audit-entries {
+    flex: 1;
+    overflow-y: auto;
+    padding: 0.25rem 0;
+  }
+
+  .audit-empty {
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    height: 100%;
+    color: var(--ctp-overlay0);
+    font-size: 0.8rem;
+  }
+
+  .audit-error {
+    color: var(--ctp-red);
+  }
+
+  .audit-entry {
+    display: flex;
+    align-items: baseline;
+    gap: 0.5rem;
+    padding: 0.1875rem 0.5rem;
+    border-bottom: 1px solid color-mix(in srgb, var(--ctp-surface0) 50%, transparent);
+    line-height: 1.4;
+  }
+
+  .audit-entry:hover {
+    background: var(--ctp-surface0);
+  }
+
+  .entry-time {
+    font-size: 0.65rem;
+    color: var(--ctp-overlay0);
+    font-family: var(--font-mono, monospace);
+    white-space: nowrap;
+    flex-shrink: 0;
+  }
+
+  .entry-agent {
+    font-size: 0.7rem;
+    font-weight: 600;
+    white-space: nowrap;
+    flex-shrink: 0;
+    min-width: 5rem;
+  }
+
+  .entry-type {
+    font-size: 0.6rem;
+    padding: 0.0625rem 0.3125rem;
+    border-radius: 0.1875rem;
+    background: color-mix(in srgb, var(--badge-color) 15%, transparent);
+    color: var(--badge-color);
+    font-weight: 600;
+    white-space: nowrap;
+    flex-shrink: 0;
+    text-transform: capitalize;
+  }
+
+  .entry-detail {
+    font-size: 0.7rem;
+    color: var(--ctp-subtext0);
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+    min-width: 0;
+  }
+</style>
diff --git a/v2/src/lib/components/Workspace/CodeEditor.svelte b/v2/src/lib/components/Workspace/CodeEditor.svelte
new file mode 100644
index 0000000..5a124ee
--- /dev/null
+++ b/v2/src/lib/components/Workspace/CodeEditor.svelte
@@ -0,0 +1,332 @@
+<script lang="ts">
+  import { onMount, onDestroy } from 'svelte';
+  import { EditorView, keymap, lineNumbers, highlightActiveLine, highlightActiveLineGutter, drawSelection, rectangularSelection, crosshairCursor, dropCursor } from '@codemirror/view';
+  import { EditorState } from '@codemirror/state';
+  import { defaultKeymap, history, historyKeymap, indentWithTab } from '@codemirror/commands';
+  import { syntaxHighlighting, defaultHighlightStyle, indentOnInput, bracketMatching, foldGutter, foldKeymap } from '@codemirror/language';
+  import { closeBrackets, closeBracketsKeymap, autocompletion, completionKeymap } from '@codemirror/autocomplete';
+  import { highlightSelectionMatches, searchKeymap } from '@codemirror/search';
+
+  interface Props {
+    content: string;
+    lang: string;
+    onchange?: (content: string) => void;
+    onsave?: () => void;
+    onblur?: () => void;
+  }
+
+  let { content, lang, onchange, onsave, onblur }: Props = $props();
+
+  let container: HTMLDivElement | undefined = $state();
+  let view: EditorView | undefined = $state();
+
+  // Map lang hint to CodeMirror language extension
+  async function getLangExtension(lang: string) {
+    switch (lang) {
+      case 'javascript':
+      case 'jsx': {
+        const { javascript } = await import('@codemirror/lang-javascript');
+        return javascript({ jsx: true });
+      }
+      case 'typescript':
+      case 'tsx': {
+        const { javascript } = await import('@codemirror/lang-javascript');
+        return javascript({ jsx: true, typescript: true });
+      }
+      case 'html':
+      case 'svelte': {
+        const { html } = await import('@codemirror/lang-html');
+        return html();
+      }
+      case 'css':
+      case 'scss':
+      case 'less': {
+        const { css } = await import('@codemirror/lang-css');
+        return css();
+      }
+      case 'json': {
+        const { json } = await import('@codemirror/lang-json');
+        return json();
+      }
+      case 'markdown': {
+        const { markdown } = await import('@codemirror/lang-markdown');
+        return markdown();
+      }
+      case 'python': {
+        const { python } = await import('@codemirror/lang-python');
+        return python();
+      }
+      case 'rust': {
+        const { rust } = await import('@codemirror/lang-rust');
+        return rust();
+      }
+      case 'xml': {
+        const { xml } = await import('@codemirror/lang-xml');
+        return xml();
+      }
+      case 'sql': {
+        const { sql } = await import('@codemirror/lang-sql');
+        return sql();
+      }
+      case 'yaml': {
+        const { yaml } = await import('@codemirror/lang-yaml');
+        return yaml();
+      }
+      case 'cpp':
+      case 'c':
+      case 'h': {
+        const { cpp } = await import('@codemirror/lang-cpp');
+        return cpp();
+      }
+      case 'java': {
+        const { java } = await import('@codemirror/lang-java');
+        return java();
+      }
+      case 'php': {
+        const { php } = await import('@codemirror/lang-php');
+        return php();
+      }
+      case 'go': {
+        const { go } = await import('@codemirror/lang-go');
+        return go();
+      }
+      default:
+        return null;
+    }
+  }
+
+  // Catppuccin Mocha-inspired theme that reads CSS custom properties
+  const catppuccinTheme = EditorView.theme({
+    '&': {
+      backgroundColor: 'var(--ctp-base)',
+      color: 'var(--ctp-text)',
+      fontFamily: 'var(--term-font-family, "JetBrains Mono", monospace)',
+      fontSize: '0.775rem',
+    },
+    '.cm-content': {
+      caretColor: 'var(--ctp-rosewater)',
+      lineHeight: '1.55',
+    },
+    '.cm-cursor, .cm-dropCursor': {
+      borderLeftColor: 'var(--ctp-rosewater)',
+    },
+    '&.cm-focused .cm-selectionBackground, .cm-selectionBackground, .cm-content ::selection': {
+      backgroundColor: 'color-mix(in srgb, var(--ctp-blue) 25%, transparent)',
+    },
+    '.cm-panels': {
+      backgroundColor: 'var(--ctp-mantle)',
+      color: 'var(--ctp-text)',
+    },
+    '.cm-panels.cm-panels-top': {
+      borderBottom: '1px solid var(--ctp-surface0)',
+    },
+    '.cm-searchMatch': {
+      backgroundColor: 'color-mix(in srgb, var(--ctp-yellow) 25%, transparent)',
+    },
+    '.cm-searchMatch.cm-searchMatch-selected': {
+      backgroundColor: 'color-mix(in srgb, var(--ctp-peach) 30%, transparent)',
+    },
+    '.cm-activeLine': {
+      backgroundColor: 'color-mix(in srgb, var(--ctp-surface0) 40%, transparent)',
+    },
+    '.cm-selectionMatch': {
+      backgroundColor: 'color-mix(in srgb, var(--ctp-teal) 15%, transparent)',
+    },
+    '.cm-matchingBracket, .cm-nonmatchingBracket': {
+      backgroundColor: 'color-mix(in srgb, var(--ctp-blue) 20%, transparent)',
+      outline: '1px solid color-mix(in srgb, var(--ctp-blue) 40%, transparent)',
+    },
+    '.cm-gutters': {
+      backgroundColor: 'var(--ctp-mantle)',
+      color: 'var(--ctp-overlay0)',
+      border: 'none',
+      borderRight: '1px solid var(--ctp-surface0)',
+    },
+    '.cm-activeLineGutter': {
+      backgroundColor: 'color-mix(in srgb, var(--ctp-surface0) 40%, transparent)',
+      color: 'var(--ctp-text)',
+    },
+    '.cm-foldPlaceholder': {
+      backgroundColor: 'var(--ctp-surface0)',
+      border: 'none',
+      color: 'var(--ctp-overlay1)',
+    },
+    '.cm-tooltip': {
+      backgroundColor: 'var(--ctp-surface0)',
+      color: 'var(--ctp-text)',
+      border: '1px solid var(--ctp-surface1)',
+      borderRadius: '0.25rem',
+    },
+    '.cm-tooltip .cm-tooltip-arrow:before': {
+      borderTopColor: 'var(--ctp-surface1)',
+      borderBottomColor: 'var(--ctp-surface1)',
+    },
+    '.cm-tooltip .cm-tooltip-arrow:after': {
+      borderTopColor: 'var(--ctp-surface0)',
+      borderBottomColor: 'var(--ctp-surface0)',
+    },
+    '.cm-tooltip-autocomplete': {
+      '& > ul > li[aria-selected]': {
+        backgroundColor: 'color-mix(in srgb, var(--ctp-blue) 20%, transparent)',
+        color: 'var(--ctp-text)',
+      },
+    },
+  }, { dark: true });
+
+  async function createEditor() {
+    if (!container) return;
+
+    const langExt = await getLangExtension(lang);
+
+    const extensions = [
+      lineNumbers(),
+      highlightActiveLineGutter(),
+      history(),
+      foldGutter(),
+      drawSelection(),
+      dropCursor(),
+      EditorState.allowMultipleSelections.of(true),
+      indentOnInput(),
+      syntaxHighlighting(defaultHighlightStyle, { fallback: true }),
+      bracketMatching(),
+      closeBrackets(),
+      autocompletion(),
+      rectangularSelection(),
+      crosshairCursor(),
+      highlightActiveLine(),
+      highlightSelectionMatches(),
+      keymap.of([
+        ...closeBracketsKeymap,
+        ...defaultKeymap,
+        ...searchKeymap,
+        ...historyKeymap,
+        ...foldKeymap,
+        ...completionKeymap,
+        indentWithTab,
+        { key: 'Mod-s', run: () => { onsave?.(); return true; } },
+      ]),
+      catppuccinTheme,
+      EditorView.updateListener.of(update => {
+        if (update.docChanged) {
+          onchange?.(update.state.doc.toString());
+        }
+      }),
+      EditorView.domEventHandlers({
+        blur: () => { onblur?.(); },
+      }),
+      EditorView.lineWrapping,
+    ];
+
+    if (langExt) extensions.push(langExt);
+
+    view = new EditorView({
+      state: EditorState.create({ doc: content, extensions }),
+      parent: container,
+    });
+  }
+
+  onMount(() => {
+    createEditor();
+  });
+
+  onDestroy(() => {
+    view?.destroy();
+  });
+
+  // When content prop changes externally (different file loaded), replace editor content
+  let lastContent = $state(content);
+  $effect(() => {
+    const c = content;
+    if (view && c !== lastContent) {
+      const currentDoc = view.state.doc.toString();
+      if (c !== currentDoc) {
+        view.dispatch({
+          changes: { from: 0, to: view.state.doc.length, insert: c },
+        });
+      }
+      lastContent = c;
+    }
+  });
+
+  // When lang changes, recreate editor
+  let lastLang = $state(lang);
+  $effect(() => {
+    const l = lang;
+    if (l !== lastLang && view) {
+      lastLang = l;
+      const currentContent = view.state.doc.toString();
+      view.destroy();
+      // Small delay to let DOM settle
+      queueMicrotask(async () => {
+        const langExt = await getLangExtension(l);
+        const extensions = [
+          lineNumbers(),
+          highlightActiveLineGutter(),
+          history(),
+          foldGutter(),
+          drawSelection(),
+          dropCursor(),
+          EditorState.allowMultipleSelections.of(true),
+          indentOnInput(),
+          syntaxHighlighting(defaultHighlightStyle, { fallback: true }),
+          bracketMatching(),
+          closeBrackets(),
+          autocompletion(),
+          rectangularSelection(),
+          crosshairCursor(),
+          highlightActiveLine(),
+          highlightSelectionMatches(),
+          keymap.of([
+            ...closeBracketsKeymap,
+            ...defaultKeymap,
+            ...searchKeymap,
+            ...historyKeymap,
+            ...foldKeymap,
+            ...completionKeymap,
+            indentWithTab,
+            { key: 'Mod-s', run: () => { onsave?.(); return true; } },
+          ]),
+          catppuccinTheme,
+          EditorView.updateListener.of(update => {
+            if (update.docChanged) {
+              onchange?.(update.state.doc.toString());
+            }
+          }),
+          EditorView.domEventHandlers({
+            blur: () => { onblur?.(); },
+          }),
+          EditorView.lineWrapping,
+        ];
+        if (langExt) extensions.push(langExt);
+        view = new EditorView({
+          state: EditorState.create({ doc: currentContent, extensions }),
+          parent: container!,
+        });
+      });
+    }
+  });
+
+  export function getContent(): string {
+    return view?.state.doc.toString() ?? content;
+  }
+</script>
+
+<div class="code-editor" bind:this={container}></div>
+
+<style>
+  .code-editor {
+    flex: 1;
+    overflow: hidden;
+    display: flex;
+    flex-direction: column;
+  }
+
+  .code-editor :global(.cm-editor) {
+    flex: 1;
+    overflow: hidden;
+  }
+
+  .code-editor :global(.cm-scroller) {
+    overflow: auto;
+  }
+</style>
diff --git a/v2/src/lib/components/Workspace/CommandPalette.svelte b/v2/src/lib/components/Workspace/CommandPalette.svelte
new file mode 100644
index 0000000..ede93bf
--- /dev/null
+++ b/v2/src/lib/components/Workspace/CommandPalette.svelte
@@ -0,0 +1,539 @@
+<script lang="ts">
+  import {
+    getAllGroups,
+    switchGroup,
+    getActiveGroupId,
+    getAllWorkItems,
+    getActiveProjectId,
+    setActiveProject,
+    setActiveTab,
+    triggerFocusFlash,
+    emitProjectTabSwitch,
+    emitTerminalToggle,
+    addTerminalTab,
+  } from '../../stores/workspace.svelte';
+  import { getPluginCommands } from '../../stores/plugins.svelte';
+
+  interface Props {
+    open: boolean;
+    onclose: () => void;
+  }
+
+  let { open, onclose }: Props = $props();
+
+  let query = $state('');
+  let inputEl: HTMLInputElement | undefined = $state();
+  let selectedIndex = $state(0);
+  let showShortcuts = $state(false);
+
+  // --- Command definitions ---
+
+  interface Command {
+    id: string;
+    label: string;
+    category: string;
+    shortcut?: string;
+    action: () => void;
+  }
+
+  let commands = $derived.by((): Command[] => {
+    const cmds: Command[] = [];
+    const groups = getAllGroups();
+    const projects = getAllWorkItems();
+    const activeGroupId = getActiveGroupId();
+    const activeProjectId = getActiveProjectId();
+
+    // Project focus commands
+    projects.forEach((p, i) => {
+      if (i < 5) {
+        cmds.push({
+          id: `focus-project-${i + 1}`,
+          label: `Focus Project ${i + 1}: ${p.name}`,
+          category: 'Navigation',
+          shortcut: `Alt+${i + 1}`,
+          action: () => {
+            setActiveProject(p.id);
+            triggerFocusFlash(p.id);
+          },
+        });
+      }
+    });
+
+    // Tab switching commands (for active project)
+    const tabNames: [string, number][] = [
+      ['Model', 1], ['Docs', 2], ['Context', 3], ['Files', 4],
+      ['SSH', 5], ['Memory', 6], ['Metrics', 7],
+    ];
+    for (const [name, idx] of tabNames) {
+      cmds.push({
+        id: `tab-${name.toLowerCase()}`,
+        label: `Switch to ${name} Tab`,
+        category: 'Tabs',
+        shortcut: `Ctrl+Shift+${idx}`,
+        action: () => {
+          if (activeProjectId) {
+            emitProjectTabSwitch(activeProjectId, idx);
+          }
+        },
+      });
+    }
+
+    // Terminal toggle
+    cmds.push({
+      id: 'toggle-terminal',
+      label: 'Toggle Terminal Section',
+      category: 'Tabs',
+      shortcut: 'Ctrl+J',
+      action: () => {
+        if (activeProjectId) {
+          emitTerminalToggle(activeProjectId);
+        }
+      },
+    });
+
+    // New terminal tab
+    cmds.push({
+      id: 'new-terminal',
+      label: 'New Terminal Tab',
+      category: 'Terminal',
+      action: () => {
+        if (activeProjectId) {
+          addTerminalTab(activeProjectId, {
+            id: crypto.randomUUID(),
+            title: 'Terminal',
+            type: 'shell',
+          });
+          emitTerminalToggle(activeProjectId); // ensure terminal section is open
+        }
+      },
+    });
+
+    // Agent session commands
+    cmds.push({
+      id: 'focus-agent',
+      label: 'Focus Agent Pane',
+      category: 'Agent',
+      shortcut: 'Ctrl+Shift+K',
+      action: () => {
+        if (activeProjectId) {
+          emitProjectTabSwitch(activeProjectId, 1); // Model tab
+        }
+      },
+    });
+
+    // Group switching commands
+    for (const group of groups) {
+      cmds.push({
+        id: `group-${group.id}`,
+        label: `Switch Group: ${group.name}`,
+        category: 'Groups',
+        shortcut: group.id === activeGroupId ? '(active)' : undefined,
+        action: () => switchGroup(group.id),
+      });
+    }
+
+    // Settings toggle
+    cmds.push({
+      id: 'toggle-settings',
+      label: 'Toggle Settings',
+      category: 'UI',
+      shortcut: 'Ctrl+,',
+      action: () => {
+        setActiveTab('settings');
+        // Toggle is handled by App.svelte
+      },
+    });
+
+    // Vi navigation
+    cmds.push({
+      id: 'nav-prev-project',
+      label: 'Focus Previous Project',
+      category: 'Navigation',
+      shortcut: 'Ctrl+H',
+      action: () => {
+        const idx = projects.findIndex(p => p.id === activeProjectId);
+        if (idx > 0) {
+          setActiveProject(projects[idx - 1].id);
+          triggerFocusFlash(projects[idx - 1].id);
+        }
+      },
+    });
+
+    cmds.push({
+      id: 'nav-next-project',
+      label: 'Focus Next Project',
+      category: 'Navigation',
+      shortcut: 'Ctrl+L',
+      action: () => {
+        const idx = projects.findIndex(p => p.id === activeProjectId);
+        if (idx >= 0 && idx < projects.length - 1) {
+          setActiveProject(projects[idx + 1].id);
+          triggerFocusFlash(projects[idx + 1].id);
+        }
+      },
+    });
+
+    // Keyboard shortcuts help
+    cmds.push({
+      id: 'shortcuts-help',
+      label: 'Keyboard Shortcuts',
+      category: 'Help',
+      shortcut: '?',
+      action: () => { showShortcuts = true; },
+    });
+
+    // Plugin-registered commands
+    for (const pc of getPluginCommands()) {
+      cmds.push({
+        id: `plugin-${pc.pluginId}-${pc.label.toLowerCase().replace(/\s+/g, '-')}`,
+        label: pc.label,
+        category: 'Plugins',
+        action: pc.callback,
+      });
+    }
+
+    return cmds;
+  });
+
+  let filtered = $derived.by((): Command[] => {
+    if (!query.trim()) return commands;
+    const q = query.toLowerCase();
+    return commands.filter(c =>
+      c.label.toLowerCase().includes(q) ||
+      c.category.toLowerCase().includes(q)
+    );
+  });
+
+  // Grouped for display
+  let grouped = $derived.by((): [string, Command[]][] => {
+    const map = new Map<string, Command[]>();
+    for (const cmd of filtered) {
+      const list = map.get(cmd.category) ?? [];
+      list.push(cmd);
+      map.set(cmd.category, list);
+    }
+    return [...map.entries()];
+  });
+
+  $effect(() => {
+    if (open) {
+      query = '';
+      selectedIndex = 0;
+      showShortcuts = false;
+      requestAnimationFrame(() => inputEl?.focus());
+    }
+  });
+
+  // Reset selection when filter changes
+  $effect(() => {
+    void filtered;
+    selectedIndex = 0;
+  });
+
+  function executeCommand(cmd: Command) {
+    cmd.action();
+    onclose();
+  }
+
+  function handleKeydown(e: KeyboardEvent) {
+    if (e.key === 'Escape') {
+      if (showShortcuts) {
+        showShortcuts = false;
+        e.stopPropagation();
+      } else {
+        onclose();
+      }
+      return;
+    }
+
+    if (showShortcuts) return;
+
+    if (e.key === 'ArrowDown') {
+      e.preventDefault();
+      selectedIndex = Math.min(selectedIndex + 1, filtered.length - 1);
+      scrollToSelected();
+    } else if (e.key === 'ArrowUp') {
+      e.preventDefault();
+      selectedIndex = Math.max(selectedIndex - 1, 0);
+      scrollToSelected();
+    } else if (e.key === 'Enter' && filtered.length > 0) {
+      e.preventDefault();
+      executeCommand(filtered[selectedIndex]);
+    }
+  }
+
+  function scrollToSelected() {
+    requestAnimationFrame(() => {
+      const el = document.querySelector('.palette-item.selected');
+      el?.scrollIntoView({ block: 'nearest' });
+    });
+  }
+
+  // Track flat index across grouped display
+  function getFlatIndex(groupIdx: number, itemIdx: number): number {
+    let idx = 0;
+    for (let g = 0; g < groupIdx; g++) {
+      idx += grouped[g][1].length;
+    }
+    return idx + itemIdx;
+  }
+</script>
+
+{#if open}
+  <!-- svelte-ignore a11y_no_static_element_interactions -->
+  <div class="palette-backdrop" onclick={onclose} onkeydown={handleKeydown}>
+    <!-- svelte-ignore a11y_no_static_element_interactions -->
+    <div class="palette" data-testid="command-palette" onclick={(e) => e.stopPropagation()} onkeydown={handleKeydown}>
+      {#if showShortcuts}
+        <div class="shortcuts-header">
+          <h3>Keyboard Shortcuts</h3>
+          <button class="shortcuts-close" onclick={() => showShortcuts = false}>
+            <svg width="14" height="14" viewBox="0 0 14 14" fill="none">
+              <path d="M2 2l10 10M12 2L2 12" stroke="currentColor" stroke-width="1.5" stroke-linecap="round"/>
+            </svg>
+          </button>
+        </div>
+        <div class="shortcuts-list">
+          <div class="shortcut-section">
+            <h4>Global</h4>
+            <div class="shortcut-row"><kbd>Ctrl+K</kbd><span>Command Palette</span></div>
+            <div class="shortcut-row"><kbd>Ctrl+,</kbd><span>Toggle Settings</span></div>
+            <div class="shortcut-row"><kbd>Ctrl+M</kbd><span>Toggle Messages</span></div>
+            <div class="shortcut-row"><kbd>Ctrl+B</kbd><span>Toggle Sidebar</span></div>
+            <div class="shortcut-row"><kbd>Escape</kbd><span>Close Panel / Palette</span></div>
+          </div>
+          <div class="shortcut-section">
+            <h4>Project Navigation</h4>
+            <div class="shortcut-row"><kbd>Alt+1</kbd> – <kbd>Alt+5</kbd><span>Focus Project 1–5</span></div>
+            <div class="shortcut-row"><kbd>Ctrl+H</kbd><span>Previous Project</span></div>
+            <div class="shortcut-row"><kbd>Ctrl+L</kbd><span>Next Project</span></div>
+            <div class="shortcut-row"><kbd>Ctrl+J</kbd><span>Toggle Terminal</span></div>
+            <div class="shortcut-row"><kbd>Ctrl+Shift+K</kbd><span>Focus Agent Pane</span></div>
+          </div>
+          <div class="shortcut-section">
+            <h4>Project Tabs</h4>
+            <div class="shortcut-row"><kbd>Ctrl+Shift+1</kbd><span>Model</span></div>
+            <div class="shortcut-row"><kbd>Ctrl+Shift+2</kbd><span>Docs</span></div>
+            <div class="shortcut-row"><kbd>Ctrl+Shift+3</kbd><span>Context</span></div>
+            <div class="shortcut-row"><kbd>Ctrl+Shift+4</kbd><span>Files</span></div>
+            <div class="shortcut-row"><kbd>Ctrl+Shift+5</kbd><span>SSH</span></div>
+            <div class="shortcut-row"><kbd>Ctrl+Shift+6</kbd><span>Memory</span></div>
+            <div class="shortcut-row"><kbd>Ctrl+Shift+7</kbd><span>Metrics</span></div>
+          </div>
+        </div>
+      {:else}
+        <input
+          bind:this={inputEl}
+          bind:value={query}
+          class="palette-input"
+          data-testid="palette-input"
+          placeholder="Type a command..."
+          onkeydown={handleKeydown}
+        />
+        <ul class="palette-results">
+          {#each grouped as [category, items], gi}
+            <li class="palette-category">{category}</li>
+            {#each items as cmd, ci}
+              {@const flatIdx = getFlatIndex(gi, ci)}
+              <li>
+                <button
+                  class="palette-item"
+                  class:selected={flatIdx === selectedIndex}
+                  onclick={() => executeCommand(cmd)}
+                  onmouseenter={() => selectedIndex = flatIdx}
+                >
+                  <span class="cmd-label">{cmd.label}</span>
+                  {#if cmd.shortcut}
+                    <kbd class="cmd-shortcut">{cmd.shortcut}</kbd>
+                  {/if}
+                </button>
+              </li>
+            {/each}
+          {/each}
+          {#if filtered.length === 0}
+            <li class="no-results">No commands match "{query}"</li>
+          {/if}
+        </ul>
+      {/if}
+    </div>
+  </div>
+{/if}
+
+<style>
+  .palette-backdrop {
+    position: fixed;
+    inset: 0;
+    background: color-mix(in srgb, var(--ctp-crust) 70%, transparent);
+    display: flex;
+    justify-content: center;
+    padding-top: 12vh;
+    z-index: 1000;
+  }
+
+  .palette {
+    width: 32rem;
+    max-height: 28rem;
+    background: var(--ctp-mantle);
+    border: 1px solid var(--ctp-surface1);
+    border-radius: 0.5rem;
+    box-shadow: 0 0.5rem 2rem rgba(0, 0, 0, 0.4);
+    display: flex;
+    flex-direction: column;
+    overflow: hidden;
+    align-self: flex-start;
+  }
+
+  .palette-input {
+    padding: 0.75rem 1rem;
+    background: transparent;
+    border: none;
+    border-bottom: 1px solid var(--ctp-surface0);
+    color: var(--ctp-text);
+    font-size: 0.9rem;
+    outline: none;
+    font-family: inherit;
+  }
+
+  .palette-input::placeholder {
+    color: var(--ctp-overlay0);
+  }
+
+  .palette-results {
+    list-style: none;
+    margin: 0;
+    padding: 0.25rem;
+    overflow-y: auto;
+  }
+
+  .palette-category {
+    padding: 0.375rem 0.75rem 0.125rem;
+    font-size: 0.65rem;
+    font-weight: 600;
+    text-transform: uppercase;
+    letter-spacing: 0.05em;
+    color: var(--ctp-overlay0);
+  }
+
+  .palette-item {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    width: 100%;
+    padding: 0.4rem 0.75rem;
+    background: transparent;
+    border: none;
+    color: var(--ctp-text);
+    font-size: 0.82rem;
+    cursor: pointer;
+    border-radius: 0.25rem;
+    transition: background 0.08s;
+    font-family: inherit;
+  }
+
+  .palette-item:hover,
+  .palette-item.selected {
+    background: var(--ctp-surface0);
+  }
+
+  .palette-item.selected {
+    outline: 1px solid var(--ctp-blue);
+    outline-offset: -1px;
+  }
+
+  .cmd-label {
+    flex: 1;
+    text-align: left;
+  }
+
+  .cmd-shortcut {
+    font-size: 0.68rem;
+    color: var(--ctp-overlay1);
+    background: var(--ctp-surface1);
+    padding: 0.1rem 0.375rem;
+    border-radius: 0.1875rem;
+    font-family: var(--font-mono, monospace);
+    white-space: nowrap;
+    margin-left: 0.5rem;
+  }
+
+  .no-results {
+    padding: 0.75rem;
+    color: var(--ctp-overlay0);
+    font-size: 0.85rem;
+    text-align: center;
+  }
+
+  /* Shortcuts overlay */
+  .shortcuts-header {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    padding: 0.625rem 1rem;
+    border-bottom: 1px solid var(--ctp-surface0);
+  }
+
+  .shortcuts-header h3 {
+    margin: 0;
+    font-size: 0.85rem;
+    font-weight: 600;
+    color: var(--ctp-text);
+  }
+
+  .shortcuts-close {
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    width: 1.375rem;
+    height: 1.375rem;
+    background: transparent;
+    border: none;
+    border-radius: 0.25rem;
+    color: var(--ctp-subtext0);
+    cursor: pointer;
+  }
+
+  .shortcuts-close:hover {
+    color: var(--ctp-text);
+    background: var(--ctp-surface0);
+  }
+
+  .shortcuts-list {
+    padding: 0.5rem 1rem;
+    overflow-y: auto;
+  }
+
+  .shortcut-section {
+    margin-bottom: 0.75rem;
+  }
+
+  .shortcut-section h4 {
+    margin: 0 0 0.25rem;
+    font-size: 0.7rem;
+    font-weight: 600;
+    text-transform: uppercase;
+    letter-spacing: 0.05em;
+    color: var(--ctp-overlay0);
+  }
+
+  .shortcut-row {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    padding: 0.25rem 0;
+    font-size: 0.8rem;
+    color: var(--ctp-subtext1);
+  }
+
+  .shortcut-row kbd {
+    font-size: 0.68rem;
+    color: var(--ctp-overlay1);
+    background: var(--ctp-surface1);
+    padding: 0.1rem 0.375rem;
+    border-radius: 0.1875rem;
+    font-family: var(--font-mono, monospace);
+  }
+
+  .shortcut-row span {
+    text-align: right;
+  }
+</style>
diff --git a/v2/src/lib/components/Workspace/CommsTab.svelte b/v2/src/lib/components/Workspace/CommsTab.svelte
new file mode 100644
index 0000000..0739ab1
--- /dev/null
+++ b/v2/src/lib/components/Workspace/CommsTab.svelte
@@ -0,0 +1,676 @@
+<script lang="ts">
+  import { onMount, onDestroy } from 'svelte';
+  import { getActiveGroup } from '../../stores/workspace.svelte';
+  import {
+    type BtmsgAgent,
+    type BtmsgMessage,
+    type BtmsgFeedMessage,
+    type BtmsgChannel,
+    type BtmsgChannelMessage,
+    getGroupAgents,
+    getHistory,
+    getAllFeed,
+    sendMessage,
+    markRead,
+    ensureAdmin,
+    getChannels,
+    getChannelMessages,
+    sendChannelMessage,
+    createChannel,
+  } from '../../adapters/btmsg-bridge';
+
+  const ADMIN_ID = 'admin';
+  const ROLE_ICONS: Record<string, string> = {
+    admin: '👤',
+    manager: '🎯',
+    architect: '🏗',
+    tester: '🧪',
+    reviewer: '🔍',
+    project: '📦',
+  };
+
+  type ViewMode =
+    | { type: 'feed' }
+    | { type: 'dm'; agentId: string; agentName: string }
+    | { type: 'channel'; channelId: string; channelName: string };
+
+  let agents = $state<BtmsgAgent[]>([]);
+  let channels = $state<BtmsgChannel[]>([]);
+  let currentView = $state<ViewMode>({ type: 'feed' });
+  let feedMessages = $state<BtmsgFeedMessage[]>([]);
+  let dmMessages = $state<BtmsgMessage[]>([]);
+  let channelMessages = $state<BtmsgChannelMessage[]>([]);
+  let messageInput = $state('');
+  let pollTimer: ReturnType<typeof setInterval> | null = null;
+  let messagesEl: HTMLElement | undefined = $state();
+  let newChannelName = $state('');
+  let showNewChannel = $state(false);
+
+  let group = $derived(getActiveGroup());
+  let groupId = $derived(group?.id ?? '');
+
+  async function loadData() {
+    if (!groupId) return;
+    try {
+      agents = await getGroupAgents(groupId);
+      channels = await getChannels(groupId);
+    } catch {
+      // btmsg.db might not exist
+    }
+  }
+
+  async function loadMessages() {
+    if (!groupId) return;
+    try {
+      if (currentView.type === 'feed') {
+        feedMessages = await getAllFeed(groupId, 100);
+      } else if (currentView.type === 'dm') {
+        dmMessages = await getHistory(ADMIN_ID, currentView.agentId, 100);
+        await markRead(ADMIN_ID, currentView.agentId);
+      } else if (currentView.type === 'channel') {
+        channelMessages = await getChannelMessages(currentView.channelId, 100);
+      }
+    } catch {
+      // silently fail
+    }
+  }
+
+  function scrollToBottom() {
+    if (messagesEl) {
+      requestAnimationFrame(() => {
+        if (messagesEl) messagesEl.scrollTop = messagesEl.scrollHeight;
+      });
+    }
+  }
+
+  $effect(() => {
+    void currentView;
+    loadMessages().then(scrollToBottom);
+  });
+
+  $effect(() => {
+    void groupId;
+    if (groupId) {
+      ensureAdmin(groupId).catch(() => {});
+      loadData();
+    }
+  });
+
+  onMount(() => {
+    pollTimer = setInterval(() => {
+      loadData();
+      loadMessages();
+    }, 3000);
+  });
+
+  onDestroy(() => {
+    if (pollTimer) clearInterval(pollTimer);
+  });
+
+  function selectFeed() {
+    currentView = { type: 'feed' };
+  }
+
+  function selectDm(agent: BtmsgAgent) {
+    currentView = { type: 'dm', agentId: agent.id, agentName: agent.name };
+  }
+
+  function selectChannel(channel: BtmsgChannel) {
+    currentView = { type: 'channel', channelId: channel.id, channelName: channel.name };
+  }
+
+  async function handleSend() {
+    const text = messageInput.trim();
+    if (!text) return;
+
+    try {
+      if (currentView.type === 'dm') {
+        await sendMessage(ADMIN_ID, currentView.agentId, text);
+      } else if (currentView.type === 'channel') {
+        await sendChannelMessage(currentView.channelId, ADMIN_ID, text);
+      } else {
+        return; // Can't send in feed view
+      }
+      messageInput = '';
+      await loadMessages();
+      scrollToBottom();
+    } catch (e) {
+      console.warn('Failed to send message:', e);
+    }
+  }
+
+  function handleKeydown(e: KeyboardEvent) {
+    if (e.key === 'Enter' && !e.shiftKey) {
+      e.preventDefault();
+      handleSend();
+    }
+  }
+
+  async function handleCreateChannel() {
+    const name = newChannelName.trim();
+    if (!name || !groupId) return;
+    try {
+      await createChannel(name, groupId, ADMIN_ID);
+      newChannelName = '';
+      showNewChannel = false;
+      await loadData();
+    } catch (e) {
+      console.warn('Failed to create channel:', e);
+    }
+  }
+
+  function formatTime(ts: string): string {
+    try {
+      const d = new Date(ts + 'Z');
+      return d.toLocaleTimeString('pl-PL', { hour: '2-digit', minute: '2-digit' });
+    } catch {
+      return ts.slice(11, 16);
+    }
+  }
+
+  function getAgentIcon(role: string): string {
+    return ROLE_ICONS[role] ?? '🤖';
+  }
+
+  function isActive(view: ViewMode): boolean {
+    if (currentView.type !== view.type) return false;
+    if (view.type === 'dm' && currentView.type === 'dm') return view.agentId === currentView.agentId;
+    if (view.type === 'channel' && currentView.type === 'channel') return view.channelId === currentView.channelId;
+    return true;
+  }
+</script>
+
+<div class="comms-tab">
+  <!-- Conversation list -->
+  <div class="conv-list">
+    <div class="conv-header">
+      <span class="conv-header-title">Messages</span>
+    </div>
+
+    <!-- Activity Feed -->
+    <button
+      class="conv-item"
+      class:active={currentView.type === 'feed'}
+      onclick={selectFeed}
+    >
+      <span class="conv-icon">📡</span>
+      <span class="conv-name">Activity Feed</span>
+    </button>
+
+    <!-- Channels -->
+    {#if channels.length > 0 || showNewChannel}
+      <div class="conv-section-title">
+        <span>Channels</span>
+        <button class="add-btn" onclick={() => showNewChannel = !showNewChannel} title="New channel">+</button>
+      </div>
+      {#each channels as channel (channel.id)}
+        <button
+          class="conv-item"
+          class:active={currentView.type === 'channel' && currentView.channelId === channel.id}
+          onclick={() => selectChannel(channel)}
+        >
+          <span class="conv-icon">#</span>
+          <span class="conv-name">{channel.name}</span>
+          <span class="conv-meta">{channel.memberCount}</span>
+        </button>
+      {/each}
+      {#if showNewChannel}
+        <div class="new-channel">
+          <input
+            type="text"
+            placeholder="channel name"
+            bind:value={newChannelName}
+            onkeydown={(e) => { if (e.key === 'Enter') handleCreateChannel(); }}
+          />
+          <button onclick={handleCreateChannel}>OK</button>
+        </div>
+      {/if}
+    {:else}
+      <div class="conv-section-title">
+        <span>Channels</span>
+        <button class="add-btn" onclick={() => showNewChannel = !showNewChannel} title="New channel">+</button>
+      </div>
+      {#if showNewChannel}
+        <div class="new-channel">
+          <input
+            type="text"
+            placeholder="channel name"
+            bind:value={newChannelName}
+            onkeydown={(e) => { if (e.key === 'Enter') handleCreateChannel(); }}
+          />
+          <button onclick={handleCreateChannel}>OK</button>
+        </div>
+      {/if}
+    {/if}
+
+    <!-- Direct Messages -->
+    <div class="conv-section-title">
+      <span>Direct Messages</span>
+    </div>
+    {#each agents.filter(a => a.id !== ADMIN_ID) as agent (agent.id)}
+      {@const statusClass = agent.status === 'active' ? 'active' : agent.status === 'sleeping' ? 'sleeping' : 'stopped'}
+      <button
+        class="conv-item"
+        class:active={currentView.type === 'dm' && currentView.agentId === agent.id}
+        onclick={() => selectDm(agent)}
+      >
+        <span class="conv-icon">{getAgentIcon(agent.role)}</span>
+        <span class="conv-name">{agent.name}</span>
+        <span class="status-dot {statusClass}"></span>
+        {#if agent.unreadCount > 0}
+          <span class="unread-badge">{agent.unreadCount}</span>
+        {/if}
+      </button>
+    {/each}
+  </div>
+
+  <!-- Chat area -->
+  <div class="chat-area">
+    <div class="chat-header">
+      {#if currentView.type === 'feed'}
+        <span class="chat-title">📡 Activity Feed</span>
+        <span class="chat-subtitle">All agent communication</span>
+      {:else if currentView.type === 'dm'}
+        <span class="chat-title">DM with {currentView.agentName}</span>
+      {:else if currentView.type === 'channel'}
+        <span class="chat-title"># {currentView.channelName}</span>
+      {/if}
+    </div>
+
+    <div class="chat-messages" bind:this={messagesEl}>
+      {#if currentView.type === 'feed'}
+        {#if feedMessages.length === 0}
+          <div class="empty-state">No messages yet. Agents haven't started communicating.</div>
+        {:else}
+          {#each [...feedMessages].reverse() as msg (msg.id)}
+            <div class="message feed-message">
+              <div class="msg-header">
+                <span class="msg-icon">{getAgentIcon(msg.senderRole)}</span>
+                <span class="msg-sender">{msg.senderName}</span>
+                <span class="msg-arrow">→</span>
+                <span class="msg-recipient">{msg.recipientName}</span>
+                <span class="msg-time">{formatTime(msg.createdAt)}</span>
+              </div>
+              <div class="msg-content">{msg.content}</div>
+            </div>
+          {/each}
+        {/if}
+
+      {:else if currentView.type === 'dm'}
+        {#if dmMessages.length === 0}
+          <div class="empty-state">No messages yet. Start the conversation!</div>
+        {:else}
+          {#each dmMessages as msg (msg.id)}
+            {@const isMe = msg.fromAgent === ADMIN_ID}
+            <div class="message" class:own={isMe}>
+              <div class="msg-header">
+                <span class="msg-sender">{isMe ? 'You' : (msg.senderName ?? msg.fromAgent)}</span>
+                <span class="msg-time">{formatTime(msg.createdAt)}</span>
+              </div>
+              <div class="msg-content">{msg.content}</div>
+            </div>
+          {/each}
+        {/if}
+
+      {:else if currentView.type === 'channel'}
+        {#if channelMessages.length === 0}
+          <div class="empty-state">No messages in this channel yet.</div>
+        {:else}
+          {#each channelMessages as msg (msg.id)}
+            {@const isMe = msg.fromAgent === ADMIN_ID}
+            <div class="message" class:own={isMe}>
+              <div class="msg-header">
+                <span class="msg-icon">{getAgentIcon(msg.senderRole)}</span>
+                <span class="msg-sender">{isMe ? 'You' : msg.senderName}</span>
+                <span class="msg-time">{formatTime(msg.createdAt)}</span>
+              </div>
+              <div class="msg-content">{msg.content}</div>
+            </div>
+          {/each}
+        {/if}
+      {/if}
+    </div>
+
+    {#if currentView.type !== 'feed'}
+      <div class="chat-input">
+        <textarea
+          placeholder={currentView.type === 'dm' ? `Message ${currentView.agentName}...` : `Message #${currentView.channelName}...`}
+          bind:value={messageInput}
+          onkeydown={handleKeydown}
+          rows="1"
+        ></textarea>
+        <button class="send-btn" onclick={handleSend} disabled={!messageInput.trim()}>
+          <svg width="16" height="16" viewBox="0 0 24 24" fill="none">
+            <path d="M22 2L11 13M22 2l-7 20-4-9-9-4 20-7z" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"/>
+          </svg>
+        </button>
+      </div>
+    {/if}
+  </div>
+</div>
+
+<style>
+  .comms-tab {
+    display: flex;
+    min-width: 36rem;
+    height: 100%;
+  }
+
+  /* Conversation list */
+  .conv-list {
+    width: 13rem;
+    flex-shrink: 0;
+    border-right: 1px solid var(--ctp-surface0);
+    overflow-y: auto;
+    display: flex;
+    flex-direction: column;
+  }
+
+  .conv-header {
+    padding: 0.5rem 0.75rem;
+    border-bottom: 1px solid var(--ctp-surface0);
+  }
+
+  .conv-header-title {
+    font-size: 0.7rem;
+    font-weight: 700;
+    text-transform: uppercase;
+    letter-spacing: 0.05em;
+    color: var(--ctp-subtext0);
+  }
+
+  .conv-section-title {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    padding: 0.5rem 0.75rem 0.25rem;
+    font-size: 0.6rem;
+    font-weight: 700;
+    text-transform: uppercase;
+    letter-spacing: 0.05em;
+    color: var(--ctp-overlay0);
+  }
+
+  .add-btn {
+    background: transparent;
+    border: none;
+    color: var(--ctp-overlay0);
+    font-size: 0.8rem;
+    cursor: pointer;
+    padding: 0;
+    line-height: 1;
+  }
+
+  .add-btn:hover {
+    color: var(--ctp-text);
+  }
+
+  .conv-item {
+    display: flex;
+    align-items: center;
+    gap: 0.4rem;
+    width: 100%;
+    padding: 0.35rem 0.75rem;
+    background: transparent;
+    border: none;
+    color: var(--ctp-subtext0);
+    font-size: 0.75rem;
+    cursor: pointer;
+    text-align: left;
+    transition: background 0.1s, color 0.1s;
+  }
+
+  .conv-item:hover {
+    background: var(--ctp-surface0);
+    color: var(--ctp-text);
+  }
+
+  .conv-item.active {
+    background: color-mix(in srgb, var(--ctp-blue) 15%, transparent);
+    color: var(--ctp-text);
+  }
+
+  .conv-icon {
+    font-size: 0.8rem;
+    flex-shrink: 0;
+    width: 1.2rem;
+    text-align: center;
+  }
+
+  .conv-name {
+    flex: 1;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+  }
+
+  .conv-meta {
+    font-size: 0.55rem;
+    color: var(--ctp-overlay0);
+  }
+
+  .status-dot {
+    width: 6px;
+    height: 6px;
+    border-radius: 50%;
+    flex-shrink: 0;
+  }
+
+  .status-dot.active {
+    background: var(--ctp-green);
+    box-shadow: 0 0 4px var(--ctp-green);
+  }
+
+  .status-dot.sleeping {
+    background: var(--ctp-yellow);
+  }
+
+  .status-dot.stopped {
+    background: var(--ctp-overlay0);
+  }
+
+  .unread-badge {
+    background: var(--ctp-red);
+    color: var(--ctp-base);
+    border-radius: 0.5rem;
+    padding: 0 0.3rem;
+    font-size: 0.55rem;
+    font-weight: 700;
+    min-width: 0.9rem;
+    text-align: center;
+    flex-shrink: 0;
+  }
+
+  .new-channel {
+    display: flex;
+    gap: 0.25rem;
+    padding: 0.25rem 0.75rem;
+  }
+
+  .new-channel input {
+    flex: 1;
+    background: var(--ctp-surface0);
+    border: 1px solid var(--ctp-surface1);
+    border-radius: 0.2rem;
+    color: var(--ctp-text);
+    font-size: 0.7rem;
+    padding: 0.2rem 0.4rem;
+    outline: none;
+  }
+
+  .new-channel input:focus {
+    border-color: var(--ctp-blue);
+  }
+
+  .new-channel button {
+    background: var(--ctp-blue);
+    color: var(--ctp-base);
+    border: none;
+    border-radius: 0.2rem;
+    font-size: 0.6rem;
+    font-weight: 600;
+    padding: 0.2rem 0.4rem;
+    cursor: pointer;
+  }
+
+  /* Chat area */
+  .chat-area {
+    flex: 1;
+    display: flex;
+    flex-direction: column;
+    min-width: 0;
+  }
+
+  .chat-header {
+    display: flex;
+    align-items: baseline;
+    gap: 0.5rem;
+    padding: 0.5rem 0.75rem;
+    border-bottom: 1px solid var(--ctp-surface0);
+    flex-shrink: 0;
+  }
+
+  .chat-title {
+    font-size: 0.8rem;
+    font-weight: 600;
+    color: var(--ctp-text);
+  }
+
+  .chat-subtitle {
+    font-size: 0.65rem;
+    color: var(--ctp-overlay0);
+  }
+
+  .chat-messages {
+    flex: 1;
+    overflow-y: auto;
+    padding: 0.5rem;
+    display: flex;
+    flex-direction: column;
+    gap: 0.4rem;
+  }
+
+  .empty-state {
+    color: var(--ctp-overlay0);
+    font-size: 0.75rem;
+    text-align: center;
+    padding: 2rem 1rem;
+  }
+
+  .message {
+    padding: 0.4rem 0.6rem;
+    border-radius: 0.375rem;
+    background: var(--ctp-surface0);
+    max-width: 85%;
+  }
+
+  .message.own {
+    align-self: flex-end;
+    background: color-mix(in srgb, var(--ctp-blue) 20%, var(--ctp-surface0));
+  }
+
+  .message.feed-message {
+    max-width: 100%;
+    background: transparent;
+    border-left: 2px solid var(--ctp-surface1);
+    border-radius: 0;
+    padding: 0.3rem 0.6rem;
+  }
+
+  .msg-header {
+    display: flex;
+    align-items: center;
+    gap: 0.3rem;
+    margin-bottom: 0.15rem;
+  }
+
+  .msg-icon {
+    font-size: 0.7rem;
+  }
+
+  .msg-sender {
+    font-size: 0.7rem;
+    font-weight: 600;
+    color: var(--ctp-text);
+  }
+
+  .msg-arrow {
+    font-size: 0.6rem;
+    color: var(--ctp-overlay0);
+  }
+
+  .msg-recipient {
+    font-size: 0.7rem;
+    font-weight: 600;
+    color: var(--ctp-subtext0);
+  }
+
+  .msg-time {
+    font-size: 0.55rem;
+    color: var(--ctp-overlay0);
+    margin-left: auto;
+  }
+
+  .msg-content {
+    font-size: 0.75rem;
+    color: var(--ctp-subtext0);
+    white-space: pre-wrap;
+    word-break: break-word;
+    line-height: 1.4;
+  }
+
+  .message.own .msg-content {
+    color: var(--ctp-text);
+  }
+
+  /* Input */
+  .chat-input {
+    display: flex;
+    gap: 0.4rem;
+    padding: 0.5rem;
+    border-top: 1px solid var(--ctp-surface0);
+    flex-shrink: 0;
+  }
+
+  .chat-input textarea {
+    flex: 1;
+    background: var(--ctp-surface0);
+    border: 1px solid var(--ctp-surface1);
+    border-radius: 0.375rem;
+    color: var(--ctp-text);
+    font-size: 0.75rem;
+    font-family: inherit;
+    padding: 0.4rem 0.6rem;
+    resize: none;
+    outline: none;
+    line-height: 1.4;
+  }
+
+  .chat-input textarea:focus {
+    border-color: var(--ctp-blue);
+  }
+
+  .send-btn {
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    width: 2rem;
+    height: 2rem;
+    background: var(--ctp-blue);
+    color: var(--ctp-base);
+    border: none;
+    border-radius: 0.375rem;
+    cursor: pointer;
+    flex-shrink: 0;
+    transition: opacity 0.1s;
+  }
+
+  .send-btn:disabled {
+    opacity: 0.4;
+    cursor: default;
+  }
+
+  .send-btn:not(:disabled):hover {
+    opacity: 0.9;
+  }
+</style>
diff --git a/v2/src/lib/components/Workspace/ContextTab.svelte b/v2/src/lib/components/Workspace/ContextTab.svelte
new file mode 100644
index 0000000..c69dd4a
--- /dev/null
+++ b/v2/src/lib/components/Workspace/ContextTab.svelte
@@ -0,0 +1,1807 @@
+<script lang="ts">
+  import { getAgentSession, getTotalCost, type AgentSession } from '../../stores/agents.svelte';
+  import type { AgentMessage, ToolCallContent, CostContent, CompactionContent } from '../../adapters/claude-messages';
+  import { extractFilePaths } from '../../utils/tool-files';
+  import {
+    getProjectAnchors,
+    getInjectableAnchors,
+    getInjectableTokenCount,
+    removeAnchor,
+    changeAnchorType,
+  } from '../../stores/anchors.svelte';
+  import { ANCHOR_BUDGET_SCALE_MAP, MAX_ANCHOR_TOKEN_BUDGET } from '../../types/anchors';
+  import type { SessionAnchor, AnchorType, AnchorBudgetScale } from '../../types/anchors';
+
+  interface Props {
+    sessionId: string | null;
+    projectId?: string;
+    anchorBudgetScale?: AnchorBudgetScale;
+  }
+
+  let { sessionId, projectId, anchorBudgetScale }: Props = $props();
+
+  // Reactive session data
+  let session = $derived(sessionId ? getAgentSession(sessionId) : undefined);
+  let messages = $derived(session?.messages ?? []);
+  let totalCost = $derived(sessionId ? getTotalCost(sessionId) : { costUsd: 0, inputTokens: 0, outputTokens: 0 });
+
+  // Context window size (Claude 3.5 Sonnet = 200k, Opus = 200k)
+  const CONTEXT_WINDOW = 200_000;
+
+  // --- Compaction tracking ---
+  interface CompactionEvent {
+    timestamp: number;
+    trigger: 'manual' | 'auto';
+    preTokens: number;
+    messageIndex: number;
+  }
+
+  let compactions = $derived.by((): CompactionEvent[] => {
+    const events: CompactionEvent[] = [];
+    for (let i = 0; i < messages.length; i++) {
+      const msg = messages[i];
+      if (msg.type === 'compaction') {
+        const c = msg.content as CompactionContent;
+        events.push({
+          timestamp: msg.timestamp,
+          trigger: c.trigger,
+          preTokens: c.preTokens,
+          messageIndex: i,
+        });
+      }
+    }
+    return events;
+  });
+
+  let lastCompaction = $derived(compactions.length > 0 ? compactions[compactions.length - 1] : null);
+
+  // --- Token category breakdown ---
+  interface TokenCategory {
+    label: string;
+    tokens: number;
+    color: string;
+    pct: number;
+  }
+
+  let categories = $derived.by(() => {
+    const msgs = messages;
+    let toolCallTokens = 0;
+    let toolResultTokens = 0;
+    let textTokens = 0;
+    let thinkingTokens = 0;
+    let otherTokens = 0;
+
+    for (const msg of msgs) {
+      const est = estimateTokens(msg);
+      switch (msg.type) {
+        case 'tool_call': toolCallTokens += est; break;
+        case 'tool_result': toolResultTokens += est; break;
+        case 'text': textTokens += est; break;
+        case 'thinking': thinkingTokens += est; break;
+        default: otherTokens += est; break;
+      }
+    }
+
+    const total = totalCost.inputTokens || (toolCallTokens + toolResultTokens + textTokens + thinkingTokens + otherTokens);
+    if (total === 0) return [];
+
+    const cats: TokenCategory[] = [];
+    const add = (label: string, tokens: number, color: string) => {
+      if (tokens > 0) cats.push({ label, tokens, color, pct: (tokens / CONTEXT_WINDOW) * 100 });
+    };
+
+    add('Assistant', textTokens, 'var(--ctp-green)');
+    add('Thinking', thinkingTokens, 'var(--ctp-mauve)');
+    add('Tool Calls', toolCallTokens, 'var(--ctp-peach)');
+    add('Tool Results', toolResultTokens, 'var(--ctp-blue)');
+    add('Other', otherTokens, 'var(--ctp-overlay1)');
+
+    return cats;
+  });
+
+  let meterFillPct = $derived(() => {
+    const total = totalCost.inputTokens;
+    return total > 0 ? Math.min((total / CONTEXT_WINDOW) * 100, 100) : 0;
+  });
+
+  // --- Turn groups ---
+  interface TurnGroup {
+    index: number;
+    userPrompt: string;
+    messages: AgentMessage[];
+    toolCalls: { name: string; input: string }[];
+    estimatedTokens: number;
+  }
+
+  let turns = $derived.by(() => {
+    const msgs = messages;
+    const groups: TurnGroup[] = [];
+    let current: TurnGroup | null = null;
+    let turnIdx = 0;
+
+    for (const msg of msgs) {
+      if (msg.type === 'text' && !current) {
+        // First text from assistant before any user prompt
+        current = { index: turnIdx++, userPrompt: '(initial)', messages: [msg], toolCalls: [], estimatedTokens: 0 };
+      } else if (msg.type === 'init' || msg.type === 'status') {
+        if (current) current.messages.push(msg);
+        else {
+          current = { index: turnIdx++, userPrompt: '(session start)', messages: [msg], toolCalls: [], estimatedTokens: 0 };
+        }
+      } else if (msg.type === 'cost') {
+        if (current) {
+          current.messages.push(msg);
+          groups.push(current);
+          current = null;
+        }
+      } else {
+        if (!current) {
+          current = { index: turnIdx++, userPrompt: '', messages: [], toolCalls: [], estimatedTokens: 0 };
+        }
+        current.messages.push(msg);
+        if (msg.type === 'tool_call') {
+          const tc = msg.content as ToolCallContent;
+          current.toolCalls.push({
+            name: tc.name,
+            input: typeof tc.input === 'string' ? tc.input.slice(0, 100) : JSON.stringify(tc.input).slice(0, 100),
+          });
+        }
+      }
+    }
+    if (current && current.messages.length > 0) groups.push(current);
+
+    // Compute estimated tokens per turn
+    for (const g of groups) {
+      g.estimatedTokens = g.messages.reduce((sum, m) => sum + estimateTokens(m), 0);
+    }
+
+    return groups;
+  });
+
+  // --- File references ---
+  interface FileRef {
+    path: string;
+    shortName: string;
+    ops: Set<string>; // 'read', 'write', 'grep', 'bash', etc.
+    count: number;
+  }
+
+  let fileRefs = $derived.by(() => {
+    const refs = new Map<string, FileRef>();
+    for (const msg of messages) {
+      if (msg.type !== 'tool_call') continue;
+      const tc = msg.content as ToolCallContent;
+      const files = extractFilePaths(tc);
+      for (const { path, op } of files) {
+        const existing = refs.get(path);
+        if (existing) {
+          existing.ops.add(op);
+          existing.count++;
+        } else {
+          refs.set(path, {
+            path,
+            shortName: path.split('/').pop() ?? path,
+            ops: new Set([op]),
+            count: 1,
+          });
+        }
+      }
+    }
+    return Array.from(refs.values()).sort((a, b) => b.count - a.count);
+  });
+
+  // --- Anchors ---
+  let anchors = $derived(projectId ? getProjectAnchors(projectId) : []);
+  let injectableAnchors = $derived(projectId ? getInjectableAnchors(projectId) : []);
+  let anchorTokens = $derived(projectId ? getInjectableTokenCount(projectId) : 0);
+  let anchorBudget = $derived(ANCHOR_BUDGET_SCALE_MAP[anchorBudgetScale ?? 'medium']);
+  let anchorBudgetPct = $derived(anchorBudget > 0 ? Math.min((anchorTokens / anchorBudget) * 100, 100) : 0);
+
+  function anchorTypeLabel(t: AnchorType): string {
+    switch (t) {
+      case 'auto': return 'Auto';
+      case 'pinned': return 'Pinned';
+      case 'promoted': return 'Promoted';
+    }
+  }
+
+  function anchorTypeColor(t: AnchorType): string {
+    switch (t) {
+      case 'auto': return 'var(--ctp-blue)';
+      case 'pinned': return 'var(--ctp-yellow)';
+      case 'promoted': return 'var(--ctp-green)';
+    }
+  }
+
+  async function handlePromote(anchor: SessionAnchor) {
+    if (!projectId) return;
+    const newType: AnchorType = anchor.anchorType === 'pinned' ? 'promoted' : 'pinned';
+    await changeAnchorType(projectId, anchor.id, newType);
+  }
+
+  async function handleRemoveAnchor(anchor: SessionAnchor) {
+    if (!projectId) return;
+    await removeAnchor(projectId, anchor.id);
+  }
+
+  // --- Helpers ---
+  function estimateTokens(msg: AgentMessage): number {
+    const content = msg.content;
+    if (!content) return 0;
+    if (msg.type === 'cost') return 0; // meta, not in context
+    let text = '';
+    if (typeof content === 'string') text = content;
+    else if (typeof content === 'object' && content !== null) {
+      if ('text' in content) text = String((content as Record<string, unknown>).text ?? '');
+      else if ('output' in content) text = String((content as Record<string, unknown>).output ?? '');
+      else if ('name' in content) text = JSON.stringify(content);
+      else text = JSON.stringify(content);
+    }
+    // ~4 chars per token
+    return Math.ceil(text.length / 4);
+  }
+
+
+  function formatTokens(n: number): string {
+    if (n >= 1_000_000) return `${(n / 1_000_000).toFixed(1)}M`;
+    if (n >= 1_000) return `${(n / 1_000).toFixed(1)}k`;
+    return String(n);
+  }
+
+  function formatCost(usd: number): string {
+    if (usd === 0) return '$0.00';
+    if (usd < 0.01) return `$${usd.toFixed(4)}`;
+    return `$${usd.toFixed(2)}`;
+  }
+
+  function formatDuration(ms: number): string {
+    if (ms < 1000) return `${ms}ms`;
+    const s = Math.floor(ms / 1000);
+    if (s < 60) return `${s}s`;
+    const m = Math.floor(s / 60);
+    return `${m}m ${s % 60}s`;
+  }
+
+  // --- Cost analytics ---
+  let avgCostPerTurn = $derived(
+    session && session.numTurns > 0
+      ? totalCost.costUsd / session.numTurns
+      : 0
+  );
+
+  let tokenEfficiency = $derived(
+    totalCost.inputTokens > 0
+      ? totalCost.outputTokens / totalCost.inputTokens
+      : 0
+  );
+
+  let burnRatePerHr = $derived.by(() => {
+    if (!session || session.durationMs <= 0 || totalCost.costUsd <= 0) return 0;
+    return (totalCost.costUsd / session.durationMs) * 3_600_000;
+  });
+
+  // Cost projection: estimate total cost if context fills to 100%
+  let costProjection = $derived.by(() => {
+    const usedPct = totalCost.inputTokens / CONTEXT_WINDOW;
+    if (usedPct <= 0) return 0;
+    return totalCost.costUsd / usedPct;
+  });
+
+  function opColor(op: string): string {
+    switch (op) {
+      case 'read': return 'var(--ctp-blue)';
+      case 'write': return 'var(--ctp-peach)';
+      case 'grep': return 'var(--ctp-mauve)';
+      case 'glob': return 'var(--ctp-teal)';
+      case 'bash': return 'var(--ctp-yellow)';
+      default: return 'var(--ctp-overlay1)';
+    }
+  }
+
+  function msgTypeLabel(type: string): string {
+    switch (type) {
+      case 'text': return 'Assistant';
+      case 'thinking': return 'Thinking';
+      case 'tool_call': return 'Tool Call';
+      case 'tool_result': return 'Tool Result';
+      case 'init': return 'Init';
+      case 'cost': return 'Cost';
+      case 'error': return 'Error';
+      case 'status': return 'Status';
+      default: return type;
+    }
+  }
+
+  function msgTypeColor(type: string): string {
+    switch (type) {
+      case 'text': return 'var(--ctp-green)';
+      case 'thinking': return 'var(--ctp-mauve)';
+      case 'tool_call': return 'var(--ctp-peach)';
+      case 'tool_result': return 'var(--ctp-blue)';
+      case 'error': return 'var(--ctp-red)';
+      default: return 'var(--ctp-overlay1)';
+    }
+  }
+
+  // Expanded turn tracking
+  let expandedTurns = $state<Set<number>>(new Set());
+
+  function toggleTurn(idx: number) {
+    const next = new Set(expandedTurns);
+    if (next.has(idx)) next.delete(idx);
+    else next.add(idx);
+    expandedTurns = next;
+  }
+
+  // --- Sub-tab navigation ---
+  type ContextSubTab = 'overview' | 'ast' | 'graph';
+  let activeSubTab = $state<ContextSubTab>('overview');
+
+  // --- AST Tree ---
+  interface AstNode {
+    id: string;
+    label: string;
+    type: 'turn' | 'thinking' | 'text' | 'tool_call' | 'tool_result' | 'file' | 'error';
+    color: string;
+    tokens: number;
+    children: AstNode[];
+    detail?: string;
+  }
+
+  let astTree = $derived.by((): AstNode[] => {
+    const turnNodes: AstNode[] = [];
+    let turnIdx = 0;
+    let currentTurn: AstNode | null = null;
+    let currentToolCall: AstNode | null = null;
+
+    for (const msg of messages) {
+      if (msg.type === 'init' || msg.type === 'status') continue;
+
+      if (msg.type === 'compaction') {
+        // Insert compaction boundary marker
+        if (currentTurn) {
+          turnNodes.push(currentTurn);
+          currentTurn = null;
+          currentToolCall = null;
+        }
+        const c = msg.content as CompactionContent;
+        turnNodes.push({
+          id: `compact-${msg.id}`,
+          label: `Compacted (${c.trigger})`,
+          type: 'turn',
+          color: 'var(--ctp-red)',
+          tokens: c.preTokens,
+          children: [{
+            id: `compact-detail-${msg.id}`,
+            label: `${formatTokens(c.preTokens)} tokens removed`,
+            type: 'error',
+            color: 'var(--ctp-red)',
+            tokens: 0,
+            children: [],
+            detail: `Context was ${c.trigger === 'auto' ? 'automatically' : 'manually'} compacted. ${formatTokens(c.preTokens)} tokens of earlier conversation were summarized.`,
+          }],
+        });
+        continue;
+      }
+
+      if (msg.type === 'cost') {
+        // End of turn
+        if (currentTurn) {
+          turnNodes.push(currentTurn);
+          currentTurn = null;
+          currentToolCall = null;
+        }
+        continue;
+      }
+
+      // Start new turn if needed
+      if (!currentTurn) {
+        currentTurn = {
+          id: `turn-${turnIdx}`,
+          label: `Turn ${++turnIdx}`,
+          type: 'turn',
+          color: 'var(--ctp-lavender)',
+          tokens: 0,
+          children: [],
+        };
+      }
+
+      const est = estimateTokens(msg);
+      currentTurn.tokens += est;
+
+      if (msg.type === 'thinking') {
+        currentTurn.children.push({
+          id: `think-${msg.id}`,
+          label: 'Thinking',
+          type: 'thinking',
+          color: 'var(--ctp-mauve)',
+          tokens: est,
+          children: [],
+          detail: truncateText(extractText(msg), 60),
+        });
+        currentToolCall = null;
+      } else if (msg.type === 'text') {
+        currentTurn.children.push({
+          id: `text-${msg.id}`,
+          label: 'Response',
+          type: 'text',
+          color: 'var(--ctp-green)',
+          tokens: est,
+          children: [],
+          detail: truncateText(extractText(msg), 60),
+        });
+        currentToolCall = null;
+      } else if (msg.type === 'tool_call') {
+        const tc = msg.content as ToolCallContent;
+        const tcNode: AstNode = {
+          id: `tc-${tc.toolUseId}`,
+          label: tc.name,
+          type: 'tool_call',
+          color: 'var(--ctp-peach)',
+          tokens: est,
+          children: [],
+        };
+
+        // Add file references as children of tool call
+        const files = extractFilePaths(tc);
+        for (const f of files) {
+          tcNode.children.push({
+            id: `file-${tc.toolUseId}-${f.path}`,
+            label: f.path.split('/').pop() ?? f.path,
+            type: 'file',
+            color: opColor(f.op),
+            tokens: 0,
+            children: [],
+            detail: f.path,
+          });
+        }
+
+        currentTurn.children.push(tcNode);
+        currentToolCall = tcNode;
+      } else if (msg.type === 'tool_result') {
+        // Attach result size to the matching tool call
+        if (currentToolCall) {
+          currentToolCall.tokens += est;
+          currentToolCall.detail = `${formatTokens(currentToolCall.tokens)} tokens`;
+        }
+      } else if (msg.type === 'error') {
+        currentTurn.children.push({
+          id: `err-${msg.id}`,
+          label: 'Error',
+          type: 'error',
+          color: 'var(--ctp-red)',
+          tokens: est,
+          children: [],
+          detail: extractText(msg),
+        });
+      }
+    }
+
+    // Push final turn if not ended by cost
+    if (currentTurn && currentTurn.children.length > 0) {
+      turnNodes.push(currentTurn);
+    }
+
+    return turnNodes;
+  });
+
+  // --- Tool Graph ---
+  interface GraphNode {
+    id: string;
+    label: string;
+    type: 'file' | 'tool';
+    x: number;
+    y: number;
+    color: string;
+    count: number;
+  }
+
+  interface GraphEdge {
+    from: string;
+    to: string;
+    op: string;
+    color: string;
+  }
+
+  let toolGraph = $derived.by((): { nodes: GraphNode[]; edges: GraphEdge[] } => {
+    const fileNodes = new Map<string, { label: string; count: number; ops: Set<string> }>();
+    const toolNodes = new Map<string, { count: number }>();
+    const edges: GraphEdge[] = [];
+
+    for (const msg of messages) {
+      if (msg.type !== 'tool_call') continue;
+      const tc = msg.content as ToolCallContent;
+      const toolName = tc.name;
+
+      // Track tool node
+      const existing = toolNodes.get(toolName);
+      if (existing) existing.count++;
+      else toolNodes.set(toolName, { count: 1 });
+
+      // Track file nodes and edges
+      const files = extractFilePaths(tc);
+      for (const f of files) {
+        const fNode = fileNodes.get(f.path);
+        if (fNode) {
+          fNode.count++;
+          fNode.ops.add(f.op);
+        } else {
+          fileNodes.set(f.path, {
+            label: f.path.split('/').pop() ?? f.path,
+            count: 1,
+            ops: new Set([f.op]),
+          });
+        }
+
+        edges.push({
+          from: `tool-${toolName}`,
+          to: `file-${f.path}`,
+          op: f.op,
+          color: opColor(f.op),
+        });
+      }
+    }
+
+    // Layout: tools on left, files on right
+    const nodes: GraphNode[] = [];
+    const toolList = Array.from(toolNodes.entries()).sort((a, b) => b[1].count - a[1].count);
+    const fileList = Array.from(fileNodes.entries()).sort((a, b) => b[1].count - a[1].count);
+
+    const NODE_SPACING = 36;
+    const LEFT_X = 20;
+    const RIGHT_X = 220;
+
+    toolList.forEach(([name, data], i) => {
+      nodes.push({
+        id: `tool-${name}`,
+        label: name,
+        type: 'tool',
+        x: LEFT_X,
+        y: 20 + i * NODE_SPACING,
+        color: toolColor(name),
+        count: data.count,
+      });
+    });
+
+    fileList.forEach(([path, data], i) => {
+      nodes.push({
+        id: `file-${path}`,
+        label: data.label,
+        type: 'file',
+        x: RIGHT_X,
+        y: 20 + i * NODE_SPACING,
+        color: 'var(--ctp-text)',
+        count: data.count,
+      });
+    });
+
+    // Deduplicate edges (same from→to, aggregate)
+    const edgeMap = new Map<string, GraphEdge>();
+    for (const e of edges) {
+      const key = `${e.from}→${e.to}`;
+      if (!edgeMap.has(key)) edgeMap.set(key, e);
+    }
+
+    return { nodes, edges: Array.from(edgeMap.values()) };
+  });
+
+  // AST layout helpers
+  const AST_NODE_W = 110;
+  const AST_NODE_H = 28;
+  const AST_H_GAP = 16;
+  const AST_V_GAP = 6;
+
+  interface AstLayout {
+    node: AstNode;
+    x: number;
+    y: number;
+    children: AstLayout[];
+  }
+
+  function layoutAst(node: AstNode, x: number, y: number): { layout: AstLayout; height: number } {
+    if (node.children.length === 0) {
+      return { layout: { node, x, y, children: [] }, height: AST_NODE_H };
+    }
+
+    const childLayouts: AstLayout[] = [];
+    let childY = y;
+    let totalHeight = 0;
+
+    for (const child of node.children) {
+      const result = layoutAst(child, x + AST_NODE_W + AST_H_GAP, childY);
+      childLayouts.push(result.layout);
+      childY += result.height + AST_V_GAP;
+      totalHeight += result.height + AST_V_GAP;
+    }
+    totalHeight -= AST_V_GAP;
+
+    const parentY = childLayouts.length > 0
+      ? (childLayouts[0].y + childLayouts[childLayouts.length - 1].y) / 2
+      : y;
+
+    return {
+      layout: { node, x, y: parentY, children: childLayouts },
+      height: Math.max(AST_NODE_H, totalHeight),
+    };
+  }
+
+  function astSvgWidth(layout: AstLayout): number {
+    let maxX = layout.x + AST_NODE_W;
+    for (const child of layout.children) maxX = Math.max(maxX, astSvgWidth(child));
+    return maxX + 12;
+  }
+
+  // Helpers
+  function extractText(msg: AgentMessage): string {
+    const c = msg.content;
+    if (typeof c === 'string') return c;
+    if (c && typeof c === 'object' && 'text' in c) return String((c as Record<string, unknown>).text ?? '');
+    if (c && typeof c === 'object' && 'message' in c) return String((c as Record<string, unknown>).message ?? '');
+    return '';
+  }
+
+  function truncateText(text: string, maxLen: number): string {
+    if (text.length <= maxLen) return text;
+    return text.slice(0, maxLen - 1) + '…';
+  }
+
+  function toolColor(name: string): string {
+    switch (name) {
+      case 'Read': case 'read': return 'var(--ctp-blue)';
+      case 'Write': case 'write': return 'var(--ctp-peach)';
+      case 'Edit': case 'edit': return 'var(--ctp-peach)';
+      case 'Grep': case 'grep': return 'var(--ctp-mauve)';
+      case 'Glob': case 'glob': return 'var(--ctp-teal)';
+      case 'Bash': case 'bash': return 'var(--ctp-yellow)';
+      case 'Agent': case 'Task': return 'var(--ctp-flamingo)';
+      default: return 'var(--ctp-sapphire)';
+    }
+  }
+</script>
+
+<div class="context-tab">
+  {#if !session}
+    <div class="empty-state">
+      <div class="empty-icon">
+        <svg width="32" height="32" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.2">
+          <circle cx="12" cy="12" r="10"/>
+          <path d="M12 6v6l4 2"/>
+        </svg>
+      </div>
+      <p class="empty-title">No active session</p>
+      <p class="empty-hint">Start an agent session to see context window analysis</p>
+    </div>
+  {:else}
+    <!-- Sub-tab switcher -->
+    <div class="sub-tabs">
+      <button class="sub-tab" class:active={activeSubTab === 'overview'} onclick={() => activeSubTab = 'overview'}>Overview</button>
+      <button class="sub-tab" class:active={activeSubTab === 'ast'} onclick={() => activeSubTab = 'ast'}>AST</button>
+      <button class="sub-tab" class:active={activeSubTab === 'graph'} onclick={() => activeSubTab = 'graph'}>Graph</button>
+    </div>
+
+    <!-- Overview panel -->
+    <div class="sub-panel" style:display={activeSubTab === 'overview' ? 'flex' : 'none'}>
+    <!-- Stats Bar -->
+    <div class="stats-bar">
+      <div class="stat">
+        <span class="stat-value">{formatTokens(totalCost.inputTokens)}</span>
+        <span class="stat-label">input</span>
+      </div>
+      <div class="stat">
+        <span class="stat-value">{formatTokens(totalCost.outputTokens)}</span>
+        <span class="stat-label">output</span>
+      </div>
+      <div class="stat">
+        <span class="stat-value">{session.numTurns}</span>
+        <span class="stat-label">turns</span>
+      </div>
+      <div class="stat">
+        <span class="stat-value cost">{formatCost(totalCost.costUsd)}</span>
+        <span class="stat-label">cost</span>
+      </div>
+      <div class="stat">
+        <span class="stat-value">{formatDuration(session.durationMs)}</span>
+        <span class="stat-label">time</span>
+      </div>
+      <div class="stat status-pill" class:running={session.status === 'running'} class:done={session.status === 'done'} class:error={session.status === 'error'}>
+        <span class="stat-value">{session.status}</span>
+      </div>
+      {#if compactions.length > 0}
+        <div class="stat compaction-pill" title="Context compacted {compactions.length} time{compactions.length > 1 ? 's' : ''}. Last: {lastCompaction?.trigger} ({formatTokens(lastCompaction?.preTokens ?? 0)} tokens summarized)">
+          <span class="stat-value">{compactions.length}×</span>
+          <span class="stat-label">compacted</span>
+        </div>
+      {/if}
+    </div>
+
+    <!-- Cost Analytics -->
+    {#if totalCost.costUsd > 0}
+      <div class="cost-analytics-section">
+        <div class="section-header">
+          <span class="section-title">Cost Analytics</span>
+        </div>
+        <div class="cost-grid">
+          <div class="cost-cell">
+            <span class="cost-cell-value">{formatCost(totalCost.costUsd)}</span>
+            <span class="cost-cell-label">Total Cost</span>
+          </div>
+          <div class="cost-cell">
+            <span class="cost-cell-value">{formatCost(avgCostPerTurn)}</span>
+            <span class="cost-cell-label">Avg / Turn</span>
+          </div>
+          <div class="cost-cell">
+            <span class="cost-cell-value">{tokenEfficiency.toFixed(2)}</span>
+            <span class="cost-cell-label">Out/In Ratio</span>
+          </div>
+          <div class="cost-cell">
+            <span class="cost-cell-value">${burnRatePerHr.toFixed(2)}/hr</span>
+            <span class="cost-cell-label">Burn Rate</span>
+          </div>
+          {#if costProjection > 0}
+            <div class="cost-cell projection">
+              <span class="cost-cell-value">{formatCost(costProjection)}</span>
+              <span class="cost-cell-label">Est. Full Context</span>
+            </div>
+          {/if}
+        </div>
+      </div>
+    {/if}
+
+    <!-- Context Meter -->
+    <div class="meter-section">
+      <div class="meter-header">
+        <span class="meter-title">Context Window</span>
+        <span class="meter-usage">{formatTokens(totalCost.inputTokens)} / {formatTokens(CONTEXT_WINDOW)}</span>
+      </div>
+      <div class="meter-bar">
+        {#each categories as cat}
+          <div
+            class="meter-segment"
+            style="width: {cat.pct}%; background: {cat.color}"
+            title="{cat.label}: {formatTokens(cat.tokens)} ({cat.pct.toFixed(1)}%)"
+          ></div>
+        {/each}
+        <div class="meter-empty" style="flex: 1"></div>
+      </div>
+      <div class="meter-legend">
+        {#each categories as cat}
+          <div class="legend-item">
+            <span class="legend-dot" style="background: {cat.color}"></span>
+            <span class="legend-label">{cat.label}</span>
+            <span class="legend-value">{formatTokens(cat.tokens)}</span>
+          </div>
+        {/each}
+      </div>
+    </div>
+
+    <!-- Session Anchors -->
+    {#if anchors.length > 0}
+      <div class="anchors-section">
+        <div class="section-header">
+          <span class="section-title">Session Anchors</span>
+          <span class="section-count">{anchors.length}</span>
+          {#if injectableAnchors.length > 0}
+            <span class="anchor-injectable-badge" title="Re-injected into system prompt on next query">
+              {injectableAnchors.length} injectable
+            </span>
+          {/if}
+        </div>
+
+        <!-- Budget meter -->
+        <div class="anchor-budget">
+          <div class="anchor-budget-header">
+            <span class="anchor-budget-label">Anchor Budget</span>
+            <span class="anchor-budget-usage">{formatTokens(anchorTokens)} / {formatTokens(anchorBudget)}</span>
+          </div>
+          <div class="anchor-budget-bar">
+            <div
+              class="anchor-budget-fill"
+              class:warn={anchorBudgetPct > 75}
+              class:full={anchorBudgetPct >= 100}
+              style="width: {anchorBudgetPct}%"
+            ></div>
+          </div>
+        </div>
+
+        <!-- Anchor list -->
+        <div class="anchor-list">
+          {#each anchors as anchor (anchor.id)}
+            <div class="anchor-item">
+              <span class="anchor-type-dot" style="background: {anchorTypeColor(anchor.anchorType)}"></span>
+              <span class="anchor-type-label" style="color: {anchorTypeColor(anchor.anchorType)}">{anchorTypeLabel(anchor.anchorType)}</span>
+              <span class="anchor-content" title={anchor.content}>{anchor.content.split('\n')[0].slice(0, 60)}{anchor.content.length > 60 ? '...' : ''}</span>
+              <span class="anchor-tokens">{formatTokens(anchor.estimatedTokens)}</span>
+              <div class="anchor-actions">
+                {#if anchor.anchorType === 'pinned'}
+                  <button
+                    class="anchor-action-btn"
+                    title="Promote to injectable (re-injected on next query)"
+                    onclick={() => handlePromote(anchor)}
+                  >
+                    <svg width="10" height="10" viewBox="0 0 24 24" fill="none" stroke="var(--ctp-green)" stroke-width="2">
+                      <path d="M12 19V5M5 12l7-7 7 7"/>
+                    </svg>
+                  </button>
+                {:else if anchor.anchorType === 'promoted'}
+                  <button
+                    class="anchor-action-btn"
+                    title="Demote to pinned (display only)"
+                    onclick={() => handlePromote(anchor)}
+                  >
+                    <svg width="10" height="10" viewBox="0 0 24 24" fill="none" stroke="var(--ctp-yellow)" stroke-width="2">
+                      <path d="M12 5v14M5 12l7 7 7-7"/>
+                    </svg>
+                  </button>
+                {/if}
+                <button
+                  class="anchor-action-btn anchor-remove-btn"
+                  title="Remove anchor"
+                  onclick={() => handleRemoveAnchor(anchor)}
+                >
+                  <svg width="10" height="10" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+                    <path d="M18 6L6 18M6 6l12 12"/>
+                  </svg>
+                </button>
+              </div>
+            </div>
+          {/each}
+        </div>
+      </div>
+    {/if}
+
+    <!-- File References -->
+    {#if fileRefs.length > 0}
+      <div class="files-section">
+        <div class="section-header">
+          <span class="section-title">Files Touched</span>
+          <span class="section-count">{fileRefs.length}</span>
+        </div>
+        <div class="files-list">
+          {#each fileRefs.slice(0, 30) as ref (ref.path)}
+            <div class="file-ref">
+              <div class="file-ops">
+                {#each Array.from(ref.ops) as op}
+                  <span class="file-op" style="color: {opColor(op)}" title="{op}">{op[0].toUpperCase()}</span>
+                {/each}
+              </div>
+              <span class="file-name" title={ref.path}>{ref.shortName}</span>
+              <span class="file-count">{ref.count}×</span>
+            </div>
+          {/each}
+          {#if fileRefs.length > 30}
+            <div class="files-more">+{fileRefs.length - 30} more</div>
+          {/if}
+        </div>
+      </div>
+    {/if}
+
+    <!-- Turn Breakdown -->
+    <div class="turns-section">
+      <div class="section-header">
+        <span class="section-title">Turns</span>
+        <span class="section-count">{turns.length}</span>
+      </div>
+      <div class="turns-list">
+        {#each turns as turn (turn.index)}
+          <div class="turn-group">
+            <button class="turn-header" onclick={() => toggleTurn(turn.index)}>
+              <span class="turn-chevron" class:open={expandedTurns.has(turn.index)}>
+                <svg width="10" height="10" viewBox="0 0 10 10" fill="none">
+                  <path d="M3 2l4 3-4 3" stroke="currentColor" stroke-width="1.2" stroke-linecap="round" stroke-linejoin="round"/>
+                </svg>
+              </span>
+              <span class="turn-index">#{turn.index + 1}</span>
+              <span class="turn-tools">
+                {#each turn.toolCalls.slice(0, 3) as tc}
+                  <span class="turn-tool-badge">{tc.name}</span>
+                {/each}
+                {#if turn.toolCalls.length > 3}
+                  <span class="turn-tool-more">+{turn.toolCalls.length - 3}</span>
+                {/if}
+              </span>
+              <span class="turn-tokens">{formatTokens(turn.estimatedTokens)}</span>
+            </button>
+
+            {#if expandedTurns.has(turn.index)}
+              <div class="turn-detail">
+                {#each turn.messages as msg}
+                  {#if msg.type !== 'cost' && msg.type !== 'status' && msg.type !== 'init'}
+                    <div class="turn-msg">
+                      <span class="turn-msg-type" style="color: {msgTypeColor(msg.type)}">{msgTypeLabel(msg.type)}</span>
+                      <span class="turn-msg-tokens">~{formatTokens(estimateTokens(msg))}</span>
+                      {#if msg.type === 'tool_call'}
+                        {@const tc = msg.content as ToolCallContent}
+                        <span class="turn-msg-name">{tc.name}</span>
+                      {/if}
+                    </div>
+                  {/if}
+                {/each}
+              </div>
+            {/if}
+          </div>
+        {/each}
+        {#if turns.length === 0}
+          <div class="turns-empty">No turns yet</div>
+        {/if}
+      </div>
+    </div>
+    </div>
+
+    <!-- AST panel -->
+    <div class="sub-panel ast-panel" style:display={activeSubTab === 'ast' ? 'flex' : 'none'}>
+      {#if astTree.length === 0}
+        <div class="turns-empty">No conversation data yet</div>
+      {:else}
+        <div class="ast-scroll">
+          {#each astTree as turnNode (turnNode.id)}
+            {@const result = layoutAst(turnNode, 8, 8)}
+            {@const svgW = astSvgWidth(result.layout)}
+            {@const svgH = Math.max(50, result.height + 20)}
+            <div class="ast-turn-block">
+              <div class="ast-turn-label">
+                <span class="ast-turn-name">{turnNode.label}</span>
+                <span class="ast-turn-tokens">{formatTokens(turnNode.tokens)}</span>
+              </div>
+              <div class="ast-svg-wrap">
+                <svg width={svgW} height={svgH}>
+                  {#snippet renderAstNode(layout: AstLayout)}
+                    <!-- Edges -->
+                    {#each layout.children as child}
+                      <path
+                        d="M {layout.x + AST_NODE_W} {layout.y + AST_NODE_H / 2}
+                           C {layout.x + AST_NODE_W + AST_H_GAP / 2} {layout.y + AST_NODE_H / 2},
+                             {child.x - AST_H_GAP / 2} {child.y + AST_NODE_H / 2},
+                             {child.x} {child.y + AST_NODE_H / 2}"
+                        fill="none"
+                        stroke="var(--ctp-surface1)"
+                        stroke-width="1"
+                      />
+                    {/each}
+
+                    <!-- Node -->
+                    <rect
+                      x={layout.x}
+                      y={layout.y}
+                      width={AST_NODE_W}
+                      height={AST_NODE_H}
+                      rx="4"
+                      fill="color-mix(in srgb, {layout.node.color} 12%, var(--ctp-surface0))"
+                      stroke={layout.node.color}
+                      stroke-width="1"
+                    />
+                    <!-- Status dot -->
+                    <circle
+                      cx={layout.x + 8}
+                      cy={layout.y + AST_NODE_H / 2}
+                      r="3"
+                      fill={layout.node.color}
+                    />
+                    <!-- Label -->
+                    <text
+                      x={layout.x + 16}
+                      y={layout.y + AST_NODE_H / 2}
+                      fill="var(--ctp-text)"
+                      font-size="9"
+                      font-family="var(--term-font-family, monospace)"
+                      dominant-baseline="middle"
+                    >{truncateText(layout.node.label, 12)}</text>
+                    <!-- Token count (right side) -->
+                    {#if layout.node.tokens > 0}
+                      <text
+                        x={layout.x + AST_NODE_W - 4}
+                        y={layout.y + AST_NODE_H / 2}
+                        fill="var(--ctp-overlay0)"
+                        font-size="7"
+                        font-family="var(--term-font-family, monospace)"
+                        dominant-baseline="middle"
+                        text-anchor="end"
+                      >{formatTokens(layout.node.tokens)}</text>
+                    {/if}
+
+                    <!-- Tooltip title -->
+                    {#if layout.node.detail}
+                      <title>{layout.node.detail}</title>
+                    {/if}
+
+                    {#each layout.children as child}
+                      {@render renderAstNode(child)}
+                    {/each}
+                  {/snippet}
+
+                  {@render renderAstNode(result.layout)}
+                </svg>
+              </div>
+            </div>
+          {/each}
+        </div>
+      {/if}
+    </div>
+
+    <!-- Graph panel -->
+    <div class="sub-panel graph-panel" style:display={activeSubTab === 'graph' ? 'flex' : 'none'}>
+      {#if toolGraph.nodes.length === 0}
+        <div class="turns-empty">No tool calls yet</div>
+      {:else}
+        {@const maxY = Math.max(...toolGraph.nodes.map(n => n.y)) + 40}
+        <div class="graph-scroll">
+          <svg width="380" height={maxY}>
+            <!-- Edges -->
+            {#each toolGraph.edges as edge}
+              {@const fromNode = toolGraph.nodes.find(n => n.id === edge.from)}
+              {@const toNode = toolGraph.nodes.find(n => n.id === edge.to)}
+              {#if fromNode && toNode}
+                <path
+                  d="M {fromNode.x + 80} {fromNode.y + 14}
+                     C {fromNode.x + 140} {fromNode.y + 14},
+                       {toNode.x - 60} {toNode.y + 14},
+                       {toNode.x} {toNode.y + 14}"
+                  fill="none"
+                  stroke={edge.color}
+                  stroke-width="1"
+                  opacity="0.4"
+                />
+              {/if}
+            {/each}
+
+            <!-- Nodes -->
+            {#each toolGraph.nodes as node (node.id)}
+              {#if node.type === 'tool'}
+                <!-- Tool node (left side) -->
+                <rect
+                  x={node.x}
+                  y={node.y}
+                  width="80"
+                  height="28"
+                  rx="4"
+                  fill="color-mix(in srgb, {node.color} 15%, var(--ctp-surface0))"
+                  stroke={node.color}
+                  stroke-width="1"
+                />
+                <text
+                  x={node.x + 8}
+                  y={node.y + 14}
+                  fill={node.color}
+                  font-size="9"
+                  font-weight="600"
+                  font-family="var(--term-font-family, monospace)"
+                  dominant-baseline="middle"
+                >{node.label}</text>
+                <text
+                  x={node.x + 76}
+                  y={node.y + 14}
+                  fill="var(--ctp-overlay0)"
+                  font-size="7"
+                  font-family="var(--term-font-family, monospace)"
+                  dominant-baseline="middle"
+                  text-anchor="end"
+                >{node.count}×</text>
+              {:else}
+                <!-- File node (right side) -->
+                <rect
+                  x={node.x}
+                  y={node.y}
+                  width="140"
+                  height="28"
+                  rx="4"
+                  fill="var(--ctp-surface0)"
+                  stroke="var(--ctp-surface1)"
+                  stroke-width="1"
+                />
+                <text
+                  x={node.x + 8}
+                  y={node.y + 14}
+                  fill="var(--ctp-text)"
+                  font-size="8"
+                  font-family="var(--term-font-family, monospace)"
+                  dominant-baseline="middle"
+                >{truncateText(node.label, 16)}</text>
+                <text
+                  x={node.x + 136}
+                  y={node.y + 14}
+                  fill="var(--ctp-overlay0)"
+                  font-size="7"
+                  font-family="var(--term-font-family, monospace)"
+                  dominant-baseline="middle"
+                  text-anchor="end"
+                >{node.count}×</text>
+              {/if}
+            {/each}
+
+            <!-- Column headers -->
+            <text x="20" y="10" fill="var(--ctp-overlay0)" font-size="8" font-weight="600" text-transform="uppercase">Tools</text>
+            <text x="220" y="10" fill="var(--ctp-overlay0)" font-size="8" font-weight="600" text-transform="uppercase">Files</text>
+          </svg>
+        </div>
+      {/if}
+    </div>
+  {/if}
+</div>
+
+<style>
+  .context-tab {
+    display: flex;
+    flex-direction: column;
+    height: 100%;
+    overflow-y: auto;
+    background: var(--ctp-base);
+    color: var(--ctp-text);
+    gap: 0.125rem;
+  }
+
+  /* Empty state */
+  .empty-state {
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    justify-content: center;
+    height: 100%;
+    gap: 0.5rem;
+    padding: 2rem;
+    text-align: center;
+  }
+
+  .empty-icon { color: var(--ctp-overlay0); }
+  .empty-title { font-size: 0.85rem; font-weight: 600; color: var(--ctp-subtext1); margin: 0; }
+  .empty-hint { font-size: 0.7rem; color: var(--ctp-overlay0); margin: 0; }
+
+  /* Stats bar */
+  .stats-bar {
+    display: flex;
+    gap: 0.125rem;
+    padding: 0.5rem 0.625rem;
+    border-bottom: 1px solid var(--ctp-surface0);
+    flex-shrink: 0;
+    flex-wrap: wrap;
+  }
+
+  .stat {
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    padding: 0.25rem 0.5rem;
+    background: var(--ctp-surface0);
+    border-radius: 0.25rem;
+    min-width: 3rem;
+  }
+
+  .stat-value {
+    font-size: 0.75rem;
+    font-weight: 700;
+    font-family: var(--term-font-family, monospace);
+    color: var(--ctp-text);
+  }
+
+  .stat-value.cost { color: var(--ctp-green); }
+
+  .stat-label {
+    font-size: 0.55rem;
+    color: var(--ctp-overlay0);
+    text-transform: uppercase;
+    letter-spacing: 0.05em;
+  }
+
+  .status-pill {
+    margin-left: auto;
+  }
+
+  .status-pill.running { background: color-mix(in srgb, var(--ctp-green) 15%, transparent); }
+  .status-pill.running .stat-value { color: var(--ctp-green); }
+  .status-pill.done { background: color-mix(in srgb, var(--ctp-blue) 15%, transparent); }
+  .status-pill.done .stat-value { color: var(--ctp-blue); }
+  .status-pill.error { background: color-mix(in srgb, var(--ctp-red) 15%, transparent); }
+  .status-pill.error .stat-value { color: var(--ctp-red); }
+
+  .compaction-pill {
+    background: color-mix(in srgb, var(--ctp-yellow) 15%, transparent);
+  }
+  .compaction-pill .stat-value { color: var(--ctp-yellow); }
+  .compaction-pill .stat-label { color: var(--ctp-yellow); opacity: 0.7; }
+
+  /* Cost Analytics */
+  .cost-analytics-section {
+    padding: 0.375rem 0.625rem;
+    border-bottom: 1px solid var(--ctp-surface0);
+    flex-shrink: 0;
+  }
+
+  .cost-grid {
+    display: grid;
+    grid-template-columns: repeat(auto-fill, minmax(5rem, 1fr));
+    gap: 0.375rem;
+    margin-top: 0.25rem;
+  }
+
+  .cost-cell {
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    padding: 0.375rem 0.25rem;
+    background: var(--ctp-surface0);
+    border-radius: 0.25rem;
+  }
+
+  .cost-cell-value {
+    font-size: 0.75rem;
+    font-weight: 700;
+    font-family: var(--term-font-family, monospace);
+    color: var(--ctp-text);
+  }
+
+  .cost-cell-label {
+    font-size: 0.55rem;
+    color: var(--ctp-overlay0);
+    text-transform: uppercase;
+    letter-spacing: 0.05em;
+    margin-top: 0.125rem;
+  }
+
+  .cost-cell.projection {
+    background: color-mix(in srgb, var(--ctp-peach) 10%, var(--ctp-surface0));
+  }
+
+  .cost-cell.projection .cost-cell-value {
+    color: var(--ctp-peach);
+  }
+
+  /* Context meter */
+  .meter-section {
+    padding: 0.5rem 0.625rem;
+    border-bottom: 1px solid var(--ctp-surface0);
+    flex-shrink: 0;
+  }
+
+  .meter-header {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    margin-bottom: 0.375rem;
+  }
+
+  .meter-title {
+    font-size: 0.7rem;
+    font-weight: 600;
+    color: var(--ctp-subtext1);
+  }
+
+  .meter-usage {
+    font-size: 0.625rem;
+    font-family: var(--term-font-family, monospace);
+    color: var(--ctp-overlay1);
+  }
+
+  .meter-bar {
+    display: flex;
+    height: 1.25rem;
+    border-radius: 0.375rem;
+    overflow: hidden;
+    background: var(--ctp-surface0);
+    gap: 1px;
+  }
+
+  .meter-segment {
+    height: 100%;
+    min-width: 2px;
+    transition: width 0.4s ease;
+    position: relative;
+  }
+
+  .meter-segment:hover {
+    filter: brightness(1.2);
+  }
+
+  .meter-empty {
+    background: transparent;
+  }
+
+  .meter-legend {
+    display: flex;
+    flex-wrap: wrap;
+    gap: 0.375rem 0.75rem;
+    margin-top: 0.375rem;
+  }
+
+  .legend-item {
+    display: flex;
+    align-items: center;
+    gap: 0.25rem;
+  }
+
+  .legend-dot {
+    width: 0.375rem;
+    height: 0.375rem;
+    border-radius: 50%;
+    flex-shrink: 0;
+  }
+
+  .legend-label {
+    font-size: 0.575rem;
+    color: var(--ctp-overlay1);
+  }
+
+  .legend-value {
+    font-size: 0.575rem;
+    font-family: var(--term-font-family, monospace);
+    color: var(--ctp-subtext0);
+  }
+
+  /* File references */
+  .files-section {
+    padding: 0.375rem 0.625rem;
+    border-bottom: 1px solid var(--ctp-surface0);
+    flex-shrink: 0;
+  }
+
+  .section-header {
+    display: flex;
+    align-items: center;
+    gap: 0.375rem;
+    margin-bottom: 0.375rem;
+  }
+
+  .section-title {
+    font-size: 0.7rem;
+    font-weight: 600;
+    color: var(--ctp-subtext1);
+  }
+
+  .section-count {
+    font-size: 0.575rem;
+    color: var(--ctp-overlay0);
+    background: var(--ctp-surface0);
+    padding: 0.0625rem 0.3125rem;
+    border-radius: 0.625rem;
+    font-family: var(--term-font-family, monospace);
+  }
+
+  .files-list {
+    display: flex;
+    flex-direction: column;
+    gap: 1px;
+    max-height: 12rem;
+    overflow-y: auto;
+  }
+
+  .file-ref {
+    display: flex;
+    align-items: center;
+    gap: 0.375rem;
+    padding: 0.1875rem 0.375rem;
+    border-radius: 0.1875rem;
+    transition: background 0.1s;
+  }
+
+  .file-ref:hover {
+    background: var(--ctp-surface0);
+  }
+
+  .file-ops {
+    display: flex;
+    gap: 0.125rem;
+    flex-shrink: 0;
+  }
+
+  .file-op {
+    font-size: 0.5rem;
+    font-weight: 700;
+    font-family: var(--term-font-family, monospace);
+    width: 0.875rem;
+    height: 0.875rem;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    border-radius: 0.125rem;
+    background: color-mix(in srgb, currentColor 12%, transparent);
+  }
+
+  .file-name {
+    font-size: 0.65rem;
+    font-family: var(--term-font-family, monospace);
+    color: var(--ctp-text);
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+    flex: 1;
+    min-width: 0;
+  }
+
+  .file-count {
+    font-size: 0.55rem;
+    color: var(--ctp-overlay0);
+    font-family: var(--term-font-family, monospace);
+    flex-shrink: 0;
+  }
+
+  .files-more {
+    font-size: 0.6rem;
+    color: var(--ctp-overlay0);
+    padding: 0.25rem 0.375rem;
+    text-align: center;
+  }
+
+  /* Turns */
+  .turns-section {
+    padding: 0.375rem 0.625rem;
+    flex: 1;
+    min-height: 0;
+    display: flex;
+    flex-direction: column;
+  }
+
+  .turns-list {
+    display: flex;
+    flex-direction: column;
+    gap: 1px;
+    overflow-y: auto;
+    flex: 1;
+  }
+
+  .turn-group {
+    border-radius: 0.1875rem;
+    overflow: hidden;
+  }
+
+  .turn-header {
+    display: flex;
+    align-items: center;
+    gap: 0.375rem;
+    width: 100%;
+    padding: 0.25rem 0.375rem;
+    background: transparent;
+    border: none;
+    color: var(--ctp-text);
+    font-size: 0.65rem;
+    cursor: pointer;
+    text-align: left;
+    transition: background 0.1s;
+  }
+
+  .turn-header:hover {
+    background: var(--ctp-surface0);
+  }
+
+  .turn-chevron {
+    flex-shrink: 0;
+    color: var(--ctp-overlay0);
+    transition: transform 0.15s;
+    display: flex;
+  }
+
+  .turn-chevron.open {
+    transform: rotate(90deg);
+  }
+
+  .turn-index {
+    font-family: var(--term-font-family, monospace);
+    font-size: 0.6rem;
+    color: var(--ctp-overlay1);
+    flex-shrink: 0;
+    min-width: 1.5rem;
+  }
+
+  .turn-tools {
+    display: flex;
+    gap: 0.1875rem;
+    flex: 1;
+    overflow: hidden;
+    flex-wrap: wrap;
+  }
+
+  .turn-tool-badge {
+    font-size: 0.525rem;
+    padding: 0.0625rem 0.25rem;
+    border-radius: 0.125rem;
+    background: color-mix(in srgb, var(--ctp-peach) 12%, transparent);
+    color: var(--ctp-peach);
+    font-family: var(--term-font-family, monospace);
+    white-space: nowrap;
+  }
+
+  .turn-tool-more {
+    font-size: 0.525rem;
+    color: var(--ctp-overlay0);
+  }
+
+  .turn-tokens {
+    font-size: 0.575rem;
+    font-family: var(--term-font-family, monospace);
+    color: var(--ctp-overlay1);
+    flex-shrink: 0;
+    margin-left: auto;
+  }
+
+  .turn-detail {
+    padding: 0.1875rem 0.375rem 0.375rem 1.5rem;
+    background: color-mix(in srgb, var(--ctp-surface0) 40%, transparent);
+  }
+
+  .turn-msg {
+    display: flex;
+    align-items: center;
+    gap: 0.375rem;
+    padding: 0.125rem 0;
+    font-size: 0.6rem;
+  }
+
+  .turn-msg-type {
+    font-weight: 600;
+    font-size: 0.55rem;
+    text-transform: uppercase;
+    letter-spacing: 0.03em;
+    min-width: 4.5rem;
+  }
+
+  .turn-msg-tokens {
+    font-family: var(--term-font-family, monospace);
+    font-size: 0.55rem;
+    color: var(--ctp-overlay0);
+  }
+
+  .turn-msg-name {
+    font-family: var(--term-font-family, monospace);
+    font-size: 0.575rem;
+    color: var(--ctp-subtext0);
+  }
+
+  .turns-empty {
+    color: var(--ctp-overlay0);
+    font-size: 0.7rem;
+    text-align: center;
+    padding: 1rem;
+  }
+
+  /* Sub-tabs */
+  .sub-tabs {
+    display: flex;
+    gap: 0;
+    background: var(--ctp-mantle);
+    border-bottom: 1px solid var(--ctp-surface0);
+    flex-shrink: 0;
+  }
+
+  .sub-tab {
+    padding: 0.25rem 0.75rem;
+    border: none;
+    border-bottom: 2px solid transparent;
+    background: transparent;
+    color: var(--ctp-overlay1);
+    font-size: 0.65rem;
+    font-weight: 500;
+    letter-spacing: 0.04em;
+    text-transform: uppercase;
+    cursor: pointer;
+    transition: color 0.12s, background 0.12s, border-color 0.12s;
+  }
+
+  .sub-tab:hover {
+    color: var(--ctp-subtext1);
+    background: var(--ctp-surface0);
+  }
+
+  .sub-tab.active {
+    color: var(--ctp-text);
+    font-weight: 600;
+    border-bottom-color: var(--ctp-blue);
+    background: var(--ctp-base);
+  }
+
+  .sub-panel {
+    display: flex;
+    flex-direction: column;
+    flex: 1;
+    min-height: 0;
+    overflow-y: auto;
+  }
+
+  /* AST */
+  .ast-panel {
+    gap: 0.125rem;
+  }
+
+  .ast-scroll {
+    display: flex;
+    flex-direction: column;
+    gap: 0.25rem;
+    padding: 0.375rem;
+    overflow-y: auto;
+    flex: 1;
+  }
+
+  .ast-turn-block {
+    border: 1px solid var(--ctp-surface0);
+    border-radius: 0.375rem;
+    overflow: hidden;
+    background: var(--ctp-base);
+  }
+
+  .ast-turn-label {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    padding: 0.25rem 0.5rem;
+    background: var(--ctp-mantle);
+    border-bottom: 1px solid var(--ctp-surface0);
+  }
+
+  .ast-turn-name {
+    font-size: 0.65rem;
+    font-weight: 600;
+    color: var(--ctp-lavender);
+  }
+
+  .ast-turn-tokens {
+    font-size: 0.575rem;
+    font-family: var(--term-font-family, monospace);
+    color: var(--ctp-overlay1);
+  }
+
+  .ast-svg-wrap {
+    overflow-x: auto;
+    padding: 0.25rem;
+  }
+
+  .ast-svg-wrap svg {
+    display: block;
+  }
+
+  /* Graph */
+  .graph-panel {
+    padding: 0.375rem;
+  }
+
+  .graph-scroll {
+    overflow: auto;
+    flex: 1;
+  }
+
+  .graph-scroll svg {
+    display: block;
+  }
+
+  /* Session Anchors */
+  .anchors-section {
+    padding: 0.375rem 0.625rem;
+    border-bottom: 1px solid var(--ctp-surface0);
+    flex-shrink: 0;
+  }
+
+  .anchor-injectable-badge {
+    font-size: 0.525rem;
+    padding: 0.0625rem 0.3125rem;
+    border-radius: 0.625rem;
+    background: color-mix(in srgb, var(--ctp-green) 15%, transparent);
+    color: var(--ctp-green);
+    font-family: var(--term-font-family, monospace);
+    margin-left: auto;
+  }
+
+  .anchor-budget {
+    margin-bottom: 0.375rem;
+  }
+
+  .anchor-budget-header {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    margin-bottom: 0.25rem;
+  }
+
+  .anchor-budget-label {
+    font-size: 0.6rem;
+    color: var(--ctp-overlay1);
+  }
+
+  .anchor-budget-usage {
+    font-size: 0.575rem;
+    font-family: var(--term-font-family, monospace);
+    color: var(--ctp-overlay1);
+  }
+
+  .anchor-budget-bar {
+    height: 0.375rem;
+    border-radius: 0.1875rem;
+    background: var(--ctp-surface0);
+    overflow: hidden;
+  }
+
+  .anchor-budget-fill {
+    height: 100%;
+    border-radius: 0.1875rem;
+    background: var(--ctp-blue);
+    transition: width 0.3s ease;
+  }
+
+  .anchor-budget-fill.warn {
+    background: var(--ctp-yellow);
+  }
+
+  .anchor-budget-fill.full {
+    background: var(--ctp-red);
+  }
+
+  .anchor-list {
+    display: flex;
+    flex-direction: column;
+    gap: 1px;
+    max-height: 10rem;
+    overflow-y: auto;
+  }
+
+  .anchor-item {
+    display: flex;
+    align-items: center;
+    gap: 0.375rem;
+    padding: 0.1875rem 0.375rem;
+    border-radius: 0.1875rem;
+    transition: background 0.1s;
+  }
+
+  .anchor-item:hover {
+    background: var(--ctp-surface0);
+  }
+
+  .anchor-type-dot {
+    width: 0.375rem;
+    height: 0.375rem;
+    border-radius: 50%;
+    flex-shrink: 0;
+  }
+
+  .anchor-type-label {
+    font-size: 0.525rem;
+    font-weight: 600;
+    text-transform: uppercase;
+    letter-spacing: 0.03em;
+    flex-shrink: 0;
+    min-width: 3.25rem;
+  }
+
+  .anchor-content {
+    font-size: 0.6rem;
+    color: var(--ctp-subtext0);
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+    flex: 1;
+    min-width: 0;
+  }
+
+  .anchor-tokens {
+    font-size: 0.55rem;
+    font-family: var(--term-font-family, monospace);
+    color: var(--ctp-overlay0);
+    flex-shrink: 0;
+  }
+
+  .anchor-actions {
+    display: flex;
+    gap: 0.125rem;
+    flex-shrink: 0;
+    opacity: 0;
+    transition: opacity 0.15s;
+  }
+
+  .anchor-item:hover .anchor-actions {
+    opacity: 1;
+  }
+
+  .anchor-action-btn {
+    background: none;
+    border: none;
+    padding: 0.125rem;
+    cursor: pointer;
+    color: var(--ctp-overlay0);
+    border-radius: 0.125rem;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    transition: background 0.1s;
+  }
+
+  .anchor-action-btn:hover {
+    background: var(--ctp-surface1);
+  }
+
+  .anchor-remove-btn:hover {
+    color: var(--ctp-red);
+  }
+</style>
diff --git a/v2/src/lib/components/Workspace/CsvTable.svelte b/v2/src/lib/components/Workspace/CsvTable.svelte
new file mode 100644
index 0000000..5b0a12d
--- /dev/null
+++ b/v2/src/lib/components/Workspace/CsvTable.svelte
@@ -0,0 +1,253 @@
+<script lang="ts">
+  interface Props {
+    content: string;
+    filename: string;
+  }
+
+  let { content, filename }: Props = $props();
+
+  /** Parse CSV with basic RFC 4180 quoting support */
+  function parseCsv(text: string): string[][] {
+    const rows: string[][] = [];
+    let i = 0;
+    const len = text.length;
+
+    while (i < len) {
+      const row: string[] = [];
+      while (i < len) {
+        let field = '';
+        if (text[i] === '"') {
+          // Quoted field
+          i++; // skip opening quote
+          while (i < len) {
+            if (text[i] === '"') {
+              if (i + 1 < len && text[i + 1] === '"') {
+                field += '"';
+                i += 2;
+              } else {
+                i++; // skip closing quote
+                break;
+              }
+            } else {
+              field += text[i];
+              i++;
+            }
+          }
+        } else {
+          // Unquoted field
+          while (i < len && text[i] !== ',' && text[i] !== '\n' && text[i] !== '\r') {
+            field += text[i];
+            i++;
+          }
+        }
+        row.push(field);
+
+        if (i < len && text[i] === ',') {
+          i++; // skip comma, continue row
+        } else {
+          // End of row
+          if (i < len && text[i] === '\r') i++;
+          if (i < len && text[i] === '\n') i++;
+          break;
+        }
+      }
+      // Skip empty trailing rows
+      if (row.length > 0 && !(row.length === 1 && row[0] === '')) {
+        rows.push(row);
+      }
+    }
+    return rows;
+  }
+
+  /** Detect delimiter: comma vs semicolon vs tab */
+  function detectDelimiter(text: string): string {
+    const firstLine = text.split('\n')[0] ?? '';
+    const commas = (firstLine.match(/,/g) ?? []).length;
+    const semicolons = (firstLine.match(/;/g) ?? []).length;
+    const tabs = (firstLine.match(/\t/g) ?? []).length;
+    if (tabs > commas && tabs > semicolons) return '\t';
+    if (semicolons > commas) return ';';
+    return ',';
+  }
+
+  let parsed = $derived.by(() => {
+    // Normalize delimiter to comma before parsing
+    const delim = detectDelimiter(content);
+    const normalized = delim === ',' ? content : content.replaceAll(delim, ',');
+    return parseCsv(normalized);
+  });
+
+  let headers = $derived(parsed[0] ?? []);
+  let dataRows = $derived(parsed.slice(1));
+  let totalRows = $derived(dataRows.length);
+
+  // Column count from widest row
+  let colCount = $derived(Math.max(...parsed.map(r => r.length), 0));
+
+  // Sort state
+  let sortCol = $state<number | null>(null);
+  let sortAsc = $state(true);
+
+  let sortedRows = $derived.by(() => {
+    if (sortCol === null) return dataRows;
+    const col = sortCol;
+    const asc = sortAsc;
+    return [...dataRows].sort((a, b) => {
+      const va = a[col] ?? '';
+      const vb = b[col] ?? '';
+      // Try numeric comparison
+      const na = Number(va);
+      const nb = Number(vb);
+      if (!isNaN(na) && !isNaN(nb)) {
+        return asc ? na - nb : nb - na;
+      }
+      return asc ? va.localeCompare(vb) : vb.localeCompare(va);
+    });
+  });
+
+  function toggleSort(col: number) {
+    if (sortCol === col) {
+      sortAsc = !sortAsc;
+    } else {
+      sortCol = col;
+      sortAsc = true;
+    }
+  }
+
+  function sortIndicator(col: number): string {
+    if (sortCol !== col) return '';
+    return sortAsc ? ' ▲' : ' ▼';
+  }
+</script>
+
+<div class="csv-table-wrapper">
+  <div class="csv-toolbar">
+    <span class="csv-info">
+      {totalRows} row{totalRows !== 1 ? 's' : ''} × {colCount} col{colCount !== 1 ? 's' : ''}
+    </span>
+    <span class="csv-filename">{filename}</span>
+  </div>
+
+  <div class="csv-scroll">
+    <table class="csv-table">
+      <thead>
+        <tr>
+          <th class="row-num">#</th>
+          {#each headers as header, i}
+            <th onclick={() => toggleSort(i)} class="sortable">
+              {header}{sortIndicator(i)}
+            </th>
+          {/each}
+        </tr>
+      </thead>
+      <tbody>
+        {#each sortedRows as row, rowIdx (rowIdx)}
+          <tr>
+            <td class="row-num">{rowIdx + 1}</td>
+            {#each { length: colCount } as _, colIdx}
+              <td>{row[colIdx] ?? ''}</td>
+            {/each}
+          </tr>
+        {/each}
+      </tbody>
+    </table>
+  </div>
+</div>
+
+<style>
+  .csv-table-wrapper {
+    display: flex;
+    flex-direction: column;
+    height: 100%;
+    overflow: hidden;
+    background: var(--ctp-base);
+  }
+
+  .csv-toolbar {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    padding: 0.25rem 0.625rem;
+    background: var(--ctp-mantle);
+    border-bottom: 1px solid var(--ctp-surface0);
+    flex-shrink: 0;
+  }
+
+  .csv-info {
+    font-size: 0.7rem;
+    color: var(--ctp-overlay1);
+    font-variant-numeric: tabular-nums;
+  }
+
+  .csv-filename {
+    font-size: 0.65rem;
+    color: var(--ctp-overlay0);
+    font-family: var(--term-font-family, monospace);
+  }
+
+  .csv-scroll {
+    flex: 1;
+    overflow: auto;
+  }
+
+  .csv-table {
+    width: 100%;
+    border-collapse: collapse;
+    font-size: 0.725rem;
+    font-family: var(--term-font-family, monospace);
+    white-space: nowrap;
+  }
+
+  .csv-table thead {
+    position: sticky;
+    top: 0;
+    z-index: 1;
+  }
+
+  .csv-table th {
+    background: var(--ctp-mantle);
+    color: var(--ctp-subtext1);
+    font-weight: 600;
+    text-align: left;
+    padding: 0.3125rem 0.5rem;
+    border-bottom: 1px solid var(--ctp-surface1);
+    user-select: none;
+  }
+
+  .csv-table th.sortable {
+    cursor: pointer;
+    transition: background 0.12s;
+  }
+
+  .csv-table th.sortable:hover {
+    background: var(--ctp-surface0);
+    color: var(--ctp-text);
+  }
+
+  .csv-table td {
+    padding: 0.25rem 0.5rem;
+    border-bottom: 1px solid var(--ctp-surface0);
+    color: var(--ctp-text);
+    max-width: 20rem;
+    overflow: hidden;
+    text-overflow: ellipsis;
+  }
+
+  .csv-table tbody tr:hover td {
+    background: color-mix(in srgb, var(--ctp-surface0) 50%, transparent);
+  }
+
+  .row-num {
+    color: var(--ctp-overlay0);
+    font-size: 0.625rem;
+    text-align: right;
+    width: 2.5rem;
+    min-width: 2.5rem;
+    padding-right: 0.625rem;
+    border-right: 1px solid var(--ctp-surface0);
+  }
+
+  thead .row-num {
+    border-bottom: 1px solid var(--ctp-surface1);
+  }
+</style>
diff --git a/v2/src/lib/components/Workspace/DocsTab.svelte b/v2/src/lib/components/Workspace/DocsTab.svelte
new file mode 100644
index 0000000..299adf9
--- /dev/null
+++ b/v2/src/lib/components/Workspace/DocsTab.svelte
@@ -0,0 +1,160 @@
+<script lang="ts">
+  import { getActiveProjectId, getActiveGroup } from '../../stores/workspace.svelte';
+  import { discoverMarkdownFiles, type MdFileEntry } from '../../adapters/groups-bridge';
+  import MarkdownPane from '../Markdown/MarkdownPane.svelte';
+
+  let files = $state<MdFileEntry[]>([]);
+  let selectedPath = $state<string | null>(null);
+  let loading = $state(false);
+
+  let activeProjectId = $derived(getActiveProjectId());
+  let activeGroup = $derived(getActiveGroup());
+  let activeProject = $derived(
+    activeGroup?.projects.find(p => p.id === activeProjectId),
+  );
+
+  $effect(() => {
+    const project = activeProject;
+    if (project) {
+      loadFiles(project.cwd);
+    } else {
+      files = [];
+      selectedPath = null;
+    }
+  });
+
+  async function loadFiles(cwd: string) {
+    loading = true;
+    try {
+      files = await discoverMarkdownFiles(cwd);
+      // Auto-select first priority file
+      const priority = files.find(f => f.priority);
+      selectedPath = priority?.path ?? files[0]?.path ?? null;
+    } catch (e) {
+      console.warn('Failed to discover markdown files:', e);
+      files = [];
+    } finally {
+      loading = false;
+    }
+  }
+</script>
+
+<div class="docs-tab">
+  <aside class="file-picker">
+    <h3 class="picker-title">
+      {activeProject?.name ?? 'No project'} — Docs
+    </h3>
+    {#if loading}
+      <div class="loading">Scanning...</div>
+    {:else if files.length === 0}
+      <div class="empty">No markdown files found</div>
+    {:else}
+      <ul class="file-list">
+        {#each files as file}
+          <li>
+            <button
+              class="file-btn"
+              class:active={selectedPath === file.path}
+              class:priority={file.priority}
+              onclick={() => (selectedPath = file.path)}
+            >
+              {file.name}
+            </button>
+          </li>
+        {/each}
+      </ul>
+    {/if}
+  </aside>
+
+  <main class="doc-content">
+    {#if selectedPath}
+      <MarkdownPane paneId="docs-viewer" filePath={selectedPath} />
+    {:else}
+      <div class="no-selection">Select a document from the sidebar</div>
+    {/if}
+  </main>
+</div>
+
+<style>
+  .docs-tab {
+    display: flex;
+    height: 100%;
+    overflow: hidden;
+    min-width: 22em;
+  }
+
+  .file-picker {
+    width: 14em;
+    flex-shrink: 0;
+    background: var(--ctp-mantle);
+    border-right: 1px solid var(--ctp-surface0);
+    overflow-y: auto;
+    padding: 0.5rem 0;
+  }
+
+  .picker-title {
+    font-size: 0.75rem;
+    font-weight: 600;
+    color: var(--ctp-subtext0);
+    padding: 0.25rem 0.75rem 0.5rem;
+    margin: 0;
+    text-transform: uppercase;
+    letter-spacing: 0.04em;
+  }
+
+  .file-list {
+    list-style: none;
+    margin: 0;
+    padding: 0;
+  }
+
+  .file-btn {
+    display: block;
+    width: 100%;
+    padding: 0.3rem 0.75rem;
+    background: transparent;
+    border: none;
+    color: var(--ctp-subtext0);
+    font-size: 0.8rem;
+    text-align: left;
+    cursor: pointer;
+    transition: color 0.1s, background 0.1s;
+  }
+
+  .file-btn:hover {
+    background: var(--ctp-surface0);
+    color: var(--ctp-text);
+  }
+
+  .file-btn.active {
+    background: var(--ctp-surface0);
+    color: var(--ctp-text);
+    font-weight: 600;
+  }
+
+  .file-btn.priority {
+    color: var(--ctp-blue);
+  }
+
+  .file-btn.priority.active {
+    color: var(--ctp-blue);
+  }
+
+  .doc-content {
+    flex: 1;
+    overflow: auto;
+  }
+
+  .loading, .empty, .no-selection {
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    color: var(--ctp-overlay0);
+    font-size: 0.85rem;
+    padding: 1.25rem;
+  }
+
+  .no-selection {
+    height: 100%;
+  }
+</style>
diff --git a/v2/src/lib/components/Workspace/FilesTab.svelte b/v2/src/lib/components/Workspace/FilesTab.svelte
new file mode 100644
index 0000000..0cc4f37
--- /dev/null
+++ b/v2/src/lib/components/Workspace/FilesTab.svelte
@@ -0,0 +1,700 @@
+<script lang="ts">
+  import { listDirectoryChildren, readFileContent, writeFileContent, type DirEntry, type FileContent } from '../../adapters/files-bridge';
+  import { getSetting } from '../../adapters/settings-bridge';
+  import { convertFileSrc } from '@tauri-apps/api/core';
+  import CodeEditor from './CodeEditor.svelte';
+  import PdfViewer from './PdfViewer.svelte';
+  import CsvTable from './CsvTable.svelte';
+
+  interface Props {
+    cwd: string;
+  }
+
+  let { cwd }: Props = $props();
+
+  // Tree state: expanded dirs and their children
+  interface TreeNode extends DirEntry {
+    children?: TreeNode[];
+    loading?: boolean;
+    depth: number;
+  }
+
+  // Open file tab
+  interface FileTab {
+    path: string;
+    name: string;
+    pinned: boolean;
+    content: FileContent | null;
+    dirty: boolean;
+    editContent: string; // current editor content (may differ from saved)
+  }
+
+  let roots = $state<TreeNode[]>([]);
+  let expandedPaths = $state<Set<string>>(new Set());
+
+  // Tab state: open file tabs + active tab
+  let fileTabs = $state<FileTab[]>([]);
+  let activeTabPath = $state<string | null>(null);
+  let fileLoading = $state(false);
+
+  // Sidebar state
+  let sidebarCollapsed = $state(false);
+  let sidebarWidth = $state(14); // rem
+  let resizing = $state(false);
+
+  // Settings
+  let saveOnBlur = $state(false);
+
+  // Derived: active tab's content
+  let activeTab = $derived(fileTabs.find(t => t.path === activeTabPath) ?? null);
+
+  // Load root directory + settings
+  $effect(() => {
+    const dir = cwd;
+    loadDirectory(dir).then(entries => {
+      roots = entries.map(e => ({ ...e, depth: 0 }));
+    });
+    getSetting('files_save_on_blur').then(v => {
+      saveOnBlur = v === 'true';
+    });
+  });
+
+  async function loadDirectory(path: string): Promise<DirEntry[]> {
+    try {
+      return await listDirectoryChildren(path);
+    } catch (e) {
+      console.warn('Failed to list directory:', e);
+      return [];
+    }
+  }
+
+  async function toggleDir(node: TreeNode) {
+    const path = node.path;
+    if (expandedPaths.has(path)) {
+      const next = new Set(expandedPaths);
+      next.delete(path);
+      expandedPaths = next;
+    } else {
+      if (!node.children) {
+        node.loading = true;
+        const entries = await loadDirectory(path);
+        node.children = entries.map(e => ({ ...e, depth: node.depth + 1 }));
+        node.loading = false;
+      }
+      expandedPaths = new Set([...expandedPaths, path]);
+    }
+  }
+
+  /** Single click: preview file (replaces existing preview tab) */
+  async function previewFile(node: TreeNode) {
+    if (node.is_dir) {
+      toggleDir(node);
+      return;
+    }
+    // If already open as pinned tab, just focus it
+    const existing = fileTabs.find(t => t.path === node.path);
+    if (existing?.pinned) {
+      activeTabPath = node.path;
+      return;
+    }
+
+    // Replace any existing preview (unpinned) tab
+    const previewIdx = fileTabs.findIndex(t => !t.pinned);
+    const tab: FileTab = {
+      path: node.path,
+      name: node.name,
+      pinned: false,
+      content: null,
+      dirty: false,
+      editContent: '',
+    };
+
+    if (existing) {
+      // Already the preview tab, just refocus
+      activeTabPath = node.path;
+      return;
+    }
+
+    if (previewIdx >= 0) {
+      fileTabs[previewIdx] = tab;
+    } else {
+      fileTabs = [...fileTabs, tab];
+    }
+    activeTabPath = node.path;
+
+    // Load content — must look up from reactive array, not local reference
+    fileLoading = true;
+    try {
+      const content = await readFileContent(node.path);
+      const target = fileTabs.find(t => t.path === node.path);
+      if (target) {
+        target.content = content;
+        target.editContent = content.type === 'Text' ? content.content : '';
+      }
+    } catch (e) {
+      const target = fileTabs.find(t => t.path === node.path);
+      if (target) target.content = { type: 'Binary', message: `Error: ${e}` };
+    } finally {
+      fileLoading = false;
+    }
+  }
+
+  /** Double click: pin the file as a permanent tab */
+  function pinFile(node: TreeNode) {
+    if (node.is_dir) return;
+    const existing = fileTabs.find(t => t.path === node.path);
+    if (existing) {
+      existing.pinned = true;
+      activeTabPath = node.path;
+    } else {
+      // Open and pin directly
+      previewFile(node).then(() => {
+        const tab = fileTabs.find(t => t.path === node.path);
+        if (tab) tab.pinned = true;
+      });
+    }
+  }
+
+  function closeTab(path: string) {
+    const tab = fileTabs.find(t => t.path === path);
+    if (tab?.dirty) {
+      // Save before closing if dirty
+      saveTab(tab);
+    }
+    fileTabs = fileTabs.filter(t => t.path !== path);
+    if (activeTabPath === path) {
+      activeTabPath = fileTabs[fileTabs.length - 1]?.path ?? null;
+    }
+  }
+
+  function flattenTree(nodes: TreeNode[]): TreeNode[] {
+    const result: TreeNode[] = [];
+    for (const node of nodes) {
+      result.push(node);
+      if (node.is_dir && expandedPaths.has(node.path) && node.children) {
+        result.push(...flattenTree(node.children));
+      }
+    }
+    return result;
+  }
+
+  let flatNodes = $derived(flattenTree(roots));
+
+  function fileIcon(node: TreeNode): string {
+    if (node.is_dir) return expandedPaths.has(node.path) ? '📂' : '📁';
+    const ext = node.ext;
+    if (['ts', 'tsx'].includes(ext)) return '🟦';
+    if (['js', 'jsx', 'mjs'].includes(ext)) return '🟨';
+    if (ext === 'rs') return '🦀';
+    if (ext === 'py') return '🐍';
+    if (ext === 'svelte') return '🟧';
+    if (['md', 'markdown'].includes(ext)) return '📝';
+    if (['json', 'toml', 'yaml', 'yml'].includes(ext)) return '⚙️';
+    if (['png', 'jpg', 'jpeg', 'gif', 'webp', 'svg', 'ico'].includes(ext)) return '🖼️';
+    if (ext === 'pdf') return '📕';
+    if (ext === 'csv') return '📊';
+    if (['css', 'scss', 'less'].includes(ext)) return '🎨';
+    if (['html', 'htm'].includes(ext)) return '🌐';
+    return '📄';
+  }
+
+  function formatSize(bytes: number): string {
+    if (bytes < 1024) return `${bytes} B`;
+    if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+    return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+  }
+
+  function isImageExt(path: string): boolean {
+    const ext = path.split('.').pop()?.toLowerCase() ?? '';
+    return ['png', 'jpg', 'jpeg', 'gif', 'webp', 'svg', 'ico', 'bmp'].includes(ext);
+  }
+
+  function isPdfExt(path: string): boolean {
+    return path.split('.').pop()?.toLowerCase() === 'pdf';
+  }
+
+  function isCsvLang(lang: string): boolean {
+    return lang === 'csv';
+  }
+
+  // Editor change handler
+  function handleEditorChange(tabPath: string, newContent: string) {
+    const tab = fileTabs.find(t => t.path === tabPath);
+    if (!tab || tab.content?.type !== 'Text') return;
+    tab.editContent = newContent;
+    tab.dirty = newContent !== tab.content.content;
+  }
+
+  // Save a tab to disk
+  async function saveTab(tab: FileTab) {
+    if (!tab.dirty || tab.content?.type !== 'Text') return;
+    try {
+      await writeFileContent(tab.path, tab.editContent);
+      // Update the saved content reference
+      tab.content = { type: 'Text', content: tab.editContent, lang: tab.content.lang };
+      tab.dirty = false;
+    } catch (e) {
+      console.warn('Failed to save file:', e);
+    }
+  }
+
+  // Save active tab
+  function saveActiveTab() {
+    if (activeTab?.dirty) saveTab(activeTab);
+  }
+
+  // Blur handler: save if setting enabled
+  function handleEditorBlur(tabPath: string) {
+    if (!saveOnBlur) return;
+    const tab = fileTabs.find(t => t.path === tabPath);
+    if (tab?.dirty) saveTab(tab);
+  }
+
+  // Drag-resize sidebar
+  function startResize(e: MouseEvent) {
+    e.preventDefault();
+    resizing = true;
+    const startX = e.clientX;
+    const startWidth = sidebarWidth;
+
+    function onMove(ev: MouseEvent) {
+      const delta = ev.clientX - startX;
+      const newWidth = startWidth + delta / 16; // convert px to rem (approx)
+      sidebarWidth = Math.max(8, Math.min(30, newWidth));
+    }
+
+    function onUp() {
+      resizing = false;
+      window.removeEventListener('mousemove', onMove);
+      window.removeEventListener('mouseup', onUp);
+    }
+
+    window.addEventListener('mousemove', onMove);
+    window.addEventListener('mouseup', onUp);
+  }
+</script>
+
+<div class="files-tab">
+  {#if !sidebarCollapsed}
+    <aside class="tree-sidebar" style="width: {sidebarWidth}rem">
+      <div class="tree-header">
+        <span class="tree-title">Explorer</span>
+        <button class="collapse-btn" onclick={() => sidebarCollapsed = true} title="Collapse sidebar">
+          <svg width="12" height="12" viewBox="0 0 12 12" fill="none">
+            <path d="M8 2L4 6l4 4" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/>
+          </svg>
+        </button>
+      </div>
+      <div class="tree-list">
+        {#each flatNodes as node (node.path)}
+          <button
+            class="tree-row"
+            class:selected={activeTabPath === node.path}
+            class:dir={node.is_dir}
+            style="padding-left: {0.5 + node.depth * 1}rem"
+            onclick={() => previewFile(node)}
+            ondblclick={() => pinFile(node)}
+          >
+            <span class="tree-icon">{fileIcon(node)}</span>
+            <span class="tree-name">{node.name}</span>
+            {#if !node.is_dir}
+              <span class="tree-size">{formatSize(node.size)}</span>
+            {/if}
+            {#if node.loading}
+              <span class="tree-loading">…</span>
+            {/if}
+          </button>
+        {/each}
+        {#if flatNodes.length === 0}
+          <div class="tree-empty">No files</div>
+        {/if}
+      </div>
+    </aside>
+    <!-- svelte-ignore a11y_no_static_element_interactions -->
+    <div class="resize-handle" class:active={resizing} onmousedown={startResize}></div>
+  {:else}
+    <button class="expand-btn" onclick={() => sidebarCollapsed = false} title="Show explorer">
+      <svg width="12" height="12" viewBox="0 0 12 12" fill="none">
+        <path d="M4 2l4 4-4 4" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/>
+      </svg>
+    </button>
+  {/if}
+
+  <main class="file-viewer">
+    <!-- File tabs bar -->
+    {#if fileTabs.length > 0}
+      <div class="file-tab-bar">
+        {#each fileTabs as tab (tab.path)}
+          <div
+            class="file-tab"
+            class:active={activeTabPath === tab.path}
+            class:preview={!tab.pinned}
+            onclick={() => activeTabPath = tab.path}
+            ondblclick={() => { tab.pinned = true; }}
+            onkeydown={(e) => { if (e.key === 'Enter' || e.key === ' ') { e.preventDefault(); activeTabPath = tab.path; } }}
+            role="tab"
+            tabindex="0"
+          >
+            <span class="file-tab-name" class:italic={!tab.pinned}>
+              {tab.name}{#if tab.dirty}<span class="dirty-dot"></span>{/if}
+            </span>
+            <button class="file-tab-close" onclick={(e) => { e.stopPropagation(); closeTab(tab.path); }}>×</button>
+          </div>
+        {/each}
+      </div>
+    {/if}
+
+    <!-- Content area -->
+    {#if fileLoading && activeTabPath && !activeTab?.content}
+      <div class="viewer-state">Loading…</div>
+    {:else if !activeTab}
+      <div class="viewer-state">Select a file to view</div>
+    {:else if activeTab.content?.type === 'TooLarge'}
+      <div class="viewer-state">
+        <span class="viewer-warning">File too large</span>
+        <span class="viewer-detail">{formatSize(activeTab.content.size)}</span>
+      </div>
+    {:else if activeTab.content?.type === 'Binary'}
+      {#if isPdfExt(activeTab.path)}
+        {#key activeTabPath}
+          <PdfViewer filePath={activeTab.path} />
+        {/key}
+      {:else if isImageExt(activeTab.path)}
+        <div class="viewer-image">
+          <img src={convertFileSrc(activeTab.path)} alt={activeTab.name} />
+        </div>
+      {:else}
+        <div class="viewer-state">{activeTab.content.message}</div>
+      {/if}
+    {:else if activeTab.content?.type === 'Text'}
+      {#if isCsvLang(activeTab.content.lang)}
+        {#key activeTabPath}
+          <CsvTable content={activeTab.editContent} filename={activeTab.name} />
+        {/key}
+      {:else}
+        {#key activeTabPath}
+          <CodeEditor
+            content={activeTab.editContent}
+            lang={activeTab.content.lang}
+            onchange={(c) => handleEditorChange(activeTab!.path, c)}
+            onsave={saveActiveTab}
+            onblur={() => handleEditorBlur(activeTab!.path)}
+          />
+        {/key}
+      {/if}
+    {/if}
+
+    {#if activeTab}
+      <div class="viewer-path">
+        {activeTab.path}
+        {#if activeTab.dirty}
+          <span class="path-dirty">(unsaved)</span>
+        {/if}
+      </div>
+    {/if}
+  </main>
+</div>
+
+<style>
+  .files-tab {
+    display: flex;
+    height: 100%;
+    overflow: hidden;
+    flex: 1;
+  }
+
+  /* --- Sidebar --- */
+
+  .tree-sidebar {
+    flex-shrink: 0;
+    background: var(--ctp-mantle);
+    border-right: 1px solid var(--ctp-surface0);
+    display: flex;
+    flex-direction: column;
+    overflow: hidden;
+    min-width: 8rem;
+    max-width: 30rem;
+  }
+
+  .tree-header {
+    padding: 0.375rem 0.625rem;
+    border-bottom: 1px solid var(--ctp-surface0);
+    flex-shrink: 0;
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+  }
+
+  .tree-title {
+    font-size: 0.675rem;
+    font-weight: 600;
+    text-transform: uppercase;
+    letter-spacing: 0.05em;
+    color: var(--ctp-overlay1);
+  }
+
+  .collapse-btn, .expand-btn {
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    background: transparent;
+    border: none;
+    color: var(--ctp-overlay1);
+    cursor: pointer;
+    padding: 0.125rem;
+    border-radius: 0.1875rem;
+    transition: color 0.12s, background 0.12s;
+  }
+
+  .collapse-btn:hover, .expand-btn:hover {
+    color: var(--ctp-text);
+    background: var(--ctp-surface0);
+  }
+
+  .expand-btn {
+    flex-shrink: 0;
+    width: 1.5rem;
+    height: 100%;
+    background: var(--ctp-mantle);
+    border-right: 1px solid var(--ctp-surface0);
+    border-radius: 0;
+    padding: 0;
+  }
+
+  .resize-handle {
+    width: 4px;
+    cursor: col-resize;
+    background: transparent;
+    flex-shrink: 0;
+    transition: background 0.15s;
+    margin-left: -2px;
+    margin-right: -2px;
+    z-index: 1;
+  }
+
+  .resize-handle:hover, .resize-handle.active {
+    background: var(--ctp-blue);
+  }
+
+  .tree-list {
+    flex: 1;
+    overflow-y: auto;
+    overflow-x: hidden;
+  }
+
+  .tree-row {
+    display: flex;
+    align-items: center;
+    gap: 0.25rem;
+    width: 100%;
+    height: 1.5rem;
+    border: none;
+    background: transparent;
+    color: var(--ctp-subtext0);
+    font-size: 0.7rem;
+    text-align: left;
+    cursor: pointer;
+    white-space: nowrap;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    transition: background 0.1s;
+    padding-right: 0.375rem;
+  }
+
+  .tree-row:hover {
+    background: var(--ctp-surface0);
+    color: var(--ctp-text);
+  }
+
+  .tree-row.selected {
+    background: color-mix(in srgb, var(--accent, var(--ctp-blue)) 15%, transparent);
+    color: var(--ctp-text);
+  }
+
+  .tree-row.dir {
+    font-weight: 500;
+  }
+
+  .tree-icon {
+    font-size: 0.65rem;
+    flex-shrink: 0;
+    width: 1rem;
+    text-align: center;
+  }
+
+  .tree-name {
+    overflow: hidden;
+    text-overflow: ellipsis;
+    flex: 1;
+    min-width: 0;
+  }
+
+  .tree-size {
+    font-size: 0.575rem;
+    color: var(--ctp-overlay0);
+    flex-shrink: 0;
+    margin-left: auto;
+  }
+
+  .tree-loading {
+    color: var(--ctp-overlay0);
+    font-size: 0.6rem;
+  }
+
+  .tree-empty {
+    color: var(--ctp-overlay0);
+    font-size: 0.7rem;
+    padding: 1rem;
+    text-align: center;
+  }
+
+  /* --- File tab bar --- */
+
+  .file-tab-bar {
+    display: flex;
+    background: var(--ctp-mantle);
+    border-bottom: 1px solid var(--ctp-surface0);
+    flex-shrink: 0;
+    overflow-x: auto;
+    scrollbar-width: none;
+  }
+
+  .file-tab {
+    display: inline-flex;
+    align-items: center;
+    gap: 0.25rem;
+    padding: 0.25rem 0.375rem 0.25rem 0.625rem;
+    border: none;
+    border-bottom: 2px solid transparent;
+    background: transparent;
+    color: var(--ctp-overlay1);
+    font-size: 0.675rem;
+    cursor: pointer;
+    white-space: nowrap;
+    transition: color 0.1s, background 0.1s;
+    max-width: 10rem;
+  }
+
+  .file-tab:hover {
+    background: var(--ctp-surface0);
+    color: var(--ctp-subtext1);
+  }
+
+  .file-tab.active {
+    background: var(--ctp-base);
+    color: var(--ctp-text);
+    border-bottom-color: var(--accent, var(--ctp-blue));
+  }
+
+  .file-tab-name {
+    overflow: hidden;
+    text-overflow: ellipsis;
+    display: inline-flex;
+    align-items: center;
+    gap: 0.25rem;
+  }
+
+  .file-tab-name.italic {
+    font-style: italic;
+  }
+
+  .dirty-dot {
+    display: inline-block;
+    width: 0.375rem;
+    height: 0.375rem;
+    border-radius: 50%;
+    background: var(--ctp-peach);
+    flex-shrink: 0;
+  }
+
+  .file-tab-close {
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    width: 1rem;
+    height: 1rem;
+    border: none;
+    background: transparent;
+    color: var(--ctp-overlay0);
+    font-size: 0.75rem;
+    cursor: pointer;
+    border-radius: 0.125rem;
+    flex-shrink: 0;
+    opacity: 0;
+    transition: opacity 0.1s, background 0.1s;
+  }
+
+  .file-tab:hover .file-tab-close,
+  .file-tab.active .file-tab-close {
+    opacity: 1;
+  }
+
+  .file-tab-close:hover {
+    background: var(--ctp-surface1);
+    color: var(--ctp-text);
+  }
+
+  /* --- Viewer --- */
+
+  .file-viewer {
+    flex: 1;
+    min-width: 0;
+    display: flex;
+    flex-direction: column;
+    overflow: hidden;
+    background: var(--ctp-base);
+  }
+
+  .viewer-state {
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    justify-content: center;
+    height: 100%;
+    gap: 0.5rem;
+    color: var(--ctp-overlay0);
+    font-size: 0.8rem;
+  }
+
+  .viewer-warning {
+    color: var(--ctp-yellow);
+    font-weight: 600;
+  }
+
+  .viewer-detail {
+    font-size: 0.7rem;
+  }
+
+  .viewer-image {
+    flex: 1;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    padding: 1rem;
+    overflow: auto;
+  }
+
+  .viewer-image img {
+    max-width: 100%;
+    max-height: 100%;
+    object-fit: contain;
+    border-radius: 0.25rem;
+  }
+
+  .viewer-path {
+    border-top: 1px solid var(--ctp-surface0);
+    padding: 0.25rem 0.75rem;
+    font-size: 0.65rem;
+    font-family: var(--term-font-family, monospace);
+    color: var(--ctp-overlay0);
+    flex-shrink: 0;
+    display: flex;
+    align-items: center;
+    gap: 0.5rem;
+  }
+
+  .path-dirty {
+    color: var(--ctp-peach);
+    font-size: 0.6rem;
+  }
+</style>
diff --git a/v2/src/lib/components/Workspace/GlobalTabBar.svelte b/v2/src/lib/components/Workspace/GlobalTabBar.svelte
new file mode 100644
index 0000000..fb7864b
--- /dev/null
+++ b/v2/src/lib/components/Workspace/GlobalTabBar.svelte
@@ -0,0 +1,103 @@
+<script lang="ts">
+  import { getActiveTab, setActiveTab, type WorkspaceTab } from '../../stores/workspace.svelte';
+
+  interface Props {
+    expanded?: boolean;
+    ontoggle?: () => void;
+  }
+
+  let { expanded = false, ontoggle }: Props = $props();
+
+  const settingsIcon = 'M10.3 2L9.9 4.4a7 7 0 0 0-1.8 1l-2.2-.9-1.7 3 1.8 1.5a7 7 0 0 0 0 2l-1.8 1.5 1.7 3 2.2-.9a7 7 0 0 0 1.8 1L10.3 18h3.4l.4-2.4a7 7 0 0 0 1.8-1l2.2.9 1.7-3-1.8-1.5a7 7 0 0 0 0-2l1.8-1.5-1.7-3-2.2.9a7 7 0 0 0-1.8-1L13.7 2h-3.4zM12 8a4 4 0 1 1 0 8 4 4 0 0 1 0-8z';
+
+  function handleTabClick(tab: WorkspaceTab) {
+    if (getActiveTab() === tab && expanded) {
+      ontoggle?.();
+    } else {
+      setActiveTab(tab);
+      if (!expanded) ontoggle?.();
+    }
+  }
+</script>
+
+<nav class="sidebar-rail" data-testid="sidebar-rail">
+  <button
+    class="rail-btn"
+    class:active={getActiveTab() === 'comms' && expanded}
+    onclick={() => handleTabClick('comms')}
+    title="Messages (Ctrl+M)"
+  >
+    <svg width="20" height="20" viewBox="0 0 24 24" fill="none">
+      <path
+        d="M21 11.5a8.38 8.38 0 0 1-.9 3.8 8.5 8.5 0 0 1-7.6 4.7 8.38 8.38 0 0 1-3.8-.9L3 21l1.9-5.7a8.38 8.38 0 0 1-.9-3.8 8.5 8.5 0 0 1 4.7-7.6 8.38 8.38 0 0 1 3.8-.9h.5a8.48 8.48 0 0 1 8 8v.5z"
+        stroke="currentColor"
+        stroke-width="1.5"
+        stroke-linecap="round"
+        stroke-linejoin="round"
+        fill="none"
+      />
+    </svg>
+  </button>
+
+  <div class="rail-spacer"></div>
+
+  <button
+    class="rail-btn"
+    class:active={getActiveTab() === 'settings' && expanded}
+    onclick={() => handleTabClick('settings')}
+    title="Settings (Ctrl+,)"
+    data-testid="settings-btn"
+  >
+    <svg width="20" height="20" viewBox="0 0 24 24" fill="none">
+      <path
+        d={settingsIcon}
+        stroke="currentColor"
+        stroke-width="1.5"
+        stroke-linecap="round"
+        stroke-linejoin="round"
+        fill="none"
+      />
+    </svg>
+  </button>
+</nav>
+
+<style>
+  .sidebar-rail {
+    display: flex;
+    flex-direction: column;
+    gap: 0.25rem;
+    padding: 0.5rem 0.375rem;
+    background: var(--ctp-mantle);
+    border-right: 1px solid var(--ctp-surface0);
+    flex-shrink: 0;
+    width: 2.75rem;
+  }
+
+  .rail-btn {
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    width: 2rem;
+    height: 2rem;
+    background: transparent;
+    border: none;
+    border-radius: 0.375rem;
+    color: var(--ctp-subtext0);
+    cursor: pointer;
+    transition: color 0.15s, background 0.15s;
+  }
+
+  .rail-btn:hover {
+    color: var(--ctp-text);
+    background: var(--ctp-surface0);
+  }
+
+  .rail-btn.active {
+    color: var(--ctp-blue);
+    background: var(--ctp-surface0);
+  }
+
+  .rail-spacer {
+    flex: 1;
+  }
+</style>
diff --git a/v2/src/lib/components/Workspace/GroupAgentsPanel.svelte b/v2/src/lib/components/Workspace/GroupAgentsPanel.svelte
new file mode 100644
index 0000000..b75a8f0
--- /dev/null
+++ b/v2/src/lib/components/Workspace/GroupAgentsPanel.svelte
@@ -0,0 +1,428 @@
+<script lang="ts">
+  import { onMount, onDestroy } from 'svelte';
+  import { getActiveGroup, getEnabledProjects, setActiveProject } from '../../stores/workspace.svelte';
+  import type { GroupAgentConfig, GroupAgentStatus, ProjectConfig } from '../../types/groups';
+  import { getGroupAgents, setAgentStatus, type BtmsgAgent } from '../../adapters/btmsg-bridge';
+  import type { AgentId } from '../../types/ids';
+
+  /** Runtime agent status from btmsg database */
+  let btmsgAgents = $state<BtmsgAgent[]>([]);
+  let pollTimer: ReturnType<typeof setInterval> | null = null;
+
+  let group = $derived(getActiveGroup());
+  let agents = $derived(group?.agents ?? []);
+  let projects = $derived(getEnabledProjects());
+  let hasAgents = $derived(agents.length > 0 || projects.length > 0);
+  let collapsed = $state(false);
+
+  const ROLE_ICONS: Record<string, string> = {
+    manager: '🎯',
+    architect: '🏗',
+    tester: '🧪',
+    reviewer: '🔍',
+  };
+
+  const ROLE_LABELS: Record<string, string> = {
+    manager: 'Manager',
+    architect: 'Architect',
+    tester: 'Tester',
+    reviewer: 'Reviewer',
+  };
+
+  async function pollBtmsg() {
+    if (!group) return;
+    try {
+      btmsgAgents = await getGroupAgents(group.id);
+    } catch {
+      // btmsg.db might not exist yet
+    }
+  }
+
+  onMount(() => {
+    pollBtmsg();
+    pollTimer = setInterval(pollBtmsg, 5000); // Poll every 5 seconds
+  });
+
+  onDestroy(() => {
+    if (pollTimer) clearInterval(pollTimer);
+  });
+
+  function getStatus(agentId: AgentId): GroupAgentStatus {
+    const btAgent = btmsgAgents.find(a => a.id === agentId);
+    return (btAgent?.status as GroupAgentStatus) ?? 'stopped';
+  }
+
+  function getUnread(agentId: AgentId): number {
+    const btAgent = btmsgAgents.find(a => a.id === agentId);
+    return btAgent?.unreadCount ?? 0;
+  }
+
+  async function toggleAgent(agent: GroupAgentConfig) {
+    const current = getStatus(agent.id);
+    const newStatus = current === 'stopped' ? 'active' : 'stopped';
+    try {
+      await setAgentStatus(agent.id, newStatus);
+      await pollBtmsg(); // Refresh immediately
+    } catch (e) {
+      console.warn('Failed to set agent status:', e);
+    }
+  }
+</script>
+
+{#if hasAgents}
+  <div class="group-agents-panel" class:collapsed>
+    <button
+      class="panel-header"
+      onclick={() => collapsed = !collapsed}
+    >
+      <span class="header-left">
+        <span class="header-icon">{collapsed ? '▸' : '▾'}</span>
+        <span class="header-title">Agents</span>
+        <span class="agent-count">{agents.length + projects.length}</span>
+      </span>
+      <span class="header-right">
+        {#each agents as agent (agent.id)}
+          {@const status = getStatus(agent.id)}
+          <span
+            class="status-dot"
+            class:active={status === 'active'}
+            class:sleeping={status === 'sleeping'}
+            class:stopped={status === 'stopped'}
+            title="{ROLE_LABELS[agent.role] ?? agent.role}: {status}"
+          ></span>
+        {/each}
+        {#if agents.length > 0 && projects.length > 0}
+          <span class="tier-separator-dot"></span>
+        {/if}
+        {#each projects as project (project.id)}
+          {@const status = getStatus(project.id)}
+          <span
+            class="status-dot"
+            class:active={status === 'active'}
+            class:sleeping={status === 'sleeping'}
+            class:stopped={status === 'stopped'}
+            title="{project.name}: {status}"
+          ></span>
+        {/each}
+      </span>
+    </button>
+
+    {#if !collapsed}
+      {#if agents.length > 0}
+        <div class="tier-label">
+          <span class="tier-text">Tier 1 — Management</span>
+        </div>
+        <div class="agents-grid">
+          {#each agents as agent (agent.id)}
+            {@const status = getStatus(agent.id)}
+            <div
+              class="agent-card"
+              class:active={status === 'active'}
+              class:sleeping={status === 'sleeping'}
+              onclick={() => setActiveProject(agent.id)}
+              role="button"
+              tabindex="0"
+            >
+              <div class="card-top">
+                <span class="agent-icon">{ROLE_ICONS[agent.role] ?? '🤖'}</span>
+                <span class="agent-name">{agent.name}</span>
+                <span
+                  class="card-status-dot"
+                  class:active={status === 'active'}
+                  class:sleeping={status === 'sleeping'}
+                  class:stopped={status === 'stopped'}
+                ></span>
+              </div>
+              <div class="card-meta">
+                <span class="agent-role">{ROLE_LABELS[agent.role] ?? agent.role}</span>
+                {#if agent.model}
+                  <span class="agent-model">{agent.model}</span>
+                {/if}
+                {#if getUnread(agent.id) > 0}
+                  <span class="unread-badge">{getUnread(agent.id)}</span>
+                {/if}
+              </div>
+              <div class="card-actions">
+                <button
+                  class="action-btn"
+                  class:start={status === 'stopped'}
+                  class:stop={status !== 'stopped'}
+                  onclick={(e: MouseEvent) => { e.stopPropagation(); toggleAgent(agent); }}
+                  title={status === 'stopped' ? 'Start agent' : 'Stop agent'}
+                >
+                  {status === 'stopped' ? '▶' : '■'}
+                </button>
+              </div>
+            </div>
+          {/each}
+        </div>
+      {/if}
+
+      {#if projects.length > 0}
+        <div class="tier-divider"></div>
+        <div class="tier-label">
+          <span class="tier-text">Tier 2 — Execution</span>
+        </div>
+        <div class="agents-grid">
+          {#each projects as project (project.id)}
+            {@const status = getStatus(project.id)}
+            <div
+              class="agent-card tier2"
+              class:active={status === 'active'}
+              class:sleeping={status === 'sleeping'}
+              onclick={() => setActiveProject(project.id)}
+              role="button"
+              tabindex="0"
+            >
+              <div class="card-top">
+                <span class="agent-icon">{project.icon}</span>
+                <span class="agent-name">{project.name}</span>
+                <span
+                  class="card-status-dot"
+                  class:active={status === 'active'}
+                  class:sleeping={status === 'sleeping'}
+                  class:stopped={status === 'stopped'}
+                ></span>
+              </div>
+              <div class="card-meta">
+                <span class="agent-role">Project</span>
+                {#if getUnread(project.id) > 0}
+                  <span class="unread-badge">{getUnread(project.id)}</span>
+                {/if}
+              </div>
+            </div>
+          {/each}
+        </div>
+      {/if}
+    {/if}
+  </div>
+{/if}
+
+<style>
+  .group-agents-panel {
+    flex-shrink: 0;
+    background: var(--ctp-mantle);
+    border-bottom: 1px solid var(--ctp-surface0);
+  }
+
+  .panel-header {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    width: 100%;
+    padding: 0.25rem 0.5rem;
+    background: transparent;
+    border: none;
+    color: var(--ctp-subtext0);
+    font-size: 0.7rem;
+    cursor: pointer;
+    transition: color 0.1s;
+  }
+
+  .panel-header:hover {
+    color: var(--ctp-text);
+  }
+
+  .header-left {
+    display: flex;
+    align-items: center;
+    gap: 0.3rem;
+  }
+
+  .header-icon {
+    font-size: 0.6rem;
+    width: 0.6rem;
+  }
+
+  .header-title {
+    font-weight: 600;
+    text-transform: uppercase;
+    letter-spacing: 0.05em;
+    font-size: 0.6rem;
+  }
+
+  .agent-count {
+    background: var(--ctp-surface0);
+    color: var(--ctp-subtext0);
+    border-radius: 0.5rem;
+    padding: 0 0.3rem;
+    font-size: 0.55rem;
+    font-weight: 600;
+  }
+
+  .header-right {
+    display: flex;
+    gap: 0.25rem;
+  }
+
+  .status-dot, .card-status-dot {
+    width: 6px;
+    height: 6px;
+    border-radius: 50%;
+    background: var(--ctp-overlay0);
+  }
+
+  .status-dot.active, .card-status-dot.active {
+    background: var(--ctp-green);
+    box-shadow: 0 0 4px var(--ctp-green);
+    animation: pulse 2s ease-in-out infinite;
+  }
+
+  .status-dot.sleeping, .card-status-dot.sleeping {
+    background: var(--ctp-yellow);
+    animation: pulse 3s ease-in-out infinite;
+  }
+
+  .status-dot.stopped, .card-status-dot.stopped {
+    background: var(--ctp-overlay0);
+  }
+
+  @keyframes pulse {
+    0%, 100% { opacity: 1; }
+    50% { opacity: 0.4; }
+  }
+
+  .tier-label {
+    padding: 0.1rem 0.5rem;
+  }
+
+  .tier-text {
+    font-size: 0.5rem;
+    font-weight: 600;
+    text-transform: uppercase;
+    letter-spacing: 0.06em;
+    color: var(--ctp-overlay0);
+  }
+
+  .tier-divider {
+    height: 1px;
+    margin: 0.15rem 0.5rem;
+    background: var(--ctp-surface0);
+  }
+
+  .tier-separator-dot {
+    width: 1px;
+    height: 6px;
+    background: var(--ctp-surface1);
+    margin: 0 0.1rem;
+  }
+
+  .agents-grid {
+    display: flex;
+    gap: 0.25rem;
+    padding: 0.1rem 0.5rem 0.25rem;
+    overflow-x: auto;
+  }
+
+  .agent-card {
+    flex: 0 0 auto;
+    min-width: 7rem;
+    padding: 0.3rem 0.4rem;
+    background: var(--ctp-base);
+    border: 1px solid var(--ctp-surface0);
+    border-radius: 0.25rem;
+    transition: border-color 0.15s, background 0.15s;
+    cursor: pointer;
+  }
+
+  .agent-card:hover {
+    border-color: var(--ctp-surface1);
+  }
+
+  .agent-card.active {
+    border-color: var(--ctp-green);
+    background: color-mix(in srgb, var(--ctp-green) 5%, var(--ctp-base));
+  }
+
+  .agent-card.sleeping {
+    border-color: var(--ctp-yellow);
+    background: color-mix(in srgb, var(--ctp-yellow) 5%, var(--ctp-base));
+  }
+
+  .card-top {
+    display: flex;
+    align-items: center;
+    gap: 0.25rem;
+  }
+
+  .agent-icon {
+    font-size: 0.75rem;
+  }
+
+  .agent-name {
+    font-size: 0.7rem;
+    font-weight: 600;
+    color: var(--ctp-text);
+    flex: 1;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+  }
+
+  .card-meta {
+    display: flex;
+    gap: 0.3rem;
+    margin-top: 0.15rem;
+  }
+
+  .agent-role {
+    font-size: 0.55rem;
+    color: var(--ctp-subtext0);
+    text-transform: uppercase;
+    letter-spacing: 0.03em;
+  }
+
+  .agent-model {
+    font-size: 0.55rem;
+    color: var(--ctp-overlay0);
+    font-family: monospace;
+  }
+
+  .card-actions {
+    margin-top: 0.2rem;
+    display: flex;
+    justify-content: flex-end;
+  }
+
+  .action-btn {
+    background: transparent;
+    border: 1px solid var(--ctp-surface1);
+    color: var(--ctp-subtext0);
+    font-size: 0.6rem;
+    padding: 0.1rem 0.3rem;
+    border-radius: 0.15rem;
+    cursor: pointer;
+    transition: all 0.1s;
+  }
+
+  .action-btn.start:hover {
+    background: var(--ctp-green);
+    color: var(--ctp-base);
+    border-color: var(--ctp-green);
+  }
+
+  .action-btn.stop:hover {
+    background: var(--ctp-red);
+    color: var(--ctp-base);
+    border-color: var(--ctp-red);
+  }
+
+  .agent-card.tier2 {
+    min-width: 6rem;
+  }
+
+  .agent-card.tier2 .card-actions {
+    display: none;
+  }
+
+  .unread-badge {
+    background: var(--ctp-red);
+    color: var(--ctp-base);
+    border-radius: 0.5rem;
+    padding: 0 0.25rem;
+    font-size: 0.5rem;
+    font-weight: 700;
+    min-width: 0.75rem;
+    text-align: center;
+  }
+</style>
diff --git a/v2/src/lib/components/Workspace/MemoriesTab.svelte b/v2/src/lib/components/Workspace/MemoriesTab.svelte
new file mode 100644
index 0000000..1b7bab2
--- /dev/null
+++ b/v2/src/lib/components/Workspace/MemoriesTab.svelte
@@ -0,0 +1,375 @@
+<script lang="ts">
+  import { getDefaultAdapter, getAvailableAdapters, type MemoryAdapter, type MemoryNode } from '../../adapters/memory-adapter';
+
+  let adapter = $state<MemoryAdapter | undefined>(undefined);
+  let adapterName = $state('');
+  let nodes = $state<MemoryNode[]>([]);
+  let searchQuery = $state('');
+  let loading = $state(false);
+  let error = $state('');
+  let total = $state(0);
+  let selectedNode = $state<MemoryNode | null>(null);
+
+  $effect(() => {
+    adapter = getDefaultAdapter();
+    adapterName = adapter?.name ?? '';
+    if (adapter) {
+      loadNodes();
+    }
+  });
+
+  async function loadNodes() {
+    if (!adapter) return;
+    loading = true;
+    error = '';
+    try {
+      const result = await adapter.list({ limit: 50 });
+      nodes = result.nodes;
+      total = result.total;
+    } catch (e) {
+      error = `Failed to load: ${e}`;
+      nodes = [];
+    } finally {
+      loading = false;
+    }
+  }
+
+  async function handleSearch() {
+    if (!adapter || !searchQuery.trim()) {
+      if (adapter) loadNodes();
+      return;
+    }
+    loading = true;
+    error = '';
+    try {
+      const result = await adapter.search(searchQuery.trim(), { limit: 50 });
+      nodes = result.nodes;
+      total = result.total;
+    } catch (e) {
+      error = `Search failed: ${e}`;
+    } finally {
+      loading = false;
+    }
+  }
+
+  function selectNode(node: MemoryNode) {
+    selectedNode = selectedNode?.id === node.id ? null : node;
+  }
+
+  function clearSearch() {
+    searchQuery = '';
+    selectedNode = null;
+    loadNodes();
+  }
+</script>
+
+<div class="memories-tab">
+  {#if !adapter}
+    <div class="no-adapter">
+      <div class="no-adapter-icon">
+        <svg width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round">
+          <circle cx="12" cy="12" r="10"></circle>
+          <path d="M12 8v4m0 4h.01"></path>
+        </svg>
+      </div>
+      <p class="no-adapter-title">No memory adapter configured</p>
+      <p class="no-adapter-hint">Register a memory adapter (e.g. Memora) to browse knowledge here.</p>
+    </div>
+  {:else}
+    <div class="mem-header">
+      <h3>{adapterName}</h3>
+      <span class="mem-count">{total} memories</span>
+      <div class="mem-adapters">
+        {#each getAvailableAdapters() as a (a.name)}
+          <button
+            class="adapter-btn"
+            class:active={a.name === adapterName}
+            onclick={() => { adapter = a; adapterName = a.name; loadNodes(); }}
+          >{a.name}</button>
+        {/each}
+      </div>
+    </div>
+
+    <div class="mem-search">
+      <input
+        type="text"
+        class="search-input"
+        placeholder="Search memories…"
+        bind:value={searchQuery}
+        onkeydown={(e) => { if (e.key === 'Enter') handleSearch(); }}
+      />
+      {#if searchQuery}
+        <button class="clear-btn" onclick={clearSearch}>Clear</button>
+      {/if}
+    </div>
+
+    {#if error}
+      <div class="mem-error">{error}</div>
+    {/if}
+
+    <div class="mem-list">
+      {#if loading}
+        <div class="mem-state">Loading…</div>
+      {:else if nodes.length === 0}
+        <div class="mem-state">No memories found</div>
+      {:else}
+        {#each nodes as node (node.id)}
+          <button class="mem-card" class:expanded={selectedNode?.id === node.id} onclick={() => selectNode(node)}>
+            <div class="mem-card-header">
+              <span class="mem-id">#{node.id}</span>
+              <div class="mem-tags">
+                {#each node.tags.slice(0, 4) as tag}
+                  <span class="mem-tag">{tag}</span>
+                {/each}
+                {#if node.tags.length > 4}
+                  <span class="mem-tag-more">+{node.tags.length - 4}</span>
+                {/if}
+              </div>
+            </div>
+            <div class="mem-card-content" class:truncated={selectedNode?.id !== node.id}>
+              {node.content}
+            </div>
+            {#if selectedNode?.id === node.id && node.metadata}
+              <div class="mem-card-meta">
+                <pre>{JSON.stringify(node.metadata, null, 2)}</pre>
+              </div>
+            {/if}
+          </button>
+        {/each}
+      {/if}
+    </div>
+  {/if}
+</div>
+
+<style>
+  .memories-tab {
+    display: flex;
+    flex-direction: column;
+    height: 100%;
+    background: var(--ctp-base);
+    color: var(--ctp-text);
+    overflow: hidden;
+  }
+
+  .no-adapter {
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    justify-content: center;
+    height: 100%;
+    gap: 0.5rem;
+    padding: 2rem;
+    text-align: center;
+  }
+
+  .no-adapter-icon {
+    color: var(--ctp-overlay0);
+  }
+
+  .no-adapter-title {
+    font-size: 0.85rem;
+    font-weight: 600;
+    color: var(--ctp-subtext1);
+    margin: 0;
+  }
+
+  .no-adapter-hint {
+    font-size: 0.7rem;
+    color: var(--ctp-overlay0);
+    margin: 0;
+  }
+
+  .mem-header {
+    display: flex;
+    align-items: center;
+    gap: 0.5rem;
+    padding: 0.5rem 0.75rem;
+    border-bottom: 1px solid var(--ctp-surface0);
+    flex-shrink: 0;
+  }
+
+  .mem-header h3 {
+    font-size: 0.8rem;
+    font-weight: 600;
+    color: var(--ctp-blue);
+    margin: 0;
+    text-transform: capitalize;
+  }
+
+  .mem-count {
+    font-size: 0.625rem;
+    color: var(--ctp-overlay0);
+  }
+
+  .mem-adapters {
+    margin-left: auto;
+    display: flex;
+    gap: 0.25rem;
+  }
+
+  .adapter-btn {
+    padding: 0.125rem 0.375rem;
+    border: 1px solid var(--ctp-surface0);
+    border-radius: 0.25rem;
+    background: transparent;
+    color: var(--ctp-overlay1);
+    font-size: 0.6rem;
+    cursor: pointer;
+    transition: all 0.12s;
+  }
+
+  .adapter-btn.active {
+    background: var(--ctp-surface0);
+    color: var(--ctp-text);
+    border-color: var(--ctp-blue);
+  }
+
+  .mem-search {
+    display: flex;
+    gap: 0.25rem;
+    padding: 0.375rem 0.75rem;
+    border-bottom: 1px solid var(--ctp-surface0);
+    flex-shrink: 0;
+  }
+
+  .search-input {
+    flex: 1;
+    background: var(--ctp-surface0);
+    border: 1px solid var(--ctp-surface0);
+    border-radius: 0.25rem;
+    color: var(--ctp-text);
+    font-size: 0.7rem;
+    padding: 0.25rem 0.5rem;
+  }
+
+  .search-input:focus {
+    outline: none;
+    border-color: var(--ctp-blue);
+  }
+
+  .clear-btn {
+    background: var(--ctp-surface0);
+    border: none;
+    color: var(--ctp-subtext0);
+    font-size: 0.65rem;
+    padding: 0.25rem 0.5rem;
+    border-radius: 0.25rem;
+    cursor: pointer;
+  }
+
+  .clear-btn:hover {
+    background: var(--ctp-surface1);
+    color: var(--ctp-text);
+  }
+
+  .mem-error {
+    padding: 0.5rem 0.75rem;
+    color: var(--ctp-red);
+    font-size: 0.7rem;
+    flex-shrink: 0;
+  }
+
+  .mem-list {
+    flex: 1;
+    overflow-y: auto;
+    padding: 0.375rem 0.5rem;
+  }
+
+  .mem-state {
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    height: 100%;
+    color: var(--ctp-overlay0);
+    font-size: 0.75rem;
+  }
+
+  .mem-card {
+    display: flex;
+    flex-direction: column;
+    width: 100%;
+    text-align: left;
+    background: var(--ctp-surface0);
+    border: 1px solid transparent;
+    border-radius: 0.25rem;
+    padding: 0.375rem 0.5rem;
+    margin-bottom: 0.25rem;
+    cursor: pointer;
+    transition: background 0.1s, border-color 0.1s;
+  }
+
+  .mem-card:hover {
+    background: var(--ctp-surface1);
+  }
+
+  .mem-card.expanded {
+    border-color: var(--ctp-blue);
+  }
+
+  .mem-card-header {
+    display: flex;
+    align-items: center;
+    gap: 0.375rem;
+    margin-bottom: 0.25rem;
+  }
+
+  .mem-id {
+    font-size: 0.6rem;
+    color: var(--ctp-overlay0);
+    font-family: var(--term-font-family, monospace);
+    flex-shrink: 0;
+  }
+
+  .mem-tags {
+    display: flex;
+    gap: 0.1875rem;
+    flex-wrap: wrap;
+    overflow: hidden;
+  }
+
+  .mem-tag {
+    font-size: 0.55rem;
+    padding: 0.0625rem 0.25rem;
+    border-radius: 0.1875rem;
+    background: color-mix(in srgb, var(--ctp-blue) 15%, transparent);
+    color: var(--ctp-blue);
+  }
+
+  .mem-tag-more {
+    font-size: 0.55rem;
+    color: var(--ctp-overlay0);
+  }
+
+  .mem-card-content {
+    font-size: 0.7rem;
+    line-height: 1.4;
+    color: var(--ctp-subtext0);
+    white-space: pre-wrap;
+    word-break: break-word;
+  }
+
+  .mem-card-content.truncated {
+    max-height: 3em;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    display: -webkit-box;
+    -webkit-line-clamp: 2;
+    -webkit-box-orient: vertical;
+  }
+
+  .mem-card-meta {
+    margin-top: 0.375rem;
+    padding-top: 0.375rem;
+    border-top: 1px solid var(--ctp-surface1);
+  }
+
+  .mem-card-meta pre {
+    font-size: 0.6rem;
+    font-family: var(--term-font-family, monospace);
+    color: var(--ctp-overlay1);
+    white-space: pre-wrap;
+    margin: 0;
+    max-height: 10rem;
+    overflow-y: auto;
+  }
+</style>
diff --git a/v2/src/lib/components/Workspace/MetricsPanel.svelte b/v2/src/lib/components/Workspace/MetricsPanel.svelte
new file mode 100644
index 0000000..945d22b
--- /dev/null
+++ b/v2/src/lib/components/Workspace/MetricsPanel.svelte
@@ -0,0 +1,808 @@
+<script lang="ts">
+  import { onMount, onDestroy } from 'svelte';
+  import type { ProjectConfig } from '../../types/groups';
+  import type { ProjectHealth } from '../../stores/health.svelte';
+  import type { GroupId, ProjectId as ProjectIdType } from '../../types/ids';
+  import { getProjectHealth, getAllProjectHealth, getHealthAggregates } from '../../stores/health.svelte';
+  import { getAgentSession } from '../../stores/agents.svelte';
+  import { listTasks, type Task } from '../../adapters/bttask-bridge';
+  import { invoke } from '@tauri-apps/api/core';
+
+  interface Props {
+    project: ProjectConfig;
+    groupId?: GroupId;
+  }
+
+  let { project, groupId }: Props = $props();
+
+  // --- View toggle ---
+  type MetricsView = 'live' | 'history';
+  let activeView = $state<MetricsView>('live');
+
+  // --- Live view state ---
+  let taskCounts = $state<Record<string, number>>({ todo: 0, progress: 0, review: 0, done: 0, blocked: 0 });
+  let taskPollTimer: ReturnType<typeof setInterval> | null = null;
+
+  // --- History view state ---
+  interface MetricPoint {
+    endTime: number;
+    costUsd: number;
+    peakTokens: number;
+    turnCount: number;
+    toolCallCount: number;
+    durationMin: number;
+  }
+  let historyData = $state<MetricPoint[]>([]);
+  let historyLoading = $state(false);
+  type HistoryMetric = 'cost' | 'tokens' | 'turns' | 'tools' | 'duration';
+  let selectedHistoryMetric = $state<HistoryMetric>('cost');
+
+  // --- Derived live data ---
+  let health = $derived(getProjectHealth(project.id));
+  let aggregates = $derived(getHealthAggregates());
+  let allHealth = $derived(getAllProjectHealth());
+
+  let session = $derived.by(() => {
+    if (!health?.sessionId) return undefined;
+    return getAgentSession(health.sessionId);
+  });
+
+  // --- Task polling ---
+  async function fetchTaskCounts() {
+    if (!groupId) return;
+    try {
+      const tasks = await listTasks(groupId);
+      const counts: Record<string, number> = { todo: 0, progress: 0, review: 0, done: 0, blocked: 0 };
+      for (const t of tasks) {
+        if (counts[t.status] !== undefined) counts[t.status]++;
+      }
+      taskCounts = counts;
+    } catch {
+      // bttask db may not exist yet
+    }
+  }
+
+  // --- History loading ---
+  async function loadHistory() {
+    historyLoading = true;
+    try {
+      const metrics = await invoke<Array<{
+        id: number;
+        project_id: string;
+        session_id: string;
+        start_time: number;
+        end_time: number;
+        peak_tokens: number;
+        turn_count: number;
+        tool_call_count: number;
+        cost_usd: number;
+        model: string | null;
+        status: string;
+        error_message: string | null;
+      }>>('session_metrics_load', { projectId: project.id, limit: 50 });
+
+      historyData = metrics.reverse().map(m => ({
+        endTime: m.end_time,
+        costUsd: m.cost_usd,
+        peakTokens: m.peak_tokens,
+        turnCount: m.turn_count,
+        toolCallCount: m.tool_call_count,
+        durationMin: Math.max(0.1, (m.end_time - m.start_time) / 60_000),
+      }));
+    } catch (e) {
+      console.warn('Failed to load metrics history:', e);
+      historyData = [];
+    }
+    historyLoading = false;
+  }
+
+  // --- SVG sparkline helpers ---
+  function sparklinePath(points: number[], width: number, height: number): string {
+    if (points.length < 2) return '';
+    const max = Math.max(...points, 0.001);
+    const step = width / (points.length - 1);
+    return points
+      .map((v, i) => {
+        const x = i * step;
+        const y = height - (v / max) * height;
+        return `${i === 0 ? 'M' : 'L'}${x.toFixed(1)},${y.toFixed(1)}`;
+      })
+      .join(' ');
+  }
+
+  function getHistoryValues(metric: HistoryMetric): number[] {
+    switch (metric) {
+      case 'cost': return historyData.map(d => d.costUsd);
+      case 'tokens': return historyData.map(d => d.peakTokens);
+      case 'turns': return historyData.map(d => d.turnCount);
+      case 'tools': return historyData.map(d => d.toolCallCount);
+      case 'duration': return historyData.map(d => d.durationMin);
+    }
+  }
+
+  function formatMetricValue(metric: HistoryMetric, value: number): string {
+    switch (metric) {
+      case 'cost': return `$${value.toFixed(4)}`;
+      case 'tokens': return value >= 1000 ? `${(value / 1000).toFixed(1)}K` : `${value}`;
+      case 'turns': return `${value}`;
+      case 'tools': return `${value}`;
+      case 'duration': return `${value.toFixed(1)}m`;
+    }
+  }
+
+  const METRIC_LABELS: Record<HistoryMetric, string> = {
+    cost: 'Cost (USD)',
+    tokens: 'Peak Tokens',
+    turns: 'Turns',
+    tools: 'Tool Calls',
+    duration: 'Duration',
+  };
+
+  const METRIC_COLORS: Record<HistoryMetric, string> = {
+    cost: 'var(--ctp-yellow)',
+    tokens: 'var(--ctp-blue)',
+    turns: 'var(--ctp-green)',
+    tools: 'var(--ctp-mauve)',
+    duration: 'var(--ctp-peach)',
+  };
+
+  // --- Formatting helpers ---
+  function fmtBurnRate(rate: number): string {
+    if (rate === 0) return '$0/hr';
+    if (rate < 0.01) return `$${(rate * 100).toFixed(1)}c/hr`;
+    return `$${rate.toFixed(2)}/hr`;
+  }
+
+  function fmtPressure(p: number | null): string {
+    if (p === null) return '—';
+    return `${Math.round(p * 100)}%`;
+  }
+
+  function pressureColor(p: number | null): string {
+    if (p === null) return 'var(--ctp-overlay0)';
+    if (p > 0.9) return 'var(--ctp-red)';
+    if (p > 0.75) return 'var(--ctp-peach)';
+    if (p > 0.5) return 'var(--ctp-yellow)';
+    return 'var(--ctp-green)';
+  }
+
+  function stateColor(state: string): string {
+    switch (state) {
+      case 'running': return 'var(--ctp-green)';
+      case 'idle': return 'var(--ctp-overlay1)';
+      case 'stalled': return 'var(--ctp-peach)';
+      default: return 'var(--ctp-overlay0)';
+    }
+  }
+
+  function fmtIdle(ms: number): string {
+    if (ms === 0) return '—';
+    const sec = Math.floor(ms / 1000);
+    if (sec < 60) return `${sec}s`;
+    const min = Math.floor(sec / 60);
+    if (min < 60) return `${min}m`;
+    return `${Math.floor(min / 60)}h ${min % 60}m`;
+  }
+
+  // --- Lifecycle ---
+  onMount(() => {
+    fetchTaskCounts();
+    taskPollTimer = setInterval(fetchTaskCounts, 10_000);
+  });
+
+  onDestroy(() => {
+    if (taskPollTimer) clearInterval(taskPollTimer);
+  });
+
+  // Load history when switching to history view
+  $effect(() => {
+    if (activeView === 'history' && historyData.length === 0) {
+      loadHistory();
+    }
+  });
+</script>
+
+<div class="metrics-panel">
+  <!-- View tabs -->
+  <div class="view-tabs">
+    <button
+      class="vtab"
+      class:active={activeView === 'live'}
+      onclick={() => activeView = 'live'}
+    >Live</button>
+    <button
+      class="vtab"
+      class:active={activeView === 'history'}
+      onclick={() => activeView = 'history'}
+    >History</button>
+  </div>
+
+  {#if activeView === 'live'}
+    <div class="live-view">
+      <!-- Aggregates bar -->
+      <div class="agg-bar">
+        <div class="agg-item">
+          <span class="agg-label">Fleet</span>
+          <span class="agg-badges">
+            {#if aggregates.running > 0}
+              <span class="agg-badge" style="color: var(--ctp-green)">{aggregates.running} running</span>
+            {/if}
+            {#if aggregates.idle > 0}
+              <span class="agg-badge" style="color: var(--ctp-overlay1)">{aggregates.idle} idle</span>
+            {/if}
+            {#if aggregates.stalled > 0}
+              <span class="agg-badge" style="color: var(--ctp-peach)">{aggregates.stalled} stalled</span>
+            {/if}
+          </span>
+        </div>
+        <div class="agg-item">
+          <span class="agg-label">Burn</span>
+          <span class="agg-value" style="color: var(--ctp-mauve)">{fmtBurnRate(aggregates.totalBurnRatePerHour)}</span>
+        </div>
+      </div>
+
+      <!-- This project's health -->
+      {#if health}
+        <div class="section-header">This Project</div>
+        <div class="health-grid">
+          <div class="health-card">
+            <span class="hc-label">Status</span>
+            <span class="hc-value" style="color: {stateColor(health.activityState)}">
+              {health.activityState}
+              {#if health.activeTool}
+                <span class="hc-tool">({health.activeTool})</span>
+              {/if}
+            </span>
+          </div>
+          <div class="health-card">
+            <span class="hc-label">Burn Rate</span>
+            <span class="hc-value" style="color: var(--ctp-mauve)">{fmtBurnRate(health.burnRatePerHour)}</span>
+          </div>
+          <div class="health-card">
+            <span class="hc-label">Context</span>
+            <span class="hc-value" style="color: {pressureColor(health.contextPressure)}">{fmtPressure(health.contextPressure)}</span>
+          </div>
+          <div class="health-card">
+            <span class="hc-label">Idle</span>
+            <span class="hc-value">{fmtIdle(health.idleDurationMs)}</span>
+          </div>
+          {#if session}
+            <div class="health-card">
+              <span class="hc-label">Tokens</span>
+              <span class="hc-value" style="color: var(--ctp-blue)">{(session.inputTokens + session.outputTokens).toLocaleString()}</span>
+            </div>
+            <div class="health-card">
+              <span class="hc-label">Cost</span>
+              <span class="hc-value" style="color: var(--ctp-yellow)">${session.costUsd.toFixed(4)}</span>
+            </div>
+            <div class="health-card">
+              <span class="hc-label">Turns</span>
+              <span class="hc-value">{session.numTurns}</span>
+            </div>
+            <div class="health-card">
+              <span class="hc-label">Model</span>
+              <span class="hc-value hc-model">{session.model ?? '—'}</span>
+            </div>
+          {/if}
+          {#if health.fileConflictCount > 0}
+            <div class="health-card health-warn">
+              <span class="hc-label">Conflicts</span>
+              <span class="hc-value" style="color: var(--ctp-red)">{health.fileConflictCount}</span>
+            </div>
+          {/if}
+          {#if health.externalConflictCount > 0}
+            <div class="health-card health-warn">
+              <span class="hc-label">External</span>
+              <span class="hc-value" style="color: var(--ctp-peach)">{health.externalConflictCount}</span>
+            </div>
+          {/if}
+          {#if health.attentionScore > 0}
+            <div class="health-card health-attention">
+              <span class="hc-label">Attention</span>
+              <span class="hc-value" style="color: {health.attentionScore >= 90 ? 'var(--ctp-red)' : health.attentionScore >= 70 ? 'var(--ctp-peach)' : 'var(--ctp-yellow)'}">{health.attentionScore}</span>
+              {#if health.attentionReason}
+                <span class="hc-reason">{health.attentionReason}</span>
+              {/if}
+            </div>
+          {/if}
+        </div>
+      {:else}
+        <div class="empty-state">No health data — start an agent session</div>
+      {/if}
+
+      <!-- Task board summary -->
+      {#if groupId}
+        <div class="section-header">Task Board</div>
+        <div class="task-summary">
+          {#each ['todo', 'progress', 'review', 'done', 'blocked'] as status}
+            <div class="task-col" class:task-col-blocked={status === 'blocked' && taskCounts[status] > 0}>
+              <span class="tc-count" class:tc-zero={taskCounts[status] === 0}>{taskCounts[status]}</span>
+              <span class="tc-label">{status === 'progress' ? 'In Prog' : status === 'todo' ? 'To Do' : status.charAt(0).toUpperCase() + status.slice(1)}</span>
+            </div>
+          {/each}
+        </div>
+      {/if}
+
+      <!-- Attention queue (cross-project) -->
+      {#if allHealth.filter(h => h.attentionScore > 0).length > 0}
+        <div class="section-header">Attention Queue</div>
+        <div class="attention-list">
+          {#each allHealth.filter(h => h.attentionScore > 0).slice(0, 5) as item}
+            <div class="attention-row">
+              <span class="ar-score" style="color: {item.attentionScore >= 90 ? 'var(--ctp-red)' : item.attentionScore >= 70 ? 'var(--ctp-peach)' : 'var(--ctp-yellow)'}">{item.attentionScore}</span>
+              <span class="ar-id">{item.projectId.slice(0, 8)}</span>
+              <span class="ar-reason">{item.attentionReason ?? '—'}</span>
+            </div>
+          {/each}
+        </div>
+      {/if}
+    </div>
+  {:else}
+    <!-- History view -->
+    <div class="history-view">
+      {#if historyLoading}
+        <div class="empty-state">Loading history...</div>
+      {:else if historyData.length === 0}
+        <div class="empty-state">No session history for this project</div>
+      {:else}
+        <!-- Metric selector -->
+        <div class="metric-tabs">
+          {#each (['cost', 'tokens', 'turns', 'tools', 'duration'] as const) as metric}
+            <button
+              class="mtab"
+              class:active={selectedHistoryMetric === metric}
+              onclick={() => selectedHistoryMetric = metric}
+              style={selectedHistoryMetric === metric ? `border-bottom-color: ${METRIC_COLORS[metric]}` : ''}
+            >{METRIC_LABELS[metric]}</button>
+          {/each}
+        </div>
+
+        <!-- Sparkline chart -->
+        {@const values = getHistoryValues(selectedHistoryMetric)}
+        {@const maxVal = Math.max(...values, 0.001)}
+        {@const minVal = Math.min(...values)}
+        {@const lastVal = values[values.length - 1] ?? 0}
+        {@const avgVal = values.length > 0 ? values.reduce((a, b) => a + b, 0) / values.length : 0}
+
+        <div class="sparkline-container">
+          <svg viewBox="0 0 400 120" class="sparkline-svg" preserveAspectRatio="none">
+            <!-- Grid lines -->
+            <line x1="0" y1="30" x2="400" y2="30" stroke="var(--ctp-surface0)" stroke-width="0.5" />
+            <line x1="0" y1="60" x2="400" y2="60" stroke="var(--ctp-surface0)" stroke-width="0.5" />
+            <line x1="0" y1="90" x2="400" y2="90" stroke="var(--ctp-surface0)" stroke-width="0.5" />
+
+            <!-- Area fill -->
+            <path
+              d="{sparklinePath(values, 400, 110)} L400,110 L0,110 Z"
+              fill={METRIC_COLORS[selectedHistoryMetric]}
+              opacity="0.08"
+            />
+
+            <!-- Line -->
+            <path
+              d={sparklinePath(values, 400, 110)}
+              fill="none"
+              stroke={METRIC_COLORS[selectedHistoryMetric]}
+              stroke-width="2"
+              stroke-linecap="round"
+              stroke-linejoin="round"
+            />
+
+            <!-- Last point dot -->
+            {#if values.length > 0}
+              {@const lastX = 400}
+              {@const lastY = 110 - (lastVal / maxVal) * 110}
+              <circle cx={lastX} cy={lastY} r="3" fill={METRIC_COLORS[selectedHistoryMetric]} />
+            {/if}
+          </svg>
+        </div>
+
+        <!-- Stats row -->
+        <div class="stats-row">
+          <div class="stat">
+            <span class="stat-label">Last</span>
+            <span class="stat-value" style="color: {METRIC_COLORS[selectedHistoryMetric]}">{formatMetricValue(selectedHistoryMetric, lastVal)}</span>
+          </div>
+          <div class="stat">
+            <span class="stat-label">Avg</span>
+            <span class="stat-value">{formatMetricValue(selectedHistoryMetric, avgVal)}</span>
+          </div>
+          <div class="stat">
+            <span class="stat-label">Max</span>
+            <span class="stat-value">{formatMetricValue(selectedHistoryMetric, maxVal)}</span>
+          </div>
+          <div class="stat">
+            <span class="stat-label">Min</span>
+            <span class="stat-value">{formatMetricValue(selectedHistoryMetric, minVal)}</span>
+          </div>
+          <div class="stat">
+            <span class="stat-label">Sessions</span>
+            <span class="stat-value">{historyData.length}</span>
+          </div>
+        </div>
+
+        <!-- Session table -->
+        <div class="section-header">Recent Sessions</div>
+        <div class="session-table">
+          <div class="st-header">
+            <span class="st-col st-col-time">Time</span>
+            <span class="st-col st-col-dur">Dur</span>
+            <span class="st-col st-col-cost">Cost</span>
+            <span class="st-col st-col-tok">Tokens</span>
+            <span class="st-col st-col-turns">Turns</span>
+            <span class="st-col st-col-tools">Tools</span>
+          </div>
+          {#each historyData.slice(-10).reverse() as row}
+            <div class="st-row">
+              <span class="st-col st-col-time">{new Date(row.endTime).toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' })}</span>
+              <span class="st-col st-col-dur">{row.durationMin.toFixed(0)}m</span>
+              <span class="st-col st-col-cost" style="color: var(--ctp-yellow)">${row.costUsd.toFixed(3)}</span>
+              <span class="st-col st-col-tok">{row.peakTokens >= 1000 ? `${(row.peakTokens / 1000).toFixed(0)}K` : row.peakTokens}</span>
+              <span class="st-col st-col-turns">{row.turnCount}</span>
+              <span class="st-col st-col-tools">{row.toolCallCount}</span>
+            </div>
+          {/each}
+        </div>
+
+        <button class="refresh-btn" onclick={loadHistory}>Refresh</button>
+      {/if}
+    </div>
+  {/if}
+</div>
+
+<style>
+  .metrics-panel {
+    display: flex;
+    flex-direction: column;
+    height: 100%;
+    overflow: hidden;
+    font-family: system-ui, -apple-system, sans-serif;
+    font-size: 0.8rem;
+    color: var(--ctp-text);
+  }
+
+  /* --- View tabs --- */
+  .view-tabs {
+    display: flex;
+    gap: 0;
+    background: var(--ctp-mantle);
+    border-bottom: 1px solid var(--ctp-surface0);
+    flex-shrink: 0;
+  }
+
+  .vtab {
+    flex: 1;
+    padding: 0.375rem 0;
+    border: none;
+    border-bottom: 2px solid transparent;
+    background: transparent;
+    color: var(--ctp-overlay1);
+    font-size: 0.7rem;
+    font-weight: 500;
+    letter-spacing: 0.05em;
+    text-transform: uppercase;
+    cursor: pointer;
+    transition: color 0.12s, border-color 0.12s;
+  }
+
+  .vtab:hover { color: var(--ctp-subtext1); }
+  .vtab.active {
+    color: var(--ctp-text);
+    border-bottom-color: var(--accent, var(--ctp-blue));
+    font-weight: 600;
+  }
+
+  /* --- Live view --- */
+  .live-view {
+    flex: 1;
+    overflow-y: auto;
+    padding: 0.5rem;
+    display: flex;
+    flex-direction: column;
+    gap: 0.625rem;
+  }
+
+  .agg-bar {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    padding: 0.375rem 0.5rem;
+    background: var(--ctp-mantle);
+    border-radius: 0.25rem;
+    border: 1px solid var(--ctp-surface0);
+  }
+
+  .agg-item {
+    display: flex;
+    align-items: center;
+    gap: 0.375rem;
+  }
+
+  .agg-label {
+    color: var(--ctp-overlay0);
+    font-size: 0.65rem;
+    text-transform: uppercase;
+    letter-spacing: 0.05em;
+  }
+
+  .agg-badges {
+    display: flex;
+    gap: 0.375rem;
+  }
+
+  .agg-badge {
+    font-size: 0.7rem;
+    font-weight: 500;
+  }
+
+  .agg-value {
+    font-size: 0.75rem;
+    font-weight: 600;
+  }
+
+  .section-header {
+    color: var(--ctp-overlay0);
+    font-size: 0.6rem;
+    text-transform: uppercase;
+    letter-spacing: 0.08em;
+    padding: 0.25rem 0 0.125rem;
+    font-weight: 600;
+  }
+
+  /* --- Health grid --- */
+  .health-grid {
+    display: grid;
+    grid-template-columns: repeat(auto-fill, minmax(5.5rem, 1fr));
+    gap: 0.375rem;
+  }
+
+  .health-card {
+    padding: 0.375rem 0.5rem;
+    background: var(--ctp-mantle);
+    border-radius: 0.25rem;
+    border: 1px solid var(--ctp-surface0);
+    display: flex;
+    flex-direction: column;
+    gap: 0.125rem;
+  }
+
+  .health-warn { border-color: color-mix(in srgb, var(--ctp-peach) 30%, var(--ctp-surface0)); }
+  .health-attention { border-color: color-mix(in srgb, var(--ctp-yellow) 30%, var(--ctp-surface0)); }
+
+  .hc-label {
+    font-size: 0.6rem;
+    color: var(--ctp-overlay0);
+    text-transform: uppercase;
+    letter-spacing: 0.05em;
+  }
+
+  .hc-value {
+    font-size: 0.8rem;
+    font-weight: 600;
+    color: var(--ctp-text);
+  }
+
+  .hc-tool {
+    font-size: 0.65rem;
+    font-weight: 400;
+    color: var(--ctp-overlay1);
+  }
+
+  .hc-model {
+    font-size: 0.6rem;
+    font-weight: 400;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+  }
+
+  .hc-reason {
+    font-size: 0.6rem;
+    color: var(--ctp-subtext0);
+    font-weight: 400;
+  }
+
+  /* --- Task summary --- */
+  .task-summary {
+    display: flex;
+    gap: 0.25rem;
+  }
+
+  .task-col {
+    flex: 1;
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    gap: 0.125rem;
+    padding: 0.375rem 0.25rem;
+    background: var(--ctp-mantle);
+    border-radius: 0.25rem;
+    border: 1px solid var(--ctp-surface0);
+  }
+
+  .task-col-blocked {
+    border-color: color-mix(in srgb, var(--ctp-red) 30%, var(--ctp-surface0));
+  }
+
+  .tc-count {
+    font-size: 1rem;
+    font-weight: 700;
+    color: var(--ctp-text);
+    line-height: 1;
+  }
+
+  .tc-zero { color: var(--ctp-overlay0); }
+
+  .tc-label {
+    font-size: 0.55rem;
+    color: var(--ctp-overlay0);
+    text-transform: uppercase;
+    letter-spacing: 0.03em;
+  }
+
+  /* --- Attention queue --- */
+  .attention-list {
+    display: flex;
+    flex-direction: column;
+    gap: 0.25rem;
+  }
+
+  .attention-row {
+    display: flex;
+    align-items: center;
+    gap: 0.5rem;
+    padding: 0.25rem 0.5rem;
+    background: var(--ctp-mantle);
+    border-radius: 0.25rem;
+    border: 1px solid var(--ctp-surface0);
+    font-size: 0.7rem;
+  }
+
+  .ar-score { font-weight: 700; min-width: 1.5rem; }
+  .ar-id { color: var(--ctp-overlay1); font-family: monospace; font-size: 0.65rem; }
+  .ar-reason { color: var(--ctp-subtext0); flex: 1; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+
+  /* --- History view --- */
+  .history-view {
+    flex: 1;
+    overflow-y: auto;
+    padding: 0.5rem;
+    display: flex;
+    flex-direction: column;
+    gap: 0.5rem;
+  }
+
+  .metric-tabs {
+    display: flex;
+    gap: 0;
+    flex-shrink: 0;
+  }
+
+  .mtab {
+    flex: 1;
+    padding: 0.25rem 0;
+    border: none;
+    border-bottom: 2px solid transparent;
+    background: transparent;
+    color: var(--ctp-overlay1);
+    font-size: 0.6rem;
+    font-weight: 500;
+    text-transform: uppercase;
+    letter-spacing: 0.03em;
+    cursor: pointer;
+    transition: color 0.12s;
+  }
+
+  .mtab:hover { color: var(--ctp-subtext1); }
+  .mtab.active { color: var(--ctp-text); font-weight: 600; }
+
+  /* --- Sparkline --- */
+  .sparkline-container {
+    background: var(--ctp-mantle);
+    border: 1px solid var(--ctp-surface0);
+    border-radius: 0.25rem;
+    padding: 0.5rem;
+  }
+
+  .sparkline-svg {
+    width: 100%;
+    height: 7.5rem;
+  }
+
+  /* --- Stats row --- */
+  .stats-row {
+    display: flex;
+    gap: 0.25rem;
+  }
+
+  .stat {
+    flex: 1;
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    gap: 0.0625rem;
+    padding: 0.25rem;
+    background: var(--ctp-mantle);
+    border-radius: 0.25rem;
+    border: 1px solid var(--ctp-surface0);
+  }
+
+  .stat-label {
+    font-size: 0.55rem;
+    color: var(--ctp-overlay0);
+    text-transform: uppercase;
+    letter-spacing: 0.05em;
+  }
+
+  .stat-value {
+    font-size: 0.7rem;
+    font-weight: 600;
+    color: var(--ctp-subtext0);
+  }
+
+  /* --- Session table --- */
+  .session-table {
+    display: flex;
+    flex-direction: column;
+    gap: 1px;
+    font-size: 0.65rem;
+    font-family: monospace;
+  }
+
+  .st-header {
+    display: flex;
+    gap: 0;
+    padding: 0.25rem 0;
+    border-bottom: 1px solid var(--ctp-surface0);
+    color: var(--ctp-overlay0);
+    text-transform: uppercase;
+    letter-spacing: 0.05em;
+    font-size: 0.55rem;
+    font-family: system-ui, sans-serif;
+  }
+
+  .st-row {
+    display: flex;
+    gap: 0;
+    padding: 0.1875rem 0;
+    border-bottom: 1px solid color-mix(in srgb, var(--ctp-surface0) 40%, transparent);
+    color: var(--ctp-subtext0);
+  }
+
+  .st-row:hover { background: color-mix(in srgb, var(--ctp-surface0) 30%, transparent); }
+
+  .st-col { text-align: right; padding: 0 0.25rem; }
+  .st-col-time { flex: 1.2; text-align: left; }
+  .st-col-dur { flex: 0.8; }
+  .st-col-cost { flex: 1; }
+  .st-col-tok { flex: 1; }
+  .st-col-turns { flex: 0.7; }
+  .st-col-tools { flex: 0.7; }
+
+  /* --- Misc --- */
+  .empty-state {
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    padding: 2rem;
+    color: var(--ctp-overlay0);
+    font-size: 0.75rem;
+  }
+
+  .refresh-btn {
+    align-self: center;
+    padding: 0.25rem 0.75rem;
+    background: var(--ctp-surface0);
+    border: 1px solid var(--ctp-surface1);
+    border-radius: 0.25rem;
+    color: var(--ctp-subtext0);
+    font-size: 0.65rem;
+    cursor: pointer;
+    transition: background 0.12s;
+  }
+
+  .refresh-btn:hover {
+    background: var(--ctp-surface1);
+    color: var(--ctp-text);
+  }
+</style>
diff --git a/v2/src/lib/components/Workspace/MetricsPanel.test.ts b/v2/src/lib/components/Workspace/MetricsPanel.test.ts
new file mode 100644
index 0000000..db9ada9
--- /dev/null
+++ b/v2/src/lib/components/Workspace/MetricsPanel.test.ts
@@ -0,0 +1,205 @@
+import { describe, it, expect } from 'vitest';
+
+// Test the pure utility functions used in MetricsPanel
+// These are extracted for testability since the component uses them internally
+
+// --- Sparkline path generator (same logic as in MetricsPanel.svelte) ---
+function sparklinePath(points: number[], width: number, height: number): string {
+  if (points.length < 2) return '';
+  const max = Math.max(...points, 0.001);
+  const step = width / (points.length - 1);
+  return points
+    .map((v, i) => {
+      const x = i * step;
+      const y = height - (v / max) * height;
+      return `${i === 0 ? 'M' : 'L'}${x.toFixed(1)},${y.toFixed(1)}`;
+    })
+    .join(' ');
+}
+
+// --- Format helpers (same logic as in MetricsPanel.svelte) ---
+type HistoryMetric = 'cost' | 'tokens' | 'turns' | 'tools' | 'duration';
+
+function formatMetricValue(metric: HistoryMetric, value: number): string {
+  switch (metric) {
+    case 'cost': return `$${value.toFixed(4)}`;
+    case 'tokens': return value >= 1000 ? `${(value / 1000).toFixed(1)}K` : `${value}`;
+    case 'turns': return `${value}`;
+    case 'tools': return `${value}`;
+    case 'duration': return `${value.toFixed(1)}m`;
+  }
+}
+
+function fmtBurnRate(rate: number): string {
+  if (rate === 0) return '$0/hr';
+  if (rate < 0.01) return `$${(rate * 100).toFixed(1)}c/hr`;
+  return `$${rate.toFixed(2)}/hr`;
+}
+
+function fmtPressure(p: number | null): string {
+  if (p === null) return '—';
+  return `${Math.round(p * 100)}%`;
+}
+
+function fmtIdle(ms: number): string {
+  if (ms === 0) return '—';
+  const sec = Math.floor(ms / 1000);
+  if (sec < 60) return `${sec}s`;
+  const min = Math.floor(sec / 60);
+  if (min < 60) return `${min}m`;
+  return `${Math.floor(min / 60)}h ${min % 60}m`;
+}
+
+function pressureColor(p: number | null): string {
+  if (p === null) return 'var(--ctp-overlay0)';
+  if (p > 0.9) return 'var(--ctp-red)';
+  if (p > 0.75) return 'var(--ctp-peach)';
+  if (p > 0.5) return 'var(--ctp-yellow)';
+  return 'var(--ctp-green)';
+}
+
+function stateColor(state: string): string {
+  switch (state) {
+    case 'running': return 'var(--ctp-green)';
+    case 'idle': return 'var(--ctp-overlay1)';
+    case 'stalled': return 'var(--ctp-peach)';
+    default: return 'var(--ctp-overlay0)';
+  }
+}
+
+describe('MetricsPanel — sparklinePath', () => {
+  it('returns empty string for fewer than 2 points', () => {
+    expect(sparklinePath([], 400, 120)).toBe('');
+    expect(sparklinePath([5], 400, 120)).toBe('');
+  });
+
+  it('generates valid SVG path for 2 points', () => {
+    const path = sparklinePath([0, 10], 400, 120);
+    expect(path).toMatch(/^M0\.0,120\.0 L400\.0,0\.0$/);
+  });
+
+  it('generates path with correct number of segments', () => {
+    const path = sparklinePath([1, 2, 3, 4, 5], 400, 100);
+    const segments = path.split(' ');
+    expect(segments).toHaveLength(5);
+    expect(segments[0]).toMatch(/^M/);
+    expect(segments[1]).toMatch(/^L/);
+  });
+
+  it('scales Y axis to max value', () => {
+    const path = sparklinePath([50, 100], 400, 100);
+    // Point 1: x=0, y=100 - (50/100)*100 = 50
+    // Point 2: x=400, y=100 - (100/100)*100 = 0
+    expect(path).toBe('M0.0,50.0 L400.0,0.0');
+  });
+
+  it('handles all-zero values without division by zero', () => {
+    const path = sparklinePath([0, 0, 0], 400, 100);
+    expect(path).not.toBe('');
+    expect(path).not.toContain('NaN');
+  });
+});
+
+describe('MetricsPanel — formatMetricValue', () => {
+  it('formats cost with 4 decimals', () => {
+    expect(formatMetricValue('cost', 1.2345)).toBe('$1.2345');
+    expect(formatMetricValue('cost', 0)).toBe('$0.0000');
+  });
+
+  it('formats tokens with K suffix for large values', () => {
+    expect(formatMetricValue('tokens', 150000)).toBe('150.0K');
+    expect(formatMetricValue('tokens', 1500)).toBe('1.5K');
+    expect(formatMetricValue('tokens', 500)).toBe('500');
+  });
+
+  it('formats turns as integer', () => {
+    expect(formatMetricValue('turns', 42)).toBe('42');
+  });
+
+  it('formats tools as integer', () => {
+    expect(formatMetricValue('tools', 7)).toBe('7');
+  });
+
+  it('formats duration with minutes suffix', () => {
+    expect(formatMetricValue('duration', 5.3)).toBe('5.3m');
+  });
+});
+
+describe('MetricsPanel — fmtBurnRate', () => {
+  it('shows $0/hr for zero rate', () => {
+    expect(fmtBurnRate(0)).toBe('$0/hr');
+  });
+
+  it('shows cents format for tiny rates', () => {
+    expect(fmtBurnRate(0.005)).toBe('$0.5c/hr');
+  });
+
+  it('shows dollar format for normal rates', () => {
+    expect(fmtBurnRate(2.5)).toBe('$2.50/hr');
+  });
+});
+
+describe('MetricsPanel — fmtPressure', () => {
+  it('shows dash for null', () => {
+    expect(fmtPressure(null)).toBe('—');
+  });
+
+  it('formats as percentage', () => {
+    expect(fmtPressure(0.75)).toBe('75%');
+    expect(fmtPressure(0.5)).toBe('50%');
+    expect(fmtPressure(1)).toBe('100%');
+  });
+});
+
+describe('MetricsPanel — fmtIdle', () => {
+  it('shows dash for zero', () => {
+    expect(fmtIdle(0)).toBe('—');
+  });
+
+  it('shows seconds for short durations', () => {
+    expect(fmtIdle(5000)).toBe('5s');
+    expect(fmtIdle(30000)).toBe('30s');
+  });
+
+  it('shows minutes for medium durations', () => {
+    expect(fmtIdle(120_000)).toBe('2m');
+    expect(fmtIdle(3_599_000)).toBe('59m');
+  });
+
+  it('shows hours and minutes for long durations', () => {
+    expect(fmtIdle(3_600_000)).toBe('1h 0m');
+    expect(fmtIdle(5_400_000)).toBe('1h 30m');
+  });
+});
+
+describe('MetricsPanel — pressureColor', () => {
+  it('returns overlay0 for null', () => {
+    expect(pressureColor(null)).toBe('var(--ctp-overlay0)');
+  });
+
+  it('returns red for critical pressure', () => {
+    expect(pressureColor(0.95)).toBe('var(--ctp-red)');
+  });
+
+  it('returns peach for high pressure', () => {
+    expect(pressureColor(0.8)).toBe('var(--ctp-peach)');
+  });
+
+  it('returns yellow for moderate pressure', () => {
+    expect(pressureColor(0.6)).toBe('var(--ctp-yellow)');
+  });
+
+  it('returns green for low pressure', () => {
+    expect(pressureColor(0.3)).toBe('var(--ctp-green)');
+  });
+});
+
+describe('MetricsPanel — stateColor', () => {
+  it('maps activity states to correct colors', () => {
+    expect(stateColor('running')).toBe('var(--ctp-green)');
+    expect(stateColor('idle')).toBe('var(--ctp-overlay1)');
+    expect(stateColor('stalled')).toBe('var(--ctp-peach)');
+    expect(stateColor('inactive')).toBe('var(--ctp-overlay0)');
+    expect(stateColor('unknown')).toBe('var(--ctp-overlay0)');
+  });
+});
diff --git a/v2/src/lib/components/Workspace/PdfViewer.svelte b/v2/src/lib/components/Workspace/PdfViewer.svelte
new file mode 100644
index 0000000..b63159d
--- /dev/null
+++ b/v2/src/lib/components/Workspace/PdfViewer.svelte
@@ -0,0 +1,292 @@
+<script lang="ts">
+  import { onMount, onDestroy } from 'svelte';
+  import { convertFileSrc } from '@tauri-apps/api/core';
+  import * as pdfjsLib from 'pdfjs-dist';
+
+  // Worker copied to public/ — Vite serves it as a static asset.
+  // Avoids Vite/Rollup resolution issues with pdfjs worker imports.
+  pdfjsLib.GlobalWorkerOptions.workerSrc = '/pdf.worker.min.mjs';
+
+  interface Props {
+    filePath: string;
+  }
+
+  let { filePath }: Props = $props();
+
+  let container: HTMLDivElement | undefined = $state();
+  let pageCount = $state(0);
+  let currentScale = $state(1.0);
+  let loading = $state(true);
+  let error = $state<string | null>(null);
+
+  let pdfDoc: pdfjsLib.PDFDocumentProxy | null = null;
+  let observer: IntersectionObserver | null = null;
+  // Track which pages have been rendered and which are pending
+  let renderedPages = new Set<number>();
+  let renderingPages = new Set<number>();
+
+  const SCALE_STEP = 0.25;
+  const MIN_SCALE = 0.5;
+  const MAX_SCALE = 3.0;
+
+  async function loadPdf(path: string) {
+    loading = true;
+    error = null;
+    cleanup();
+
+    try {
+      const assetUrl = convertFileSrc(path);
+      const loadingTask = pdfjsLib.getDocument(assetUrl);
+      pdfDoc = await loadingTask.promise;
+      pageCount = pdfDoc.numPages;
+      createPlaceholders();
+    } catch (e) {
+      error = `Failed to load PDF: ${e}`;
+      console.warn('PDF load error:', e);
+    } finally {
+      loading = false;
+    }
+  }
+
+  /** Create placeholder divs for each page, observed for lazy rendering */
+  function createPlaceholders() {
+    if (!pdfDoc || !container) return;
+
+    // Clean existing
+    container.innerHTML = '';
+    renderedPages.clear();
+    renderingPages.clear();
+
+    // Stop old observer
+    observer?.disconnect();
+    observer = new IntersectionObserver(onIntersect, {
+      root: container,
+      rootMargin: '200px 0px', // pre-render 200px ahead
+    });
+
+    for (let i = 1; i <= pdfDoc.numPages; i++) {
+      const placeholder = document.createElement('div');
+      placeholder.className = 'pdf-page-slot';
+      placeholder.dataset.page = String(i);
+      // Estimate height from first page viewport (or fallback)
+      placeholder.style.width = '100%';
+      placeholder.style.minHeight = '20rem';
+      container.appendChild(placeholder);
+      observer.observe(placeholder);
+    }
+  }
+
+  function onIntersect(entries: IntersectionObserverEntry[]) {
+    for (const entry of entries) {
+      if (!entry.isIntersecting) continue;
+      const pageNum = Number((entry.target as HTMLElement).dataset.page);
+      if (!pageNum || renderedPages.has(pageNum) || renderingPages.has(pageNum)) continue;
+      renderPage(pageNum, entry.target as HTMLElement);
+    }
+  }
+
+  async function renderPage(pageNum: number, slot: HTMLElement) {
+    if (!pdfDoc) return;
+    renderingPages.add(pageNum);
+
+    try {
+      const page = await pdfDoc.getPage(pageNum);
+      const viewport = page.getViewport({ scale: currentScale * window.devicePixelRatio });
+      const displayViewport = page.getViewport({ scale: currentScale });
+
+      const canvas = document.createElement('canvas');
+      canvas.className = 'pdf-page-canvas';
+      canvas.width = viewport.width;
+      canvas.height = viewport.height;
+      canvas.style.width = `${displayViewport.width}px`;
+      canvas.style.height = `${displayViewport.height}px`;
+
+      // Replace placeholder content with canvas
+      slot.innerHTML = '';
+      slot.style.minHeight = '';
+      slot.appendChild(canvas);
+
+      const ctx = canvas.getContext('2d');
+      if (!ctx) return;
+
+      const task = page.render({ canvasContext: ctx, viewport });
+      await task.promise;
+      renderedPages.add(pageNum);
+
+      // Stop observing once rendered
+      observer?.unobserve(slot);
+    } catch (e: unknown) {
+      if (e && typeof e === 'object' && 'name' in e && (e as { name: string }).name !== 'RenderingCancelledException') {
+        console.warn(`Failed to render page ${pageNum}:`, e);
+      }
+    } finally {
+      renderingPages.delete(pageNum);
+    }
+  }
+
+  function rerender() {
+    renderedPages.clear();
+    renderingPages.clear();
+    createPlaceholders();
+  }
+
+  function zoomIn() {
+    if (currentScale >= MAX_SCALE) return;
+    currentScale = Math.min(MAX_SCALE, currentScale + SCALE_STEP);
+    rerender();
+  }
+
+  function zoomOut() {
+    if (currentScale <= MIN_SCALE) return;
+    currentScale = Math.max(MIN_SCALE, currentScale - SCALE_STEP);
+    rerender();
+  }
+
+  function resetZoom() {
+    currentScale = 1.0;
+    rerender();
+  }
+
+  function cleanup() {
+    observer?.disconnect();
+    observer = null;
+    renderedPages.clear();
+    renderingPages.clear();
+    if (container) container.innerHTML = '';
+    if (pdfDoc) {
+      pdfDoc.destroy();
+      pdfDoc = null;
+    }
+  }
+
+  onMount(() => {
+    loadPdf(filePath);
+  });
+
+  // React to filePath changes
+  let lastPath = $state(filePath);
+  $effect(() => {
+    const p = filePath;
+    if (p !== lastPath) {
+      lastPath = p;
+      loadPdf(p);
+    }
+  });
+
+  onDestroy(() => {
+    cleanup();
+  });
+</script>
+
+<div class="pdf-viewer">
+  <div class="pdf-toolbar">
+    <span class="pdf-info">
+      {#if loading}
+        Loading…
+      {:else if error}
+        Error
+      {:else}
+        {pageCount} page{pageCount !== 1 ? 's' : ''}
+      {/if}
+    </span>
+    <div class="pdf-zoom-controls">
+      <button class="zoom-btn" onclick={zoomOut} disabled={currentScale <= MIN_SCALE} title="Zoom out">−</button>
+      <button class="zoom-label" onclick={resetZoom} title="Reset zoom">{Math.round(currentScale * 100)}%</button>
+      <button class="zoom-btn" onclick={zoomIn} disabled={currentScale >= MAX_SCALE} title="Zoom in">+</button>
+    </div>
+  </div>
+
+  {#if error}
+    <div class="pdf-error">{error}</div>
+  {:else}
+    <div class="pdf-pages" bind:this={container}></div>
+  {/if}
+</div>
+
+<style>
+  .pdf-viewer {
+    display: flex;
+    flex-direction: column;
+    height: 100%;
+    overflow: hidden;
+    background: var(--ctp-crust);
+  }
+
+  .pdf-toolbar {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    padding: 0.25rem 0.625rem;
+    background: var(--ctp-mantle);
+    border-bottom: 1px solid var(--ctp-surface0);
+    flex-shrink: 0;
+  }
+
+  .pdf-info {
+    font-size: 0.7rem;
+    color: var(--ctp-overlay1);
+  }
+
+  .pdf-zoom-controls {
+    display: flex;
+    align-items: center;
+    gap: 0.125rem;
+  }
+
+  .zoom-btn, .zoom-label {
+    background: transparent;
+    border: 1px solid var(--ctp-surface1);
+    color: var(--ctp-subtext0);
+    font-size: 0.7rem;
+    padding: 0.125rem 0.375rem;
+    border-radius: 0.1875rem;
+    cursor: pointer;
+    transition: background 0.12s, color 0.12s;
+  }
+
+  .zoom-btn:hover:not(:disabled), .zoom-label:hover {
+    background: var(--ctp-surface0);
+    color: var(--ctp-text);
+  }
+
+  .zoom-btn:disabled {
+    opacity: 0.4;
+    cursor: default;
+  }
+
+  .zoom-label {
+    min-width: 3rem;
+    text-align: center;
+    font-variant-numeric: tabular-nums;
+  }
+
+  .pdf-pages {
+    flex: 1;
+    overflow: auto;
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    gap: 0.5rem;
+    padding: 0.75rem;
+  }
+
+  .pdf-pages :global(.pdf-page-slot) {
+    display: flex;
+    justify-content: center;
+  }
+
+  .pdf-pages :global(.pdf-page-canvas) {
+    box-shadow: 0 1px 4px color-mix(in srgb, var(--ctp-crust) 60%, transparent);
+    border-radius: 2px;
+  }
+
+  .pdf-error {
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    height: 100%;
+    color: var(--ctp-red);
+    font-size: 0.8rem;
+    padding: 1rem;
+  }
+</style>
diff --git a/v2/src/lib/components/Workspace/ProjectBox.svelte b/v2/src/lib/components/Workspace/ProjectBox.svelte
new file mode 100644
index 0000000..c990edb
--- /dev/null
+++ b/v2/src/lib/components/Workspace/ProjectBox.svelte
@@ -0,0 +1,542 @@
+<script lang="ts">
+  import { onDestroy } from 'svelte';
+  import type { ProjectConfig } from '../../types/groups';
+  import { PROJECT_ACCENTS } from '../../types/groups';
+  import ProjectHeader from './ProjectHeader.svelte';
+  import AgentSession from './AgentSession.svelte';
+  import TerminalTabs from './TerminalTabs.svelte';
+  import TeamAgentsPanel from './TeamAgentsPanel.svelte';
+  import ProjectFiles from './ProjectFiles.svelte';
+  import ContextTab from './ContextTab.svelte';
+  import FilesTab from './FilesTab.svelte';
+  import SshTab from './SshTab.svelte';
+  import MemoriesTab from './MemoriesTab.svelte';
+  import TaskBoardTab from './TaskBoardTab.svelte';
+  import ArchitectureTab from './ArchitectureTab.svelte';
+  import TestingTab from './TestingTab.svelte';
+  import MetricsPanel from './MetricsPanel.svelte';
+  import AuditLogTab from './AuditLogTab.svelte';
+  import {
+    getTerminalTabs, getActiveGroup,
+    getFocusFlashProjectId, onProjectTabSwitch, onTerminalToggle,
+  } from '../../stores/workspace.svelte';
+  import { getProjectHealth, setStallThreshold } from '../../stores/health.svelte';
+  import { fsWatchProject, fsUnwatchProject, onFsWriteDetected, fsWatcherStatus } from '../../adapters/fs-watcher-bridge';
+  import { recordExternalWrite } from '../../stores/conflicts.svelte';
+  import { ProjectId, type AgentId, type GroupId } from '../../types/ids';
+  import { notify, dismissNotification } from '../../stores/notifications.svelte';
+  import { registerManager, unregisterManager, updateManagerConfig } from '../../stores/wake-scheduler.svelte';
+  import { setReviewQueueDepth } from '../../stores/health.svelte';
+  import { reviewQueueCount } from '../../adapters/bttask-bridge';
+  import { getStaleAgents } from '../../adapters/btmsg-bridge';
+
+  interface Props {
+    project: ProjectConfig;
+    slotIndex: number;
+    active: boolean;
+    onactivate: () => void;
+  }
+
+  let { project, slotIndex, active, onactivate }: Props = $props();
+
+  let accentVar = $derived(PROJECT_ACCENTS[slotIndex % PROJECT_ACCENTS.length]);
+  let mainSessionId = $state<string | null>(null);
+  let terminalExpanded = $state(false);
+
+  type ProjectTab = 'model' | 'docs' | 'context' | 'files' | 'ssh' | 'memories' | 'metrics' | 'tasks' | 'architecture' | 'selenium' | 'tests' | 'audit';
+  let activeTab = $state<ProjectTab>('model');
+
+  let activeGroup = $derived(getActiveGroup());
+  let agentRole = $derived(project.agentRole);
+  let isAgent = $derived(project.isAgent ?? false);
+
+  // Heartbeat status for Tier 1 agents
+  let heartbeatStatus = $state<'healthy' | 'stale' | 'dead' | null>(null);
+
+  // PERSISTED-LAZY: track which tabs have been activated at least once
+  let everActivated = $state<Record<string, boolean>>({});
+
+  let termTabs = $derived(getTerminalTabs(project.id));
+  let projectHealth = $derived(getProjectHealth(project.id));
+  let termTabCount = $derived(termTabs.length);
+
+  // Focus flash animation (triggered by keyboard quick-jump)
+  let flashProjectId = $derived(getFocusFlashProjectId());
+  let isFlashing = $derived(flashProjectId === project.id);
+
+  // Tab name -> index mapping for keyboard switching
+  const TAB_INDEX_MAP: ProjectTab[] = [
+    'model',       // 1
+    'docs',        // 2
+    'context',     // 3
+    'files',       // 4
+    'ssh',         // 5
+    'memories',    // 6
+    'metrics',     // 7
+    'tasks',       // 8
+    'architecture',// 9
+  ];
+
+  /** Activate a tab — for lazy tabs, mark as ever-activated */
+  function switchTab(tab: ProjectTab) {
+    activeTab = tab;
+    if (!everActivated[tab]) {
+      everActivated = { ...everActivated, [tab]: true };
+    }
+  }
+
+  function toggleTerminal() {
+    terminalExpanded = !terminalExpanded;
+  }
+
+  // Listen for keyboard-driven tab switches
+  $effect(() => {
+    const unsubTab = onProjectTabSwitch((pid, tabIndex) => {
+      if (pid !== project.id) return;
+      const tabName = TAB_INDEX_MAP[tabIndex - 1];
+      if (tabName) switchTab(tabName);
+    });
+    const unsubTerm = onTerminalToggle((pid) => {
+      if (pid !== project.id) return;
+      terminalExpanded = !terminalExpanded;
+    });
+    return () => {
+      unsubTab();
+      unsubTerm();
+    };
+  });
+
+  // Sync per-project stall threshold to health store
+  $effect(() => {
+    setStallThreshold(project.id, project.stallThresholdMin ?? null);
+  });
+
+  // Register Manager agents with the wake scheduler
+  $effect(() => {
+    if (!(project.isAgent && project.agentRole === 'manager')) return;
+    const groupId = activeGroup?.id;
+    if (!groupId || !mainSessionId) return;
+
+    // Find the agent config to get wake settings
+    const agentConfig = activeGroup?.agents?.find(a => a.id === project.id);
+    const strategy = agentConfig?.wakeStrategy ?? 'smart';
+    const intervalMin = agentConfig?.wakeIntervalMin ?? 3;
+    const threshold = agentConfig?.wakeThreshold ?? 0.5;
+
+    registerManager(
+      project.id as unknown as AgentId,
+      groupId as unknown as GroupId,
+      mainSessionId,
+      strategy,
+      intervalMin,
+      threshold,
+    );
+
+    return () => {
+      unregisterManager(project.id);
+    };
+  });
+
+  // Poll review queue depth for reviewer agents (feeds into attention scoring)
+  $effect(() => {
+    if (!(project.isAgent && project.agentRole === 'reviewer')) return;
+    const groupId = activeGroup?.id;
+    if (!groupId) return;
+
+    const pollReviewQueue = () => {
+      reviewQueueCount(groupId)
+        .then(count => setReviewQueueDepth(project.id, count))
+        .catch(() => {}); // best-effort
+    };
+
+    pollReviewQueue(); // immediate first poll
+    const timer = setInterval(pollReviewQueue, 10_000); // 10s poll
+    return () => clearInterval(timer);
+  });
+
+  // Heartbeat monitoring for Tier 1 agents
+  $effect(() => {
+    if (!project.isAgent) return;
+    const groupId = activeGroup?.id;
+    if (!groupId) return;
+
+    const pollHeartbeat = () => {
+      // 300s = healthy threshold, 600s = dead threshold
+      getStaleAgents(groupId as unknown as GroupId, 300)
+        .then(staleIds => {
+          if (staleIds.includes(project.id)) {
+            // Check if truly dead (>10 min)
+            getStaleAgents(groupId as unknown as GroupId, 600)
+              .then(deadIds => {
+                heartbeatStatus = deadIds.includes(project.id) ? 'dead' : 'stale';
+              })
+              .catch(() => { heartbeatStatus = 'stale'; });
+          } else {
+            heartbeatStatus = 'healthy';
+          }
+        })
+        .catch(() => { heartbeatStatus = null; });
+    };
+
+    pollHeartbeat();
+    const timer = setInterval(pollHeartbeat, 15_000); // 15s poll
+    return () => clearInterval(timer);
+  });
+
+  // S-1 Phase 2: start filesystem watcher for this project's CWD
+  $effect(() => {
+    const cwd = project.cwd;
+    const projectId = project.id;
+    if (!cwd) return;
+
+    // Start watching, then check inotify capacity
+    // Show scanning toast only if status check takes >300ms
+    let scanToastId: string | null = null;
+    const scanTimer = setTimeout(() => {
+      scanToastId = notify('info', 'Scanning project directories…');
+    }, 300);
+
+    fsWatchProject(projectId, cwd)
+      .then(() => fsWatcherStatus())
+      .then((status) => {
+        clearTimeout(scanTimer);
+        if (scanToastId) dismissNotification(scanToastId);
+        if (status.warning) {
+          notify('warning', status.warning);
+        }
+      })
+      .catch(e => {
+        clearTimeout(scanTimer);
+        if (scanToastId) dismissNotification(scanToastId);
+        console.warn(`Failed to start fs watcher for ${projectId}:`, e);
+      });
+
+    // Listen for fs write events (filter to this project)
+    let unlisten: (() => void) | null = null;
+    onFsWriteDetected((event) => {
+      if (event.project_id !== projectId) return;
+      const isNew = recordExternalWrite(ProjectId(projectId), event.file_path, event.timestamp_ms);
+      if (isNew) {
+        const shortName = event.file_path.split('/').pop() ?? event.file_path;
+        notify('warning', `External write: ${shortName} — file also modified by agent`);
+      }
+    }).then(fn => { unlisten = fn; });
+
+    return () => {
+      // Cleanup: stop watching on unmount or project change
+      fsUnwatchProject(projectId).catch(() => {});
+      unlisten?.();
+    };
+  });
+</script>
+
+<div
+  class="project-box"
+  class:active
+  class:focus-flash={isFlashing}
+  style="--accent: var({accentVar})"
+  data-testid="project-box"
+  data-project-id={project.id}
+>
+  <ProjectHeader
+    {project}
+    {slotIndex}
+    {active}
+    health={projectHealth}
+    {heartbeatStatus}
+    onclick={onactivate}
+  />
+
+  <div class="project-tabs" data-testid="project-tabs">
+    <button
+      class="ptab"
+      class:active={activeTab === 'model'}
+      onclick={() => switchTab('model')}
+    >Model</button>
+    <button
+      class="ptab"
+      class:active={activeTab === 'docs'}
+      onclick={() => switchTab('docs')}
+    >Docs</button>
+    <button
+      class="ptab"
+      class:active={activeTab === 'context'}
+      onclick={() => switchTab('context')}
+    >Context</button>
+    <button
+      class="ptab"
+      class:active={activeTab === 'files'}
+      onclick={() => switchTab('files')}
+    >Files</button>
+    <button
+      class="ptab"
+      class:active={activeTab === 'ssh'}
+      onclick={() => switchTab('ssh')}
+    >SSH</button>
+    <button
+      class="ptab"
+      class:active={activeTab === 'memories'}
+      onclick={() => switchTab('memories')}
+    >Memory</button>
+    <button
+      class="ptab"
+      class:active={activeTab === 'metrics'}
+      onclick={() => switchTab('metrics')}
+    >Metrics</button>
+    {#if isAgent && agentRole === 'manager'}
+      <button class="ptab ptab-role" class:active={activeTab === 'tasks'} onclick={() => switchTab('tasks')}>Tasks</button>
+    {/if}
+    {#if isAgent && agentRole === 'architect'}
+      <button class="ptab ptab-role" class:active={activeTab === 'architecture'} onclick={() => switchTab('architecture')}>Arch</button>
+    {/if}
+    {#if isAgent && agentRole === 'reviewer'}
+      <button class="ptab ptab-role" class:active={activeTab === 'tasks'} onclick={() => switchTab('tasks')}>Tasks</button>
+    {/if}
+    {#if isAgent && agentRole === 'tester'}
+      <button class="ptab ptab-role" class:active={activeTab === 'selenium'} onclick={() => switchTab('selenium')}>Selenium</button>
+      <button class="ptab ptab-role" class:active={activeTab === 'tests'} onclick={() => switchTab('tests')}>Tests</button>
+    {/if}
+    {#if isAgent && agentRole === 'manager'}
+      <button class="ptab ptab-role" class:active={activeTab === 'audit'} onclick={() => switchTab('audit')}>Audit</button>
+    {/if}
+  </div>
+
+  <div class="project-content-area">
+    <!-- PERSISTED-EAGER: always mounted, toggled via display -->
+    <div class="content-pane" style:display={activeTab === 'model' ? 'flex' : 'none'}>
+      <AgentSession {project} onsessionid={(id) => mainSessionId = id} />
+      {#if mainSessionId}
+        <TeamAgentsPanel {mainSessionId} />
+      {/if}
+    </div>
+    <div class="content-pane" style:display={activeTab === 'docs' ? 'flex' : 'none'}>
+      <ProjectFiles cwd={project.cwd} projectName={project.name} />
+    </div>
+    <div class="content-pane" style:display={activeTab === 'context' ? 'flex' : 'none'}>
+      <ContextTab sessionId={mainSessionId} projectId={project.id} anchorBudgetScale={project.anchorBudgetScale} />
+    </div>
+
+    <!-- PERSISTED-LAZY: mount on first activation, then toggle via display -->
+    {#if everActivated['files']}
+      <div class="content-pane" style:display={activeTab === 'files' ? 'flex' : 'none'}>
+        <FilesTab cwd={project.cwd} />
+      </div>
+    {/if}
+    {#if everActivated['ssh']}
+      <div class="content-pane" style:display={activeTab === 'ssh' ? 'flex' : 'none'}>
+        <SshTab projectId={project.id} />
+      </div>
+    {/if}
+    {#if everActivated['memories']}
+      <div class="content-pane" style:display={activeTab === 'memories' ? 'flex' : 'none'}>
+        <MemoriesTab />
+      </div>
+    {/if}
+    {#if everActivated['metrics']}
+      <div class="content-pane" style:display={activeTab === 'metrics' ? 'flex' : 'none'}>
+        <MetricsPanel {project} groupId={activeGroup?.id} />
+      </div>
+    {/if}
+    {#if everActivated['tasks'] && activeGroup}
+      <div class="content-pane" style:display={activeTab === 'tasks' ? 'flex' : 'none'}>
+        <TaskBoardTab groupId={activeGroup.id} projectId={project.id} />
+      </div>
+    {/if}
+    {#if everActivated['architecture']}
+      <div class="content-pane" style:display={activeTab === 'architecture' ? 'flex' : 'none'}>
+        <ArchitectureTab cwd={project.cwd} />
+      </div>
+    {/if}
+    {#if everActivated['selenium']}
+      <div class="content-pane" style:display={activeTab === 'selenium' ? 'flex' : 'none'}>
+        <TestingTab cwd={project.cwd} mode="selenium" />
+      </div>
+    {/if}
+    {#if everActivated['tests']}
+      <div class="content-pane" style:display={activeTab === 'tests' ? 'flex' : 'none'}>
+        <TestingTab cwd={project.cwd} mode="tests" />
+      </div>
+    {/if}
+    {#if everActivated['audit'] && activeGroup}
+      <div class="content-pane" style:display={activeTab === 'audit' ? 'flex' : 'none'}>
+        <AuditLogTab groupId={activeGroup.id} />
+      </div>
+    {/if}
+  </div>
+
+  <div class="terminal-section" style:display={activeTab === 'model' ? 'flex' : 'none'}>
+      <button class="terminal-toggle" data-testid="terminal-toggle" onclick={toggleTerminal}>
+        <span class="toggle-chevron" class:expanded={terminalExpanded}>
+          <svg width="10" height="10" viewBox="0 0 10 10" fill="none">
+            <path d="M3 2l4 3-4 3" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/>
+          </svg>
+        </span>
+        <span class="toggle-label">Terminal</span>
+        {#if termTabCount > 0}
+          <span class="toggle-count">{termTabCount}</span>
+        {/if}
+      </button>
+
+      {#if terminalExpanded}
+        <div class="project-terminal-area">
+          <TerminalTabs {project} agentSessionId={mainSessionId} />
+        </div>
+      {/if}
+  </div>
+</div>
+
+<style>
+  .project-box {
+    display: grid;
+    grid-template-rows: auto auto 1fr auto;
+    min-width: 30rem;
+    scroll-snap-align: start;
+    background: var(--ctp-base);
+    border: 1px solid var(--ctp-surface0);
+    border-radius: 0.375rem;
+    overflow: hidden;
+    transition: border-color 0.15s;
+  }
+
+  .project-box.active {
+    border-color: var(--accent);
+  }
+
+  .project-box.focus-flash {
+    animation: focus-flash 0.4s ease-out;
+  }
+
+  @keyframes focus-flash {
+    0% {
+      border-color: var(--ctp-blue);
+      box-shadow: 0 0 0 2px color-mix(in srgb, var(--ctp-blue) 40%, transparent);
+    }
+    100% {
+      border-color: var(--accent);
+      box-shadow: none;
+    }
+  }
+
+  .project-tabs {
+    display: flex;
+    gap: 0;
+    background: var(--ctp-mantle);
+    border-bottom: 1px solid var(--ctp-surface0);
+    flex-shrink: 0;
+    overflow-x: auto;
+    scrollbar-width: none;
+  }
+
+  .ptab {
+    display: inline-flex;
+    align-items: center;
+    padding: 0.3125em 0.875em;
+    border: none;
+    border-top: 2px solid transparent;
+    border-bottom: 2px solid transparent;
+    background: transparent;
+    color: var(--ctp-overlay1);
+    font-size: 0.725rem;
+    font-weight: 500;
+    letter-spacing: 0.05em;
+    text-transform: uppercase;
+    cursor: pointer;
+    transition: color 0.12s ease, background 0.12s ease, border-color 0.12s ease;
+  }
+
+  .ptab:hover {
+    color: var(--ctp-subtext1);
+    background: var(--ctp-surface0);
+  }
+
+  .ptab:focus-visible {
+    outline: 1px solid var(--ctp-blue);
+    outline-offset: -1px;
+  }
+
+  .ptab.active {
+    background: var(--ctp-base);
+    color: var(--ctp-text);
+    font-weight: 600;
+    border-bottom-color: var(--accent);
+    margin-bottom: -1px;
+  }
+
+  .ptab-role {
+    color: var(--ctp-mauve);
+  }
+
+  .ptab-role:hover {
+    color: var(--ctp-text);
+  }
+
+  .project-content-area {
+    overflow: hidden;
+    position: relative;
+    min-height: 0;
+  }
+
+  .content-pane {
+    display: flex;
+    height: 100%;
+    overflow: hidden;
+  }
+
+  .terminal-section {
+    border-top: 1px solid var(--ctp-surface0);
+    display: flex;
+    flex-direction: column;
+  }
+
+  .terminal-toggle {
+    display: flex;
+    align-items: center;
+    gap: 0.375rem;
+    padding: 0.25rem 0.625rem;
+    background: var(--ctp-mantle);
+    border: none;
+    color: var(--ctp-overlay1);
+    font-size: 0.7rem;
+    font-weight: 500;
+    cursor: pointer;
+    text-align: left;
+    transition: color 0.12s, background 0.12s;
+    flex-shrink: 0;
+  }
+
+  .terminal-toggle:hover {
+    color: var(--ctp-text);
+    background: var(--ctp-surface0);
+  }
+
+  .toggle-chevron {
+    display: flex;
+    align-items: center;
+    transition: transform 0.15s ease;
+  }
+
+  .toggle-chevron.expanded {
+    transform: rotate(90deg);
+  }
+
+  .toggle-label {
+    text-transform: uppercase;
+    letter-spacing: 0.05em;
+  }
+
+  .toggle-count {
+    font-size: 0.6rem;
+    color: var(--ctp-overlay0);
+    background: var(--ctp-surface0);
+    padding: 0 0.3rem;
+    border-radius: 0.5rem;
+    line-height: 1.4;
+    min-width: 1rem;
+    text-align: center;
+  }
+
+  .project-terminal-area {
+    height: 16rem;
+    min-height: 8rem;
+  }
+</style>
diff --git a/v2/src/lib/components/Workspace/ProjectFiles.svelte b/v2/src/lib/components/Workspace/ProjectFiles.svelte
new file mode 100644
index 0000000..1d3d806
--- /dev/null
+++ b/v2/src/lib/components/Workspace/ProjectFiles.svelte
@@ -0,0 +1,152 @@
+<script lang="ts">
+  import { discoverMarkdownFiles, type MdFileEntry } from '../../adapters/groups-bridge';
+  import MarkdownPane from '../Markdown/MarkdownPane.svelte';
+
+  interface Props {
+    cwd: string;
+    projectName: string;
+  }
+
+  let { cwd, projectName }: Props = $props();
+
+  let files = $state<MdFileEntry[]>([]);
+  let selectedPath = $state<string | null>(null);
+  let loading = $state(false);
+
+  $effect(() => {
+    loadFiles(cwd);
+  });
+
+  function handleNavigate(absolutePath: string) {
+    // If the file is in our discovered list, select it directly
+    const match = files.find(f => f.path === absolutePath);
+    if (match) {
+      selectedPath = absolutePath;
+    } else {
+      // File not in sidebar — set it directly (MarkdownPane handles loading)
+      selectedPath = absolutePath;
+    }
+  }
+
+  async function loadFiles(dir: string) {
+    loading = true;
+    try {
+      files = await discoverMarkdownFiles(dir);
+      const priority = files.find(f => f.priority);
+      selectedPath = priority?.path ?? files[0]?.path ?? null;
+    } catch (e) {
+      console.warn('Failed to discover markdown files:', e);
+      files = [];
+    } finally {
+      loading = false;
+    }
+  }
+</script>
+
+<div class="project-files">
+  <aside class="file-picker">
+    {#if loading}
+      <div class="state-msg">Scanning...</div>
+    {:else if files.length === 0}
+      <div class="state-msg">No files found</div>
+    {:else}
+      <ul class="file-list">
+        {#each files as file}
+          <li>
+            <button
+              class="file-btn"
+              class:active={selectedPath === file.path}
+              class:priority={file.priority}
+              onclick={() => (selectedPath = file.path)}
+            >
+              {file.name}
+            </button>
+          </li>
+        {/each}
+      </ul>
+    {/if}
+  </aside>
+
+  <main class="doc-content">
+    {#if selectedPath}
+      <MarkdownPane paneId="pf-{projectName}" filePath={selectedPath} onNavigate={handleNavigate} />
+    {:else}
+      <div class="state-msg full">Select a file</div>
+    {/if}
+  </main>
+</div>
+
+<style>
+  .project-files {
+    display: flex;
+    height: 100%;
+    overflow: hidden;
+    flex: 1;
+  }
+
+  .file-picker {
+    width: 10rem;
+    flex-shrink: 0;
+    background: var(--ctp-mantle);
+    border-right: 1px solid var(--ctp-surface0);
+    overflow-y: auto;
+    padding: 0.25rem 0;
+  }
+
+  .file-list {
+    list-style: none;
+    margin: 0;
+    padding: 0;
+  }
+
+  .file-btn {
+    display: block;
+    width: 100%;
+    padding: 0.2rem 0.5rem;
+    background: transparent;
+    border: none;
+    color: var(--ctp-subtext0);
+    font-size: 0.72rem;
+    text-align: left;
+    cursor: pointer;
+    transition: color 0.1s, background 0.1s;
+    white-space: nowrap;
+    overflow: hidden;
+    text-overflow: ellipsis;
+  }
+
+  .file-btn:hover {
+    background: var(--ctp-surface0);
+    color: var(--ctp-text);
+  }
+
+  .file-btn.active {
+    background: var(--ctp-surface0);
+    color: var(--ctp-text);
+    font-weight: 600;
+  }
+
+  .file-btn.priority {
+    color: var(--ctp-blue);
+  }
+
+  .doc-content {
+    flex: 1;
+    overflow: auto;
+    min-width: 0;
+  }
+
+  .state-msg {
+    color: var(--ctp-overlay0);
+    font-size: 0.75rem;
+    padding: 0.75rem 0.5rem;
+    text-align: center;
+  }
+
+  .state-msg.full {
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    height: 100%;
+  }
+</style>
diff --git a/v2/src/lib/components/Workspace/ProjectGrid.svelte b/v2/src/lib/components/Workspace/ProjectGrid.svelte
new file mode 100644
index 0000000..e8b6da2
--- /dev/null
+++ b/v2/src/lib/components/Workspace/ProjectGrid.svelte
@@ -0,0 +1,86 @@
+<script lang="ts">
+  import { onMount, onDestroy } from 'svelte';
+  import { getAllWorkItems, getActiveProjectId, setActiveProject } from '../../stores/workspace.svelte';
+  import ProjectBox from './ProjectBox.svelte';
+
+  let containerEl: HTMLDivElement | undefined = $state();
+  let containerWidth = $state(0);
+
+  let projects = $derived(getAllWorkItems());
+  let activeProjectId = $derived(getActiveProjectId());
+  let visibleCount = $derived(
+    Math.min(projects.length, Math.max(1, Math.floor(containerWidth / 520))),
+  );
+
+  let observer: ResizeObserver | undefined;
+
+  onMount(() => {
+    if (containerEl) {
+      containerWidth = containerEl.clientWidth;
+      observer = new ResizeObserver(entries => {
+        for (const entry of entries) {
+          containerWidth = entry.contentRect.width;
+        }
+      });
+      observer.observe(containerEl);
+    }
+  });
+
+  onDestroy(() => {
+    observer?.disconnect();
+  });
+</script>
+
+<div
+  class="project-grid"
+  bind:this={containerEl}
+  style="--visible-count: {visibleCount}"
+>
+  {#each projects as project, i (project.id)}
+    <div class="project-slot">
+      <ProjectBox
+        {project}
+        slotIndex={i}
+        active={activeProjectId === project.id}
+        onactivate={() => setActiveProject(project.id)}
+      />
+    </div>
+  {/each}
+
+  {#if projects.length === 0}
+    <div class="empty-state">
+      No enabled projects in this group. Go to Settings to add projects.
+    </div>
+  {/if}
+</div>
+
+<style>
+  .project-grid {
+    display: flex;
+    gap: 0.25rem;
+    height: 100%;
+    overflow-x: auto;
+    scroll-snap-type: x mandatory;
+    padding: 0.25rem;
+  }
+
+  .project-slot {
+    flex: 0 0 calc((100% - (var(--visible-count) - 1) * 0.25rem) / var(--visible-count));
+    min-width: 30rem;
+    max-width: calc(100vh * var(--project-max-aspect, 1));
+    display: flex;
+  }
+
+  .project-slot > :global(*) {
+    flex: 1;
+  }
+
+  .empty-state {
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    width: 100%;
+    color: var(--ctp-overlay0);
+    font-size: 0.9rem;
+  }
+</style>
diff --git a/v2/src/lib/components/Workspace/ProjectHeader.svelte b/v2/src/lib/components/Workspace/ProjectHeader.svelte
new file mode 100644
index 0000000..2e3b9ff
--- /dev/null
+++ b/v2/src/lib/components/Workspace/ProjectHeader.svelte
@@ -0,0 +1,321 @@
+<script lang="ts">
+  import type { ProjectConfig } from '../../types/groups';
+  import { PROJECT_ACCENTS } from '../../types/groups';
+  import type { ProjectHealth } from '../../stores/health.svelte';
+  import { acknowledgeConflicts } from '../../stores/conflicts.svelte';
+  import { ProjectId } from '../../types/ids';
+
+  interface Props {
+    project: ProjectConfig;
+    slotIndex: number;
+    active: boolean;
+    health: ProjectHealth | null;
+    /** Heartbeat status for Tier 1 agents: 'healthy' | 'stale' | 'dead' | null */
+    heartbeatStatus?: 'healthy' | 'stale' | 'dead' | null;
+    onclick: () => void;
+  }
+
+  let { project, slotIndex, active, health, heartbeatStatus = null, onclick }: Props = $props();
+
+  let accentVar = $derived(PROJECT_ACCENTS[slotIndex % PROJECT_ACCENTS.length]);
+
+  /** Shorten home dir for display */
+  let displayCwd = $derived(() => {
+    const home = '/home/';
+    const cwd = project.cwd || '~';
+    if (cwd.startsWith(home)) {
+      const afterHome = cwd.slice(home.length);
+      const slashIdx = afterHome.indexOf('/');
+      if (slashIdx >= 0) return '~' + afterHome.slice(slashIdx);
+      return '~';
+    }
+    return cwd;
+  });
+
+  let statusDotClass = $derived(() => {
+    if (!health) return 'dot-inactive';
+    switch (health.activityState) {
+      case 'running': return 'dot-running';
+      case 'idle': return 'dot-idle';
+      case 'stalled': return 'dot-stalled';
+      default: return 'dot-inactive';
+    }
+  });
+
+  let statusTooltip = $derived(() => {
+    if (!health) return 'No active session';
+    switch (health.activityState) {
+      case 'running': return health.activeTool ? `Running: ${health.activeTool}` : 'Running';
+      case 'idle': {
+        const secs = Math.floor(health.idleDurationMs / 1000);
+        return secs < 60 ? `Idle (${secs}s)` : `Idle (${Math.floor(secs / 60)}m ${secs % 60}s)`;
+      }
+      case 'stalled': {
+        const mins = Math.floor(health.idleDurationMs / 60_000);
+        return `Stalled — ${mins} min since last activity`;
+      }
+      default: return 'Inactive';
+    }
+  });
+
+  let contextPct = $derived(health?.contextPressure !== null && health?.contextPressure !== undefined
+    ? Math.round(health.contextPressure * 100)
+    : null);
+
+  let ctxColor = $derived(() => {
+    if (contextPct === null) return '';
+    if (contextPct > 90) return 'var(--ctp-red)';
+    if (contextPct > 75) return 'var(--ctp-peach)';
+    if (contextPct > 50) return 'var(--ctp-yellow)';
+    return 'var(--ctp-overlay0)';
+  });
+</script>
+
+<button
+  class="project-header"
+  class:active
+  style="--accent: var({accentVar})"
+  {onclick}
+>
+  <div class="header-main">
+    <span class="status-dot {statusDotClass()}" title={statusTooltip()}></span>
+    <span class="project-icon">{project.icon || '📁'}</span>
+    <span class="project-name">{project.name}</span>
+    <span class="project-id">({project.identifier})</span>
+  </div>
+  <div class="header-info">
+    {#if heartbeatStatus && project.isAgent}
+      <span
+        class="info-heartbeat"
+        class:hb-healthy={heartbeatStatus === 'healthy'}
+        class:hb-stale={heartbeatStatus === 'stale'}
+        class:hb-dead={heartbeatStatus === 'dead'}
+        title={heartbeatStatus === 'healthy' ? 'Agent healthy' : heartbeatStatus === 'stale' ? 'Agent stale — no heartbeat recently' : 'Agent dead — no heartbeat'}
+      >
+        {heartbeatStatus === 'healthy' ? '♥' : heartbeatStatus === 'stale' ? '♥' : '♡'}
+      </span>
+      <span class="info-sep">·</span>
+    {/if}
+    {#if health && health.externalConflictCount > 0}
+      <button
+        class="info-conflict info-conflict-external"
+        title="{health.externalConflictCount} external write{health.externalConflictCount > 1 ? 's' : ''} — files modified outside agent — click to dismiss"
+        onclick={(e: MouseEvent) => { e.stopPropagation(); acknowledgeConflicts(ProjectId(project.id)); }}
+      >
+        ⚡ {health.externalConflictCount} ext write{health.externalConflictCount > 1 ? 's' : ''} ✕
+      </button>
+      <span class="info-sep">·</span>
+    {/if}
+    {#if health && health.fileConflictCount - (health.externalConflictCount ?? 0) > 0}
+      <button
+        class="info-conflict"
+        title="{health.fileConflictCount - (health.externalConflictCount ?? 0)} agent conflict{health.fileConflictCount - (health.externalConflictCount ?? 0) > 1 ? 's' : ''} — click to dismiss"
+        onclick={(e: MouseEvent) => { e.stopPropagation(); acknowledgeConflicts(ProjectId(project.id)); }}
+      >
+        ⚠ {health.fileConflictCount - (health.externalConflictCount ?? 0)} conflict{health.fileConflictCount - (health.externalConflictCount ?? 0) > 1 ? 's' : ''} ✕
+      </button>
+      <span class="info-sep">·</span>
+    {/if}
+    {#if contextPct !== null && contextPct > 0}
+      <span class="info-ctx" style="color: {ctxColor()}" title="Context window usage">ctx {contextPct}%</span>
+      <span class="info-sep">·</span>
+    {/if}
+    {#if health && health.burnRatePerHour > 0.01}
+      <span class="info-rate" title="Burn rate">
+        ${health.burnRatePerHour < 1 ? health.burnRatePerHour.toFixed(2) : health.burnRatePerHour.toFixed(1)}/hr
+      </span>
+      <span class="info-sep">·</span>
+    {/if}
+    <span class="info-cwd" title={project.cwd}>{displayCwd()}</span>
+    {#if project.profile}
+      <span class="info-sep">·</span>
+      <span class="info-profile" title={project.profile}>{project.profile}</span>
+    {/if}
+  </div>
+</button>
+
+<style>
+  .project-header {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    gap: 0.5rem;
+    padding: 0.375rem 0.625rem;
+    background: var(--ctp-mantle);
+    border: none;
+    border-bottom: 2px solid transparent;
+    color: var(--ctp-subtext0);
+    font-size: 0.78rem;
+    cursor: pointer;
+    flex-shrink: 0;
+    width: 100%;
+    text-align: left;
+    transition: color 0.15s, border-color 0.15s;
+  }
+
+  .project-header:hover {
+    color: var(--ctp-text);
+  }
+
+  .project-header.active {
+    color: var(--ctp-text);
+    border-bottom-color: var(--accent);
+  }
+
+  .header-main {
+    display: flex;
+    align-items: center;
+    gap: 0.375rem;
+    min-width: 0;
+    flex-shrink: 0;
+  }
+
+  /* Status dot */
+  .status-dot {
+    width: 6px;
+    height: 6px;
+    border-radius: 50%;
+    flex-shrink: 0;
+  }
+
+  .dot-inactive {
+    background: var(--ctp-surface2);
+  }
+
+  .dot-running {
+    background: var(--ctp-green);
+    animation: pulse 1.5s ease-in-out infinite;
+  }
+
+  .dot-idle {
+    background: var(--ctp-overlay0);
+  }
+
+  .dot-stalled {
+    background: var(--ctp-peach);
+    animation: pulse 1s ease-in-out infinite;
+  }
+
+  @keyframes pulse {
+    0%, 100% { opacity: 1; }
+    50% { opacity: 0.3; }
+  }
+
+  .project-icon {
+    font-size: 0.85rem;
+    line-height: 1;
+    flex-shrink: 0;
+  }
+
+  .project-name {
+    font-weight: 600;
+    white-space: nowrap;
+  }
+
+  .project-id {
+    color: var(--ctp-overlay0);
+    font-size: 0.7rem;
+    white-space: nowrap;
+  }
+
+  .header-info {
+    display: flex;
+    align-items: center;
+    gap: 0.25rem;
+    min-width: 0;
+    flex-shrink: 1;
+    overflow: hidden;
+  }
+
+  .info-ctx {
+    font-size: 0.6rem;
+    font-weight: 600;
+    font-family: var(--font-mono, monospace);
+    white-space: nowrap;
+  }
+
+  .info-rate {
+    font-size: 0.6rem;
+    color: var(--ctp-mauve);
+    font-family: var(--font-mono, monospace);
+    white-space: nowrap;
+  }
+
+  .info-cwd {
+    font-size: 0.65rem;
+    color: var(--ctp-overlay0);
+    font-family: var(--font-mono, monospace);
+    white-space: nowrap;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    direction: rtl;
+    text-align: left;
+    unicode-bidi: plaintext;
+    max-width: 12rem;
+  }
+
+  .info-sep {
+    color: var(--ctp-surface2);
+    font-size: 0.6rem;
+    flex-shrink: 0;
+  }
+
+  .info-conflict {
+    font-size: 0.6rem;
+    color: var(--ctp-red);
+    font-weight: 600;
+    white-space: nowrap;
+    background: color-mix(in srgb, var(--ctp-red) 12%, transparent);
+    padding: 0.0625rem 0.375rem;
+    border-radius: 0.1875rem;
+    border: none;
+    cursor: pointer;
+    font-family: inherit;
+    line-height: inherit;
+  }
+
+  .info-conflict:hover {
+    background: color-mix(in srgb, var(--ctp-red) 25%, transparent);
+  }
+
+  .info-conflict-external {
+    color: var(--ctp-peach);
+    background: color-mix(in srgb, var(--ctp-peach) 12%, transparent);
+  }
+
+  .info-conflict-external:hover {
+    background: color-mix(in srgb, var(--ctp-peach) 25%, transparent);
+  }
+
+  .info-heartbeat {
+    font-size: 0.65rem;
+    font-weight: 600;
+    white-space: nowrap;
+  }
+
+  .hb-healthy {
+    color: var(--ctp-green);
+  }
+
+  .hb-stale {
+    color: var(--ctp-yellow);
+    animation: pulse 1.5s ease-in-out infinite;
+  }
+
+  .hb-dead {
+    color: var(--ctp-red);
+  }
+
+  .info-profile {
+    font-size: 0.65rem;
+    color: var(--ctp-blue);
+    font-weight: 600;
+    white-space: nowrap;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    max-width: 8rem;
+    background: color-mix(in srgb, var(--ctp-blue) 10%, transparent);
+    padding: 0.0625rem 0.375rem;
+    border-radius: 0.1875rem;
+  }
+</style>
diff --git a/v2/src/lib/components/Workspace/SearchOverlay.svelte b/v2/src/lib/components/Workspace/SearchOverlay.svelte
new file mode 100644
index 0000000..8285503
--- /dev/null
+++ b/v2/src/lib/components/Workspace/SearchOverlay.svelte
@@ -0,0 +1,350 @@
+<script lang="ts">
+  import { onMount } from 'svelte';
+  import { searchAll, type SearchResult } from '../../adapters/search-bridge';
+  import { setActiveProject } from '../../stores/workspace.svelte';
+
+  interface Props {
+    open: boolean;
+    onclose: () => void;
+  }
+
+  let { open, onclose }: Props = $props();
+
+  let query = $state('');
+  let results = $state<SearchResult[]>([]);
+  let loading = $state(false);
+  let inputEl: HTMLInputElement | undefined = $state();
+  let debounceTimer: ReturnType<typeof setTimeout> | null = null;
+
+  // Group results by type
+  let groupedResults = $derived(() => {
+    const groups = new Map<string, SearchResult[]>();
+    for (const r of results) {
+      const key = r.resultType;
+      if (!groups.has(key)) groups.set(key, []);
+      groups.get(key)!.push(r);
+    }
+    return groups;
+  });
+
+  const TYPE_LABELS: Record<string, string> = {
+    message: 'Messages',
+    task: 'Tasks',
+    btmsg: 'Communications',
+  };
+
+  const TYPE_ICONS: Record<string, string> = {
+    message: '\u{1F4AC}',  // speech balloon
+    task: '\u{2611}',       // ballot box with check
+    btmsg: '\u{1F4E8}',    // incoming envelope
+  };
+
+  $effect(() => {
+    if (open && inputEl) {
+      // Auto-focus when opened
+      requestAnimationFrame(() => inputEl?.focus());
+    }
+    if (!open) {
+      query = '';
+      results = [];
+      loading = false;
+    }
+  });
+
+  function handleInput(e: Event) {
+    query = (e.target as HTMLInputElement).value;
+    if (debounceTimer) clearTimeout(debounceTimer);
+
+    if (!query.trim()) {
+      results = [];
+      loading = false;
+      return;
+    }
+
+    loading = true;
+    debounceTimer = setTimeout(async () => {
+      try {
+        results = await searchAll(query, 30);
+      } catch {
+        results = [];
+      } finally {
+        loading = false;
+      }
+    }, 300);
+  }
+
+  function handleKeydown(e: KeyboardEvent) {
+    if (e.key === 'Escape') {
+      e.preventDefault();
+      onclose();
+    }
+  }
+
+  function handleBackdropClick(e: MouseEvent) {
+    if ((e.target as HTMLElement).classList.contains('search-backdrop')) {
+      onclose();
+    }
+  }
+
+  function handleResultClick(result: SearchResult) {
+    // Navigate based on result type
+    if (result.resultType === 'message') {
+      // result.id is session_id — focus the project that owns it
+      setActiveProject(result.id);
+    } else if (result.resultType === 'task') {
+      // result.id is task_id — no direct project mapping, but close overlay
+    } else if (result.resultType === 'btmsg') {
+      // result.id is message_id — no direct navigation, but close overlay
+    }
+    onclose();
+  }
+
+  function highlightSnippet(snippet: string): string {
+    // The Rust backend wraps matches in <b>...</b>
+    // We sanitize everything else but preserve <b> tags
+    return snippet
+      .replace(/&/g, '&amp;')
+      .replace(/</g, '&lt;')
+      .replace(/>/g, '&gt;')
+      .replace(/&lt;b&gt;/g, '<mark>')
+      .replace(/&lt;\/b&gt;/g, '</mark>');
+  }
+
+  function formatScore(score: number): string {
+    return score.toFixed(1);
+  }
+</script>
+
+{#if open}
+  <!-- svelte-ignore a11y_click_events_have_key_events -->
+  <!-- svelte-ignore a11y_no_static_element_interactions -->
+  <div class="search-backdrop" onclick={handleBackdropClick}>
+    <div class="search-overlay" onkeydown={handleKeydown}>
+      <div class="search-input-row">
+        <svg class="search-icon" width="16" height="16" viewBox="0 0 24 24" fill="none">
+          <circle cx="11" cy="11" r="7" stroke="currentColor" stroke-width="2"/>
+          <path d="M16 16l4.5 4.5" stroke="currentColor" stroke-width="2" stroke-linecap="round"/>
+        </svg>
+        <input
+          bind:this={inputEl}
+          class="search-input"
+          type="text"
+          value={query}
+          oninput={handleInput}
+          placeholder="Search across sessions, tasks, and messages..."
+          spellcheck="false"
+        />
+        {#if loading}
+          <div class="search-spinner"></div>
+        {/if}
+        <kbd class="search-kbd">Esc</kbd>
+      </div>
+
+      <div class="search-results">
+        {#if results.length === 0 && !loading && query.trim()}
+          <div class="search-empty">No results for "{query}"</div>
+        {:else if results.length === 0 && !loading}
+          <div class="search-empty">Search across sessions, tasks, and messages</div>
+        {:else}
+          {#each [...groupedResults()] as [type, items] (type)}
+            <div class="result-group">
+              <div class="result-group-header">
+                <span class="group-icon">{TYPE_ICONS[type] ?? '?'}</span>
+                <span class="group-label">{TYPE_LABELS[type] ?? type}</span>
+                <span class="group-count">{items.length}</span>
+              </div>
+              {#each items as item (item.id + item.snippet)}
+                <button class="result-item" onclick={() => handleResultClick(item)}>
+                  <div class="result-main">
+                    <span class="result-title">{item.title}</span>
+                    <span class="result-snippet">{@html highlightSnippet(item.snippet)}</span>
+                  </div>
+                  <span class="result-score">{formatScore(item.score)}</span>
+                </button>
+              {/each}
+            </div>
+          {/each}
+        {/if}
+      </div>
+    </div>
+  </div>
+{/if}
+
+<style>
+  .search-backdrop {
+    position: fixed;
+    inset: 0;
+    background: color-mix(in srgb, var(--ctp-crust) 70%, transparent);
+    z-index: 1000;
+    display: flex;
+    align-items: flex-start;
+    justify-content: center;
+    padding-top: 12vh;
+  }
+
+  .search-overlay {
+    width: 37.5rem;
+    max-height: 60vh;
+    background: var(--ctp-base);
+    border: 1px solid var(--ctp-surface1);
+    border-radius: 0.75rem;
+    box-shadow: 0 1.5rem 4rem color-mix(in srgb, var(--ctp-crust) 50%, transparent);
+    display: flex;
+    flex-direction: column;
+    overflow: hidden;
+  }
+
+  .search-input-row {
+    display: flex;
+    align-items: center;
+    gap: 0.5rem;
+    padding: 0.75rem 1rem;
+    border-bottom: 1px solid var(--ctp-surface0);
+  }
+
+  .search-icon {
+    color: var(--ctp-overlay1);
+    flex-shrink: 0;
+  }
+
+  .search-input {
+    flex: 1;
+    background: transparent;
+    border: none;
+    outline: none;
+    color: var(--ctp-text);
+    font-size: 0.9375rem;
+    font-family: inherit;
+  }
+
+  .search-input::placeholder {
+    color: var(--ctp-overlay0);
+  }
+
+  .search-spinner {
+    width: 14px;
+    height: 14px;
+    border: 2px solid var(--ctp-surface2);
+    border-top-color: var(--ctp-blue);
+    border-radius: 50%;
+    animation: spin 0.6s linear infinite;
+    flex-shrink: 0;
+  }
+
+  @keyframes spin {
+    to { transform: rotate(360deg); }
+  }
+
+  .search-kbd {
+    font-size: 0.625rem;
+    padding: 0.125rem 0.375rem;
+    background: var(--ctp-surface0);
+    color: var(--ctp-overlay1);
+    border: 1px solid var(--ctp-surface1);
+    border-radius: 0.25rem;
+    font-family: inherit;
+    flex-shrink: 0;
+  }
+
+  .search-results {
+    overflow-y: auto;
+    flex: 1;
+    padding: 0.25rem 0;
+  }
+
+  .search-empty {
+    padding: 2rem 1rem;
+    text-align: center;
+    color: var(--ctp-overlay0);
+    font-size: 0.8125rem;
+  }
+
+  .result-group {
+    padding: 0.25rem 0;
+  }
+
+  .result-group-header {
+    display: flex;
+    align-items: center;
+    gap: 0.375rem;
+    padding: 0.375rem 1rem;
+    font-size: 0.6875rem;
+    font-weight: 600;
+    color: var(--ctp-subtext0);
+    text-transform: uppercase;
+    letter-spacing: 0.04em;
+  }
+
+  .group-icon {
+    font-size: 0.75rem;
+  }
+
+  .group-count {
+    margin-left: auto;
+    font-size: 0.625rem;
+    color: var(--ctp-overlay0);
+    background: var(--ctp-surface0);
+    padding: 0 0.375rem;
+    border-radius: 0.625rem;
+  }
+
+  .result-item {
+    display: flex;
+    align-items: center;
+    gap: 0.75rem;
+    width: 100%;
+    padding: 0.5rem 1rem;
+    background: transparent;
+    border: none;
+    color: var(--ctp-text);
+    font: inherit;
+    font-size: 0.8125rem;
+    cursor: pointer;
+    text-align: left;
+  }
+
+  .result-item:hover {
+    background: var(--ctp-surface0);
+  }
+
+  .result-main {
+    flex: 1;
+    min-width: 0;
+    display: flex;
+    flex-direction: column;
+    gap: 0.125rem;
+  }
+
+  .result-title {
+    font-weight: 600;
+    white-space: nowrap;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    color: var(--ctp-text);
+    font-size: 0.8125rem;
+  }
+
+  .result-snippet {
+    white-space: nowrap;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    color: var(--ctp-subtext0);
+    font-size: 0.75rem;
+  }
+
+  .result-snippet :global(mark) {
+    background: color-mix(in srgb, var(--ctp-yellow) 25%, transparent);
+    color: var(--ctp-yellow);
+    border-radius: 0.125rem;
+    padding: 0 0.125rem;
+  }
+
+  .result-score {
+    font-size: 0.625rem;
+    color: var(--ctp-overlay0);
+    background: var(--ctp-surface0);
+    padding: 0.0625rem 0.375rem;
+    border-radius: 0.25rem;
+    flex-shrink: 0;
+  }
+</style>
diff --git a/v2/src/lib/components/Workspace/SettingsTab.svelte b/v2/src/lib/components/Workspace/SettingsTab.svelte
new file mode 100644
index 0000000..8acba3f
--- /dev/null
+++ b/v2/src/lib/components/Workspace/SettingsTab.svelte
@@ -0,0 +1,2712 @@
+<script lang="ts">
+  import { onMount } from 'svelte';
+  import {
+    getActiveProjectId,
+    getActiveGroup,
+    getActiveGroupId,
+    getAllGroups,
+    updateProject,
+    updateAgent,
+    addProject,
+    removeProject,
+    addGroup,
+    removeGroup,
+    switchGroup,
+  } from '../../stores/workspace.svelte';
+  import { deriveIdentifier, type GroupAgentRole, AGENT_ROLE_ICONS } from '../../types/groups';
+  import { ProjectId, GroupId } from '../../types/ids';
+  import { generateAgentPrompt } from '../../utils/agent-prompts';
+  import { getSetting, setSetting } from '../../adapters/settings-bridge';
+  import { getCurrentTheme, setTheme } from '../../stores/theme.svelte';
+  import { THEME_LIST, getPalette, type ThemeId } from '../../styles/themes';
+  import { listProfiles, type ClaudeProfile } from '../../adapters/claude-bridge';
+  import { invoke } from '@tauri-apps/api/core';
+  import { getProviders } from '../../providers/registry.svelte';
+  import type { ProviderId, ProviderSettings } from '../../providers/types';
+  import { ANCHOR_BUDGET_SCALES, ANCHOR_BUDGET_SCALE_LABELS, type AnchorBudgetScale } from '../../types/anchors';
+  import { WAKE_STRATEGIES, WAKE_STRATEGY_LABELS, WAKE_STRATEGY_DESCRIPTIONS, type WakeStrategy } from '../../types/wake';
+  import {
+    storeSecret, getSecret, deleteSecret, listSecrets,
+    hasKeyring, knownSecretKeys, SECRET_KEY_LABELS,
+  } from '../../adapters/secrets-bridge';
+  import {
+    checkForUpdates,
+    getCurrentVersion,
+    getLastCheckTimestamp,
+    type UpdateInfo,
+  } from '../../utils/updater';
+  import {
+    getPluginEntries,
+    setPluginEnabled,
+    reloadAllPlugins,
+    type PluginEntry,
+  } from '../../stores/plugins.svelte';
+
+  const PROJECT_ICONS = [
+    '📁', '🚀', '🤖', '🌐', '🔧', '🎮', '📱', '💻',
+    '🔬', '📊', '🎨', '🔒', '💬', '📦', '⚡', '🧪',
+    '🏗️', '📝', '🎯', '💡', '🔥', '🛠️', '🧩', '🗄️',
+  ];
+
+  // Claude profiles for account selector
+  let profiles = $state<ClaudeProfile[]>([]);
+
+  // Provider settings (keyed by ProviderId)
+  let providerSettings = $state<Record<string, ProviderSettings>>({});
+  let expandedProvider = $state<string | null>(null);
+  let registeredProviders = $derived(getProviders());
+  let providerDropdownOpenFor = $state<string | null>(null);
+
+  let activeGroupId = $derived(getActiveGroupId());
+  let activeGroup = $derived(getActiveGroup());
+  let activeProjectId = $derived(getActiveProjectId());
+  let groups = $derived(getAllGroups());
+
+  let editingProject = $derived(
+    activeGroup?.projects.find(p => p.id === activeProjectId),
+  );
+
+  // Global settings
+  let defaultShell = $state('');
+  let defaultCwd = $state('');
+  let uiFont = $state('');
+  let uiFontSize = $state('');
+  let termFont = $state('');
+  let termFontSize = $state('');
+  let projectMaxAspect = $state('1.0');
+  let filesSaveOnBlur = $state(false);
+  let selectedTheme = $state<ThemeId>(getCurrentTheme());
+
+  // Updater state
+  let appVersion = $state('');
+  let updateCheckResult = $state<UpdateInfo | null>(null);
+  let updateChecking = $state(false);
+  let updateLastCheck = $state<string>('');
+
+  // Secrets state
+  let keyringAvailable = $state(false);
+  let storedKeys = $state<string[]>([]);
+  let knownKeys = $state<string[]>([]);
+  let revealedKey = $state<string | null>(null);
+  let revealedValue = $state('');
+  let newSecretKey = $state('');
+  let newSecretValue = $state('');
+  let secretsKeyDropdownOpen = $state(false);
+  let secretsSaving = $state(false);
+
+  // Dropdown open states
+  let themeDropdownOpen = $state(false);
+  let uiFontDropdownOpen = $state(false);
+  let termFontDropdownOpen = $state(false);
+
+  // Per-project icon picker & profile dropdown (keyed by project id)
+  let iconPickerOpenFor = $state<string | null>(null);
+  let profileDropdownOpenFor = $state<string | null>(null);
+
+  const UI_FONTS = [
+    { value: '', label: 'System Default' },
+    { value: 'Inter', label: 'Inter' },
+    { value: 'IBM Plex Sans', label: 'IBM Plex Sans' },
+    { value: 'Noto Sans', label: 'Noto Sans' },
+    { value: 'Roboto', label: 'Roboto' },
+    { value: 'Source Sans 3', label: 'Source Sans 3' },
+    { value: 'Ubuntu', label: 'Ubuntu' },
+    { value: 'JetBrains Mono', label: 'JetBrains Mono' },
+    { value: 'Fira Code', label: 'Fira Code' },
+  ];
+
+  const TERM_FONTS = [
+    { value: '', label: 'Default (JetBrains Mono)' },
+    { value: 'JetBrains Mono', label: 'JetBrains Mono' },
+    { value: 'Fira Code', label: 'Fira Code' },
+    { value: 'Cascadia Code', label: 'Cascadia Code' },
+    { value: 'Source Code Pro', label: 'Source Code Pro' },
+    { value: 'IBM Plex Mono', label: 'IBM Plex Mono' },
+    { value: 'Hack', label: 'Hack' },
+    { value: 'Inconsolata', label: 'Inconsolata' },
+    { value: 'Ubuntu Mono', label: 'Ubuntu Mono' },
+    { value: 'monospace', label: 'monospace' },
+  ];
+
+  // Group themes by category
+  const themeGroups = $derived(() => {
+    const map = new Map<string, typeof THEME_LIST>();
+    for (const t of THEME_LIST) {
+      if (!map.has(t.group)) map.set(t.group, []);
+      map.get(t.group)!.push(t);
+    }
+    return [...map.entries()];
+  });
+
+  let selectedThemeLabel = $derived(
+    THEME_LIST.find(t => t.id === selectedTheme)?.label ?? selectedTheme,
+  );
+
+  let uiFontLabel = $derived(
+    UI_FONTS.find(f => f.value === uiFont)?.label ?? 'System Default',
+  );
+
+  let termFontLabel = $derived(
+    TERM_FONTS.find(f => f.value === termFont)?.label ?? 'Default (JetBrains Mono)',
+  );
+
+  onMount(async () => {
+    const [shell, cwd, font, size, tfont, tsize, aspect, saveOnBlur] = await Promise.all([
+      getSetting('default_shell'),
+      getSetting('default_cwd'),
+      getSetting('ui_font_family'),
+      getSetting('ui_font_size'),
+      getSetting('term_font_family'),
+      getSetting('term_font_size'),
+      getSetting('project_max_aspect'),
+      getSetting('files_save_on_blur'),
+    ]);
+    defaultShell = shell ?? '';
+    defaultCwd = cwd ?? '';
+    uiFont = font ?? '';
+    uiFontSize = size ?? '';
+    termFont = tfont ?? '';
+    termFontSize = tsize ?? '';
+    projectMaxAspect = aspect ?? '1.0';
+    filesSaveOnBlur = saveOnBlur === 'true';
+    applyAspectRatio(projectMaxAspect);
+    selectedTheme = getCurrentTheme();
+
+    try {
+      profiles = await listProfiles();
+    } catch {
+      profiles = [];
+    }
+
+    // Load provider settings
+    try {
+      const raw = await getSetting('provider_settings');
+      if (raw) providerSettings = JSON.parse(raw);
+    } catch {
+      providerSettings = {};
+    }
+
+    // Load secrets state
+    try {
+      keyringAvailable = await hasKeyring();
+      if (keyringAvailable) {
+        storedKeys = await listSecrets();
+        knownKeys = await knownSecretKeys();
+      }
+    } catch {
+      keyringAvailable = false;
+    }
+
+    // Load app version for updater section
+    appVersion = await getCurrentVersion();
+    const ts = getLastCheckTimestamp();
+    if (ts) updateLastCheck = new Date(ts).toLocaleString();
+  });
+
+  function applyCssProp(prop: string, value: string) {
+    document.documentElement.style.setProperty(prop, value);
+  }
+
+  async function handleCheckForUpdates() {
+    updateChecking = true;
+    try {
+      updateCheckResult = await checkForUpdates();
+      updateLastCheck = new Date().toLocaleString();
+    } catch {
+      updateCheckResult = { available: false };
+    } finally {
+      updateChecking = false;
+    }
+  }
+
+  async function saveGlobalSetting(key: string, value: string) {
+    try {
+      await setSetting(key, value);
+    } catch (e) {
+      console.error(`Failed to save setting ${key}:`, e);
+    }
+  }
+
+  async function handleUiFontChange(family: string) {
+    uiFont = family;
+    uiFontDropdownOpen = false;
+    const val = family
+      ? `'${family}', sans-serif`
+      : "'JetBrains Mono', 'Fira Code', 'Cascadia Code', monospace";
+    applyCssProp('--ui-font-family', val);
+    await saveGlobalSetting('ui_font_family', family);
+  }
+
+  async function handleUiFontSizeChange(size: string) {
+    const num = parseInt(size, 10);
+    if (isNaN(num) || num < 8 || num > 24) return;
+    uiFontSize = size;
+    applyCssProp('--ui-font-size', `${num}px`);
+    await saveGlobalSetting('ui_font_size', size);
+  }
+
+  async function handleTermFontChange(family: string) {
+    termFont = family;
+    termFontDropdownOpen = false;
+    const val = family
+      ? `'${family}', monospace`
+      : "'JetBrains Mono', 'Fira Code', 'Cascadia Code', monospace";
+    applyCssProp('--term-font-family', val);
+    await saveGlobalSetting('term_font_family', family);
+  }
+
+  async function handleTermFontSizeChange(size: string) {
+    const num = parseInt(size, 10);
+    if (isNaN(num) || num < 8 || num > 24) return;
+    termFontSize = size;
+    applyCssProp('--term-font-size', `${num}px`);
+    await saveGlobalSetting('term_font_size', size);
+  }
+
+  function applyAspectRatio(value: string) {
+    const num = parseFloat(value);
+    if (isNaN(num) || num <= 0) return;
+    document.documentElement.style.setProperty('--project-max-aspect', value);
+  }
+
+  async function handleAspectChange(value: string) {
+    const num = parseFloat(value);
+    if (isNaN(num) || num < 0.3 || num > 3.0) return;
+    projectMaxAspect = value;
+    applyAspectRatio(value);
+    await saveGlobalSetting('project_max_aspect', value);
+  }
+
+  async function handleThemeChange(themeId: ThemeId) {
+    selectedTheme = themeId;
+    themeDropdownOpen = false;
+    await setTheme(themeId);
+  }
+
+  async function saveProviderSettings() {
+    await saveGlobalSetting('provider_settings', JSON.stringify(providerSettings));
+  }
+
+  function toggleProviderEnabled(providerId: string) {
+    const current = providerSettings[providerId] ?? { enabled: true, config: {} };
+    providerSettings[providerId] = { ...current, enabled: !current.enabled };
+    providerSettings = { ...providerSettings };
+    saveProviderSettings();
+  }
+
+  function setProviderModel(providerId: string, model: string) {
+    const current = providerSettings[providerId] ?? { enabled: true, config: {} };
+    providerSettings[providerId] = { ...current, defaultModel: model || undefined };
+    providerSettings = { ...providerSettings };
+    saveProviderSettings();
+  }
+
+  function isProviderEnabled(providerId: string): boolean {
+    return providerSettings[providerId]?.enabled ?? true;
+  }
+
+  // --- Secrets handlers ---
+
+  async function handleRevealSecret(key: string) {
+    if (revealedKey === key) {
+      revealedKey = null;
+      revealedValue = '';
+      return;
+    }
+    try {
+      const val = await getSecret(key);
+      revealedKey = key;
+      revealedValue = val ?? '';
+    } catch (e) {
+      console.error(`Failed to reveal secret '${key}':`, e);
+    }
+  }
+
+  async function handleSaveSecret() {
+    if (!newSecretKey || !newSecretValue) return;
+    secretsSaving = true;
+    try {
+      await storeSecret(newSecretKey, newSecretValue);
+      storedKeys = await listSecrets();
+      newSecretKey = '';
+      newSecretValue = '';
+      // If we just saved the currently revealed key, clear reveal
+      revealedKey = null;
+      revealedValue = '';
+    } catch (e) {
+      console.error('Failed to store secret:', e);
+    } finally {
+      secretsSaving = false;
+    }
+  }
+
+  async function handleDeleteSecret(key: string) {
+    try {
+      await deleteSecret(key);
+      storedKeys = await listSecrets();
+      if (revealedKey === key) {
+        revealedKey = null;
+        revealedValue = '';
+      }
+    } catch (e) {
+      console.error(`Failed to delete secret '${key}':`, e);
+    }
+  }
+
+  function getSecretKeyLabel(key: string): string {
+    return SECRET_KEY_LABELS[key] ?? key;
+  }
+
+  let availableKeysForAdd = $derived(
+    knownKeys.filter(k => !storedKeys.includes(k)),
+  );
+
+  let newSecretKeyLabel = $derived(
+    newSecretKey ? getSecretKeyLabel(newSecretKey) : 'Select key...',
+  );
+
+  function handleClickOutside(e: MouseEvent) {
+    const target = e.target as HTMLElement;
+    if (!target.closest('.custom-dropdown')) {
+      themeDropdownOpen = false;
+      uiFontDropdownOpen = false;
+      termFontDropdownOpen = false;
+      providerDropdownOpenFor = null;
+      secretsKeyDropdownOpen = false;
+    }
+    if (!target.closest('.icon-field')) {
+      iconPickerOpenFor = null;
+    }
+    if (!target.closest('.profile-field')) {
+      profileDropdownOpenFor = null;
+    }
+  }
+
+  function handleKeydown(e: KeyboardEvent) {
+    if (e.key === 'Escape') {
+      themeDropdownOpen = false;
+      uiFontDropdownOpen = false;
+      termFontDropdownOpen = false;
+      iconPickerOpenFor = null;
+      profileDropdownOpenFor = null;
+      secretsKeyDropdownOpen = false;
+    }
+  }
+
+  function getProfileLabel(profileName: string): string {
+    const p = profiles.find(pr => pr.name === profileName);
+    return p?.display_name || p?.name || profileName || 'default';
+  }
+
+  async function browseDirectory(): Promise<string | null> {
+    const selected = await invoke<string | null>('pick_directory');
+    return selected ?? null;
+  }
+
+  // New project form
+  let newName = $state('');
+  let newCwd = $state('');
+
+  function handleAddProject() {
+    if (!newName.trim() || !newCwd.trim() || !activeGroupId) return;
+    const id = ProjectId(crypto.randomUUID());
+    addProject(activeGroupId, {
+      id,
+      name: newName.trim(),
+      identifier: deriveIdentifier(newName.trim()),
+      description: '',
+      icon: '📁',
+      cwd: newCwd.trim(),
+      profile: 'default',
+      enabled: true,
+    });
+    newName = '';
+    newCwd = '';
+  }
+
+  // Plugin entries (reactive from store)
+  let pluginEntries = $derived(getPluginEntries());
+
+  async function handleReloadPlugins() {
+    await reloadAllPlugins(activeGroupId);
+  }
+
+  // New group form
+  let newGroupName = $state('');
+
+  function handleAddGroup() {
+    if (!newGroupName.trim()) return;
+    const id = GroupId(crypto.randomUUID());
+    addGroup({ id, name: newGroupName.trim(), projects: [] });
+    newGroupName = '';
+  }
+</script>
+
+<!-- svelte-ignore a11y_click_events_have_key_events -->
+<!-- svelte-ignore a11y_no_static_element_interactions -->
+<div class="settings-tab" onclick={handleClickOutside} onkeydown={handleKeydown}>
+  <section class="settings-section">
+    <h2>Appearance</h2>
+    <div class="settings-list">
+      <div class="setting-field">
+        <span class="setting-label">Theme</span>
+        <div class="custom-dropdown">
+          <button
+            class="dropdown-trigger"
+            onclick={() => { themeDropdownOpen = !themeDropdownOpen; uiFontDropdownOpen = false; termFontDropdownOpen = false; }}
+            aria-haspopup="listbox"
+            aria-expanded={themeDropdownOpen}
+          >
+            <span
+              class="theme-swatch"
+              style="background: {getPalette(selectedTheme).base}; border-color: {getPalette(selectedTheme).surface1};"
+            ></span>
+            <span class="dropdown-label">{selectedThemeLabel}</span>
+            <span class="dropdown-arrow">{themeDropdownOpen ? '\u25B4' : '\u25BE'}</span>
+          </button>
+          {#if themeDropdownOpen}
+            <div class="dropdown-menu" role="listbox">
+              {#each themeGroups() as [groupName, themes]}
+                <div class="dropdown-group-label">{groupName}</div>
+                {#each themes as t}
+                  <button
+                    class="dropdown-option"
+                    class:active={t.id === selectedTheme}
+                    role="option"
+                    aria-selected={t.id === selectedTheme}
+                    onclick={() => handleThemeChange(t.id)}
+                  >
+                    <span
+                      class="theme-swatch"
+                      style="background: {getPalette(t.id).base}; border-color: {getPalette(t.id).surface1};"
+                    ></span>
+                    <span class="dropdown-option-label">{t.label}</span>
+                    <span class="theme-colors">
+                      <span class="color-dot" style="background: {getPalette(t.id).red};"></span>
+                      <span class="color-dot" style="background: {getPalette(t.id).green};"></span>
+                      <span class="color-dot" style="background: {getPalette(t.id).blue};"></span>
+                      <span class="color-dot" style="background: {getPalette(t.id).yellow};"></span>
+                    </span>
+                  </button>
+                {/each}
+              {/each}
+            </div>
+          {/if}
+        </div>
+      </div>
+
+      <div class="setting-field">
+        <span class="setting-label">UI Font</span>
+        <div class="setting-row">
+          <div class="custom-dropdown dropdown-grow">
+            <button
+              class="dropdown-trigger"
+              onclick={() => { uiFontDropdownOpen = !uiFontDropdownOpen; themeDropdownOpen = false; termFontDropdownOpen = false; }}
+              aria-haspopup="listbox"
+              aria-expanded={uiFontDropdownOpen}
+            >
+              <span class="dropdown-label" style={uiFont ? `font-family: '${uiFont}', sans-serif` : ''}>{uiFontLabel}</span>
+              <span class="dropdown-arrow">{uiFontDropdownOpen ? '\u25B4' : '\u25BE'}</span>
+            </button>
+            {#if uiFontDropdownOpen}
+              <div class="dropdown-menu" role="listbox">
+                {#each UI_FONTS as f}
+                  <button
+                    class="dropdown-option"
+                    class:active={f.value === uiFont}
+                    role="option"
+                    aria-selected={f.value === uiFont}
+                    style={f.value ? `font-family: '${f.value}', sans-serif` : ''}
+                    onclick={() => handleUiFontChange(f.value)}
+                  >
+                    <span class="dropdown-option-label">{f.label}</span>
+                  </button>
+                {/each}
+              </div>
+            {/if}
+          </div>
+          <div class="size-control">
+            <button
+              class="size-btn"
+              onclick={() => handleUiFontSizeChange(String((parseInt(uiFontSize, 10) || 13) - 1))}
+              disabled={(parseInt(uiFontSize, 10) || 13) <= 8}
+            >&minus;</button>
+            <input
+              type="number"
+              min="8"
+              max="24"
+              value={uiFontSize || '13'}
+              class="size-input"
+              onchange={e => handleUiFontSizeChange((e.target as HTMLInputElement).value)}
+            />
+            <span class="size-unit">px</span>
+            <button
+              class="size-btn"
+              onclick={() => handleUiFontSizeChange(String((parseInt(uiFontSize, 10) || 13) + 1))}
+              disabled={(parseInt(uiFontSize, 10) || 13) >= 24}
+            >+</button>
+          </div>
+        </div>
+      </div>
+
+      <div class="setting-field">
+        <span class="setting-label">Terminal Font</span>
+        <div class="setting-row">
+          <div class="custom-dropdown dropdown-grow">
+            <button
+              class="dropdown-trigger"
+              onclick={() => { termFontDropdownOpen = !termFontDropdownOpen; themeDropdownOpen = false; uiFontDropdownOpen = false; }}
+              aria-haspopup="listbox"
+              aria-expanded={termFontDropdownOpen}
+            >
+              <span class="dropdown-label" style={termFont ? `font-family: '${termFont}', monospace` : ''}>{termFontLabel}</span>
+              <span class="dropdown-arrow">{termFontDropdownOpen ? '\u25B4' : '\u25BE'}</span>
+            </button>
+            {#if termFontDropdownOpen}
+              <div class="dropdown-menu" role="listbox">
+                {#each TERM_FONTS as f}
+                  <button
+                    class="dropdown-option"
+                    class:active={f.value === termFont}
+                    role="option"
+                    aria-selected={f.value === termFont}
+                    style={f.value ? `font-family: '${f.value}', monospace` : ''}
+                    onclick={() => handleTermFontChange(f.value)}
+                  >
+                    <span class="dropdown-option-label">{f.label}</span>
+                  </button>
+                {/each}
+              </div>
+            {/if}
+          </div>
+          <div class="size-control">
+            <button
+              class="size-btn"
+              onclick={() => handleTermFontSizeChange(String((parseInt(termFontSize, 10) || 13) - 1))}
+              disabled={(parseInt(termFontSize, 10) || 13) <= 8}
+            >&minus;</button>
+            <input
+              type="number"
+              min="8"
+              max="24"
+              value={termFontSize || '13'}
+              class="size-input"
+              onchange={e => handleTermFontSizeChange((e.target as HTMLInputElement).value)}
+            />
+            <span class="size-unit">px</span>
+            <button
+              class="size-btn"
+              onclick={() => handleTermFontSizeChange(String((parseInt(termFontSize, 10) || 13) + 1))}
+              disabled={(parseInt(termFontSize, 10) || 13) >= 24}
+            >+</button>
+          </div>
+        </div>
+      </div>
+      <div class="setting-field">
+        <span class="setting-label">Project max aspect ratio</span>
+        <div class="size-control">
+          <button
+            class="size-btn"
+            onclick={() => handleAspectChange((Math.max(0.3, parseFloat(projectMaxAspect) - 0.1)).toFixed(1))}
+            disabled={parseFloat(projectMaxAspect) <= 0.3}
+          >&minus;</button>
+          <input
+            type="number"
+            min="0.3"
+            max="3.0"
+            step="0.1"
+            value={projectMaxAspect}
+            class="size-input"
+            onchange={e => handleAspectChange((e.target as HTMLInputElement).value)}
+          />
+          <span class="size-unit">w:h</span>
+          <button
+            class="size-btn"
+            onclick={() => handleAspectChange((Math.min(3.0, parseFloat(projectMaxAspect) + 0.1)).toFixed(1))}
+            disabled={parseFloat(projectMaxAspect) >= 3.0}
+          >+</button>
+        </div>
+      </div>
+    </div>
+  </section>
+
+  <section class="settings-section">
+    <h2>Defaults</h2>
+    <div class="settings-list">
+      <div class="setting-field">
+        <label for="default-shell" class="setting-label">Shell</label>
+        <input
+          id="default-shell"
+          value={defaultShell}
+          placeholder="/bin/bash"
+          onchange={e => { defaultShell = (e.target as HTMLInputElement).value; saveGlobalSetting('default_shell', defaultShell); }}
+        />
+      </div>
+      <div class="setting-field">
+        <label for="default-cwd" class="setting-label">Working directory</label>
+        <div class="input-with-browse">
+          <input
+            id="default-cwd"
+            value={defaultCwd}
+            placeholder="~"
+            onchange={e => { defaultCwd = (e.target as HTMLInputElement).value; saveGlobalSetting('default_cwd', defaultCwd); }}
+          />
+          <button class="browse-btn" title="Browse..." onclick={async () => { const d = await browseDirectory(); if (d) { defaultCwd = d; saveGlobalSetting('default_cwd', d); } }}>
+            <svg width="14" height="14" viewBox="0 0 24 24" fill="none"><path d="M3 7v13h18V7H3zm0-2h7l2 2h9v1H3V5z" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/></svg>
+          </button>
+        </div>
+      </div>
+    </div>
+
+    <h3 class="subsection-title">Editor</h3>
+    <div class="settings-grid">
+      <div class="setting-field">
+        <label class="setting-label toggle-label">
+          <span>Save on blur</span>
+          <button
+            class="toggle-switch"
+            class:on={filesSaveOnBlur}
+            role="switch"
+            aria-checked={filesSaveOnBlur}
+            onclick={() => { filesSaveOnBlur = !filesSaveOnBlur; saveGlobalSetting('files_save_on_blur', String(filesSaveOnBlur)); }}
+          >
+            <span class="toggle-thumb"></span>
+          </button>
+        </label>
+        <span class="setting-hint">Auto-save files when the editor loses focus</span>
+      </div>
+    </div>
+  </section>
+
+  <section class="settings-section">
+    <h2>Updates</h2>
+    <div class="settings-list">
+      <div class="setting-field">
+        <span class="setting-label">Current version</span>
+        <span class="setting-value">{appVersion || '...'}</span>
+      </div>
+      {#if updateLastCheck}
+        <div class="setting-field">
+          <span class="setting-label">Last checked</span>
+          <span class="setting-value setting-muted">{updateLastCheck}</span>
+        </div>
+      {/if}
+      {#if updateCheckResult?.available}
+        <div class="setting-field">
+          <span class="setting-label">Available</span>
+          <span class="setting-value update-available">v{updateCheckResult.version}</span>
+        </div>
+      {/if}
+      <div class="setting-field">
+        <button
+          class="btn-primary"
+          onclick={handleCheckForUpdates}
+          disabled={updateChecking}
+        >
+          {updateChecking ? 'Checking...' : 'Check for Updates'}
+        </button>
+      </div>
+    </div>
+  </section>
+
+  <section class="settings-section">
+    <h2>Providers</h2>
+    <div class="provider-list">
+      {#each registeredProviders as provider}
+        <div class="provider-panel" class:disabled={!isProviderEnabled(provider.id)}>
+          <button
+            class="provider-header"
+            onclick={() => { expandedProvider = expandedProvider === provider.id ? null : provider.id; }}
+          >
+            <span class="provider-name">{provider.name}</span>
+            <span class="provider-desc">{provider.description}</span>
+            <span class="provider-chevron">{expandedProvider === provider.id ? '\u25B4' : '\u25BE'}</span>
+          </button>
+          {#if expandedProvider === provider.id}
+            <div class="provider-body">
+              <div class="setting-field">
+                <label class="setting-label toggle-label">
+                  <span>Enabled</span>
+                  <button
+                    class="toggle-switch"
+                    class:on={isProviderEnabled(provider.id)}
+                    role="switch"
+                    aria-checked={isProviderEnabled(provider.id)}
+                    onclick={() => toggleProviderEnabled(provider.id)}
+                  >
+                    <span class="toggle-thumb"></span>
+                  </button>
+                </label>
+              </div>
+              {#if provider.capabilities.hasModelSelection}
+                <div class="setting-field">
+                  <span class="setting-label">Default model</span>
+                  <input
+                    value={providerSettings[provider.id]?.defaultModel ?? provider.defaultModel ?? ''}
+                    placeholder={provider.defaultModel ?? 'default'}
+                    onchange={e => setProviderModel(provider.id, (e.target as HTMLInputElement).value)}
+                  />
+                </div>
+              {/if}
+              <div class="provider-caps">
+                <span class="setting-label">Capabilities</span>
+                <div class="caps-grid">
+                  {#if provider.capabilities.hasProfiles}<span class="cap-badge">Profiles</span>{/if}
+                  {#if provider.capabilities.hasSkills}<span class="cap-badge">Skills</span>{/if}
+                  {#if provider.capabilities.supportsSubagents}<span class="cap-badge">Subagents</span>{/if}
+                  {#if provider.capabilities.supportsCost}<span class="cap-badge">Cost tracking</span>{/if}
+                  {#if provider.capabilities.supportsResume}<span class="cap-badge">Resume</span>{/if}
+                  {#if provider.capabilities.hasSandbox}<span class="cap-badge">Sandbox</span>{/if}
+                </div>
+              </div>
+            </div>
+          {/if}
+        </div>
+      {/each}
+    </div>
+  </section>
+
+  <section class="settings-section">
+    <h2>Secrets</h2>
+    <div class="secrets-status">
+      <span class="keyring-indicator" class:available={keyringAvailable} class:unavailable={!keyringAvailable}></span>
+      <span class="keyring-label">
+        {keyringAvailable ? 'System keyring available' : 'System keyring unavailable'}
+      </span>
+    </div>
+
+    {#if !keyringAvailable}
+      <div class="secrets-warning">
+        <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M10.29 3.86L1.82 18a2 2 0 0 0 1.71 3h16.94a2 2 0 0 0 1.71-3L13.71 3.86a2 2 0 0 0-3.42 0z"/><line x1="12" y1="9" x2="12" y2="13"/><line x1="12" y1="17" x2="12.01" y2="17"/></svg>
+        <span>System keyring not available. Secrets cannot be stored securely.</span>
+      </div>
+    {:else}
+      {#if storedKeys.length > 0}
+        <div class="secrets-list">
+          {#each storedKeys as key}
+            <div class="secret-row">
+              <div class="secret-info">
+                <span class="secret-key-name">{getSecretKeyLabel(key)}</span>
+                <span class="secret-key-id">{key}</span>
+              </div>
+              <div class="secret-value-area">
+                {#if revealedKey === key}
+                  <input
+                    type="text"
+                    class="secret-value-input"
+                    value={revealedValue}
+                    readonly
+                  />
+                {:else}
+                  <span class="secret-masked">{'\u25CF'.repeat(8)}</span>
+                {/if}
+              </div>
+              <div class="secret-actions">
+                <button
+                  class="secret-btn"
+                  title={revealedKey === key ? 'Hide' : 'Reveal'}
+                  onclick={() => handleRevealSecret(key)}
+                >
+                  {#if revealedKey === key}
+                    <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M17.94 17.94A10.07 10.07 0 0 1 12 20c-7 0-11-8-11-8a18.45 18.45 0 0 1 5.06-5.94M9.9 4.24A9.12 9.12 0 0 1 12 4c7 0 11 8 11 8a18.5 18.5 0 0 1-2.16 3.19m-6.72-1.07a3 3 0 1 1-4.24-4.24"/><line x1="1" y1="1" x2="23" y2="23"/></svg>
+                  {:else}
+                    <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M1 12s4-8 11-8 11 8 11 8-4 8-11 8-11-8-11-8z"/><circle cx="12" cy="12" r="3"/></svg>
+                  {/if}
+                </button>
+                <button
+                  class="secret-btn secret-btn-danger"
+                  title="Delete"
+                  onclick={() => handleDeleteSecret(key)}
+                >
+                  <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M3 6h18"/><path d="M8 6V4h8v2"/><path d="M19 6v14a2 2 0 0 1-2 2H7a2 2 0 0 1-2-2V6"/></svg>
+                </button>
+              </div>
+            </div>
+          {/each}
+        </div>
+      {/if}
+
+      <div class="secret-add-form">
+        <div class="secret-add-row">
+          <div class="custom-dropdown secret-key-dropdown">
+            <button
+              class="dropdown-trigger"
+              onclick={() => { secretsKeyDropdownOpen = !secretsKeyDropdownOpen; }}
+              aria-haspopup="listbox"
+              aria-expanded={secretsKeyDropdownOpen}
+            >
+              <span class="dropdown-label">{newSecretKeyLabel}</span>
+              <span class="dropdown-arrow">{secretsKeyDropdownOpen ? '\u25B4' : '\u25BE'}</span>
+            </button>
+            {#if secretsKeyDropdownOpen}
+              <div class="dropdown-menu" role="listbox">
+                {#each availableKeysForAdd as key}
+                  <button
+                    class="dropdown-option"
+                    class:active={newSecretKey === key}
+                    role="option"
+                    aria-selected={newSecretKey === key}
+                    onclick={() => { newSecretKey = key; secretsKeyDropdownOpen = false; }}
+                  >
+                    <span class="dropdown-option-label">{getSecretKeyLabel(key)}</span>
+                    <span class="secret-key-hint">{key}</span>
+                  </button>
+                {/each}
+                {#if availableKeysForAdd.length === 0}
+                  <span class="dropdown-empty">All keys configured</span>
+                {/if}
+              </div>
+            {/if}
+          </div>
+          <input
+            type="password"
+            class="secret-value-new"
+            bind:value={newSecretValue}
+            placeholder="Secret value"
+            disabled={!newSecretKey}
+          />
+          <button
+            class="btn-primary"
+            onclick={handleSaveSecret}
+            disabled={!newSecretKey || !newSecretValue || secretsSaving}
+          >
+            {secretsSaving ? 'Saving...' : 'Save'}
+          </button>
+        </div>
+      </div>
+    {/if}
+  </section>
+
+  <section class="settings-section">
+    <h2>Plugins</h2>
+    {#if pluginEntries.length === 0}
+      <p class="empty-notice">No plugins found in ~/.config/bterminal/plugins/</p>
+    {:else}
+      <div class="plugin-list">
+        {#each pluginEntries as entry (entry.meta.id)}
+          <div class="plugin-row">
+            <div class="plugin-info">
+              <span class="plugin-name">{entry.meta.name}</span>
+              <span class="plugin-version">v{entry.meta.version}</span>
+              {#if entry.status === 'loaded'}
+                <span class="plugin-badge loaded" title="Loaded">loaded</span>
+              {:else if entry.status === 'error'}
+                <span class="plugin-badge error" title={entry.error ?? 'Error'}>error</span>
+              {:else if entry.status === 'disabled'}
+                <span class="plugin-badge disabled">disabled</span>
+              {:else}
+                <span class="plugin-badge discovered">discovered</span>
+              {/if}
+            </div>
+            {#if entry.meta.description}
+              <p class="plugin-desc">{entry.meta.description}</p>
+            {/if}
+            {#if entry.meta.permissions.length > 0}
+              <div class="plugin-perms">
+                {#each entry.meta.permissions as perm}
+                  <span class="perm-badge">{perm}</span>
+                {/each}
+              </div>
+            {/if}
+            {#if entry.error}
+              <p class="plugin-error">{entry.error}</p>
+            {/if}
+            <label class="card-toggle" title={entry.status === 'disabled' ? 'Disabled' : 'Enabled'}>
+              <input
+                type="checkbox"
+                checked={entry.status !== 'disabled'}
+                onchange={async (e) => {
+                  const enabled = (e.target as HTMLInputElement).checked;
+                  await setPluginEnabled(entry.meta.id, enabled);
+                }}
+              />
+              <span class="toggle-track"><span class="toggle-thumb"></span></span>
+            </label>
+          </div>
+        {/each}
+      </div>
+    {/if}
+    <button class="btn-primary reload-plugins-btn" onclick={handleReloadPlugins}>
+      Reload Plugins
+    </button>
+  </section>
+
+  <section class="settings-section">
+    <h2>Groups</h2>
+    <div class="group-list">
+      {#each groups as group}
+        <div class="group-row" class:active={group.id === activeGroupId}>
+          <button class="group-name" onclick={async () => await switchGroup(group.id)}>
+            {group.name}
+          </button>
+          <span class="group-count">{group.projects.length} projects</span>
+          {#if groups.length > 1}
+            <button class="btn-danger" onclick={() => removeGroup(group.id)}>Remove</button>
+          {/if}
+        </div>
+      {/each}
+    </div>
+
+    <div class="add-form">
+      <input bind:value={newGroupName} placeholder="New group name" />
+      <button class="btn-primary" onclick={handleAddGroup} disabled={!newGroupName.trim()}>
+        Add Group
+      </button>
+    </div>
+  </section>
+
+  {#if activeGroup && (activeGroup.agents?.length ?? 0) > 0}
+    <section class="settings-section">
+      <h2>Agents in "{activeGroup.name}"</h2>
+
+      <div class="agent-cards">
+        {#each activeGroup.agents ?? [] as agent (agent.id)}
+          <div class="agent-config-card">
+            <div class="card-top-row">
+              <span class="agent-config-icon">{AGENT_ROLE_ICONS[agent.role] ?? '🤖'}</span>
+              <input
+                class="card-name-input"
+                value={agent.name}
+                placeholder="Agent name"
+                onchange={e => updateAgent(activeGroupId, agent.id, { name: (e.target as HTMLInputElement).value })}
+              />
+              <span class="agent-role-badge">{agent.role}</span>
+              <label class="card-toggle" title={agent.enabled ? 'Enabled' : 'Disabled'}>
+                <input
+                  type="checkbox"
+                  checked={agent.enabled}
+                  onchange={e => updateAgent(activeGroupId, agent.id, { enabled: (e.target as HTMLInputElement).checked })}
+                />
+                <span class="toggle-track"><span class="toggle-thumb"></span></span>
+              </label>
+            </div>
+
+            <div class="card-field">
+              <span class="card-field-label">
+                <svg width="12" height="12" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M3 7v13h18V7H3zm0-2h7l2 2h9v1H3V5z"/></svg>
+                Working Directory
+              </span>
+              <div class="input-with-browse">
+                <input
+                  class="cwd-input"
+                  value={agent.cwd ?? ''}
+                  placeholder="Inherits from group"
+                  title={agent.cwd ?? 'Inherits from first project'}
+                  onchange={e => updateAgent(activeGroupId, agent.id, { cwd: (e.target as HTMLInputElement).value || undefined })}
+                />
+                <button class="browse-btn" title="Browse..." onclick={async () => { const d = await browseDirectory(); if (d) updateAgent(activeGroupId, agent.id, { cwd: d }); }}>
+                  <svg width="14" height="14" viewBox="0 0 24 24" fill="none"><path d="M3 7v13h18V7H3zm0-2h7l2 2h9v1H3V5z" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/></svg>
+                </button>
+              </div>
+            </div>
+
+            <div class="card-field">
+              <span class="card-field-label">
+                <svg width="12" height="12" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><rect x="2" y="3" width="20" height="14" rx="2" ry="2"/><line x1="8" y1="21" x2="16" y2="21"/><line x1="12" y1="17" x2="12" y2="21"/></svg>
+                Model
+              </span>
+              <input
+                class="card-field-input"
+                value={agent.model ?? ''}
+                placeholder="Default (provider default)"
+                onchange={e => updateAgent(activeGroupId, agent.id, { model: (e.target as HTMLInputElement).value || undefined })}
+              />
+            </div>
+
+            {#if agent.role === 'manager'}
+              <div class="card-field">
+                <span class="card-field-label">
+                  <svg width="12" height="12" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><circle cx="12" cy="12" r="10"/><path d="M12 6v6l4 2"/></svg>
+                  Wake Interval
+                </span>
+                <div class="scale-slider">
+                  <input
+                    type="range"
+                    min="1"
+                    max="30"
+                    step="1"
+                    value={agent.wakeIntervalMin ?? 3}
+                    oninput={e => updateAgent(activeGroupId, agent.id, { wakeIntervalMin: parseInt((e.target as HTMLInputElement).value) })}
+                  />
+                  <span class="scale-label">{agent.wakeIntervalMin ?? 3} min</span>
+                </div>
+              </div>
+
+              <div class="card-field">
+                <span class="card-field-label">
+                  <svg width="12" height="12" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M13 2L3 14h9l-1 8 10-12h-9l1-8z"/></svg>
+                  Wake Strategy
+                </span>
+                <div class="wake-strategy-row">
+                  {#each WAKE_STRATEGIES as strat}
+                    <button
+                      class="strategy-btn"
+                      class:active={(agent.wakeStrategy ?? 'smart') === strat}
+                      title={WAKE_STRATEGY_DESCRIPTIONS[strat]}
+                      onclick={() => updateAgent(activeGroupId, agent.id, { wakeStrategy: strat })}
+                    >{WAKE_STRATEGY_LABELS[strat]}</button>
+                  {/each}
+                </div>
+                <span class="setting-hint">{WAKE_STRATEGY_DESCRIPTIONS[agent.wakeStrategy ?? 'smart']}</span>
+              </div>
+
+              {#if (agent.wakeStrategy ?? 'smart') === 'smart'}
+                <div class="card-field">
+                  <span class="card-field-label">
+                    <svg width="12" height="12" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M18 20V10"/><path d="M12 20V4"/><path d="M6 20v-6"/></svg>
+                    Wake Threshold
+                  </span>
+                  <div class="scale-slider">
+                    <input
+                      type="range"
+                      min="0"
+                      max="1"
+                      step="0.1"
+                      value={agent.wakeThreshold ?? 0.5}
+                      oninput={e => updateAgent(activeGroupId, agent.id, { wakeThreshold: parseFloat((e.target as HTMLInputElement).value) })}
+                    />
+                    <span class="scale-label">{((agent.wakeThreshold ?? 0.5) * 100).toFixed(0)}%</span>
+                  </div>
+                  <span class="setting-hint">Only wakes when signal score exceeds this level</span>
+                </div>
+              {/if}
+            {/if}
+
+            <div class="card-field">
+              <span class="card-field-label">
+                <svg width="12" height="12" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M14 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V8z"/><polyline points="14 2 14 8 20 8"/><line x1="16" y1="13" x2="8" y2="13"/><line x1="16" y1="17" x2="8" y2="17"/></svg>
+                Custom Context
+              </span>
+              <textarea
+                class="agent-prompt-input"
+                value={agent.systemPrompt ?? ''}
+                placeholder="Additional instructions for this agent (appended to auto-generated context)"
+                rows="3"
+                onchange={e => updateAgent(activeGroupId, agent.id, { systemPrompt: (e.target as HTMLTextAreaElement).value || undefined })}
+              ></textarea>
+            </div>
+
+            <details class="prompt-preview">
+              <summary class="prompt-preview-toggle">
+                <svg width="10" height="10" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M1 12s4-8 11-8 11 8 11 8-4 8-11 8-11-8-11-8z"/><circle cx="12" cy="12" r="3"/></svg>
+                Preview full introductory prompt
+              </summary>
+              <pre class="prompt-preview-content">{generateAgentPrompt({
+                role: agent.role as GroupAgentRole,
+                agentId: agent.id,
+                agentName: agent.name,
+                group: activeGroup,
+                customPrompt: agent.systemPrompt,
+              })}</pre>
+            </details>
+          </div>
+        {/each}
+      </div>
+    </section>
+  {/if}
+
+  {#if activeGroup}
+    <section class="settings-section">
+      <h2>Projects in "{activeGroup.name}"</h2>
+
+      <div class="project-cards">
+        {#each activeGroup.projects as project}
+          <div class="project-card">
+            <div class="card-top-row">
+              <div class="icon-field">
+                <button
+                  class="icon-trigger"
+                  onclick={() => { iconPickerOpenFor = iconPickerOpenFor === project.id ? null : project.id; }}
+                  title="Choose icon"
+                >{project.icon || '📁'}</button>
+                {#if iconPickerOpenFor === project.id}
+                  <div class="icon-picker">
+                    {#each PROJECT_ICONS as emoji}
+                      <button
+                        class="icon-option"
+                        class:active={project.icon === emoji}
+                        onclick={() => {
+                          updateProject(activeGroupId, project.id, { icon: emoji });
+                          iconPickerOpenFor = null;
+                        }}
+                      >{emoji}</button>
+                    {/each}
+                  </div>
+                {/if}
+              </div>
+              <div class="card-name-area">
+                <input
+                  class="card-name-input"
+                  value={project.name}
+                  placeholder="Project name"
+                  onchange={e => updateProject(activeGroupId, project.id, { name: (e.target as HTMLInputElement).value })}
+                />
+              </div>
+              <label class="card-toggle" title={project.enabled ? 'Enabled' : 'Disabled'}>
+                <input
+                  type="checkbox"
+                  checked={project.enabled}
+                  onchange={e => updateProject(activeGroupId, project.id, { enabled: (e.target as HTMLInputElement).checked })}
+                />
+                <span class="toggle-track"><span class="toggle-thumb"></span></span>
+              </label>
+            </div>
+
+            <div class="card-field">
+              <span class="card-field-label">
+                <svg width="12" height="12" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M3 7v13h18V7H3zm0-2h7l2 2h9v1H3V5z"/></svg>
+                Path
+              </span>
+              <div class="input-with-browse">
+                <input
+                  class="cwd-input"
+                  value={project.cwd}
+                  placeholder="/path/to/project"
+                  title={project.cwd}
+                  onchange={e => updateProject(activeGroupId, project.id, { cwd: (e.target as HTMLInputElement).value })}
+                />
+                <button class="browse-btn" title="Browse..." onclick={async () => { const d = await browseDirectory(); if (d) updateProject(activeGroupId, project.id, { cwd: d }); }}>
+                  <svg width="14" height="14" viewBox="0 0 24 24" fill="none"><path d="M3 7v13h18V7H3zm0-2h7l2 2h9v1H3V5z" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/></svg>
+                </button>
+              </div>
+            </div>
+
+            <div class="card-field profile-field">
+              <span class="card-field-label">
+                <svg width="12" height="12" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M20 21v-2a4 4 0 0 0-4-4H8a4 4 0 0 0-4 4v2"/><circle cx="12" cy="7" r="4"/></svg>
+                Account
+              </span>
+              {#if profiles.length > 1}
+                <div class="custom-dropdown">
+                  <button
+                    class="dropdown-trigger profile-trigger"
+                    onclick={() => { profileDropdownOpenFor = profileDropdownOpenFor === project.id ? null : project.id; }}
+                    aria-haspopup="listbox"
+                    aria-expanded={profileDropdownOpenFor === project.id}
+                  >
+                    <span class="profile-badge">{getProfileLabel(project.profile)}</span>
+                    <span class="dropdown-arrow">{profileDropdownOpenFor === project.id ? '\u25B4' : '\u25BE'}</span>
+                  </button>
+                  {#if profileDropdownOpenFor === project.id}
+                    <div class="dropdown-menu profile-menu" role="listbox">
+                      {#each profiles as prof}
+                        <button
+                          class="dropdown-option"
+                          class:active={project.profile === prof.name}
+                          role="option"
+                          aria-selected={project.profile === prof.name}
+                          onclick={() => {
+                            updateProject(activeGroupId, project.id, { profile: prof.name });
+                            profileDropdownOpenFor = null;
+                          }}
+                        >
+                          <span class="profile-option-name">{prof.display_name || prof.name}</span>
+                          {#if prof.email}
+                            <span class="profile-option-email">{prof.email}</span>
+                          {/if}
+                        </button>
+                      {/each}
+                    </div>
+                  {/if}
+                </div>
+              {:else}
+                <span class="profile-single">{getProfileLabel(project.profile)}</span>
+              {/if}
+            </div>
+
+            {#if registeredProviders.length > 1}
+              <div class="card-field">
+                <span class="card-field-label">
+                  <svg width="12" height="12" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M12 2L2 7l10 5 10-5-10-5z"/><path d="M2 17l10 5 10-5"/><path d="M2 12l10 5 10-5"/></svg>
+                  Provider
+                </span>
+                <div class="custom-dropdown">
+                  <button
+                    class="dropdown-trigger provider-trigger"
+                    onclick={() => { providerDropdownOpenFor = providerDropdownOpenFor === project.id ? null : project.id; }}
+                    aria-haspopup="listbox"
+                    aria-expanded={providerDropdownOpenFor === project.id}
+                  >
+                    <span class="dropdown-label">{registeredProviders.find(p => p.id === (project.provider ?? 'claude'))?.name ?? 'Claude Code'}</span>
+                    <span class="dropdown-arrow">{providerDropdownOpenFor === project.id ? '\u25B4' : '\u25BE'}</span>
+                  </button>
+                  {#if providerDropdownOpenFor === project.id}
+                    <div class="dropdown-menu" role="listbox">
+                      {#each registeredProviders.filter(p => isProviderEnabled(p.id)) as prov}
+                        <button
+                          class="dropdown-option"
+                          class:active={(project.provider ?? 'claude') === prov.id}
+                          role="option"
+                          aria-selected={(project.provider ?? 'claude') === prov.id}
+                          onclick={() => {
+                            updateProject(activeGroupId, project.id, { provider: prov.id });
+                            providerDropdownOpenFor = null;
+                          }}
+                        >
+                          <span class="dropdown-option-label">{prov.name}</span>
+                        </button>
+                      {/each}
+                    </div>
+                  {/if}
+                </div>
+              </div>
+            {/if}
+
+            <div class="card-field">
+              <span class="card-field-label">
+                <svg width="12" height="12" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M12 20V10"/><path d="M18 20V4"/><path d="M6 20v-4"/></svg>
+                Anchor Budget
+              </span>
+              <div class="scale-slider">
+                <input
+                  type="range"
+                  min="0"
+                  max={ANCHOR_BUDGET_SCALES.length - 1}
+                  step="1"
+                  value={ANCHOR_BUDGET_SCALES.indexOf(project.anchorBudgetScale ?? 'medium')}
+                  oninput={(e) => {
+                    const idx = parseInt((e.target as HTMLInputElement).value);
+                    updateProject(activeGroupId, project.id, { anchorBudgetScale: ANCHOR_BUDGET_SCALES[idx] });
+                  }}
+                />
+                <span class="scale-label">{ANCHOR_BUDGET_SCALE_LABELS[project.anchorBudgetScale ?? 'medium']}</span>
+              </div>
+            </div>
+
+            <div class="card-field card-field-row">
+              <span class="card-field-label">
+                <svg width="12" height="12" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M6 3v12"/><path d="M18 9a3 3 0 0 0-3-3H7"/><path d="M18 9v12"/></svg>
+                Worktree Isolation
+              </span>
+              <label class="card-toggle" title={project.useWorktrees ? 'Worktrees enabled' : 'Worktrees disabled'}>
+                <input
+                  type="checkbox"
+                  checked={project.useWorktrees ?? false}
+                  onchange={e => updateProject(activeGroupId, project.id, { useWorktrees: (e.target as HTMLInputElement).checked })}
+                />
+                <span class="toggle-track"><span class="toggle-thumb"></span></span>
+              </label>
+            </div>
+
+            <div class="card-field card-field-row">
+              <span class="card-field-label">
+                <svg width="12" height="12" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><rect x="3" y="11" width="18" height="11" rx="2" ry="2"/><path d="M7 11V7a5 5 0 0 1 10 0v4"/></svg>
+                Sandbox (Landlock)
+              </span>
+              <label class="card-toggle" title={project.sandboxEnabled ? 'Filesystem sandbox enabled' : 'Filesystem sandbox disabled'}>
+                <input
+                  type="checkbox"
+                  checked={project.sandboxEnabled ?? false}
+                  onchange={e => updateProject(activeGroupId, project.id, { sandboxEnabled: (e.target as HTMLInputElement).checked })}
+                />
+                <span class="toggle-track"><span class="toggle-thumb"></span></span>
+              </label>
+            </div>
+
+            <div class="card-field">
+              <span class="card-field-label">
+                <svg width="12" height="12" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><circle cx="12" cy="12" r="10"/><path d="M12 6v6l4 2"/></svg>
+                Stall Threshold
+              </span>
+              <div class="scale-slider">
+                <input
+                  type="range"
+                  min="5"
+                  max="60"
+                  step="5"
+                  value={project.stallThresholdMin ?? 15}
+                  oninput={(e) => {
+                    updateProject(activeGroupId, project.id, { stallThresholdMin: parseInt((e.target as HTMLInputElement).value) });
+                  }}
+                />
+                <span class="scale-label">{project.stallThresholdMin ?? 15} min</span>
+              </div>
+            </div>
+
+            <div class="card-field">
+              <span class="card-field-label">
+                <svg width="12" height="12" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M14 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V8z"/><polyline points="14 2 14 8 20 8"/><line x1="16" y1="13" x2="8" y2="13"/><line x1="16" y1="17" x2="8" y2="17"/></svg>
+                Custom Context
+              </span>
+              <textarea
+                class="agent-prompt-input"
+                value={project.systemPrompt ?? ''}
+                placeholder="Additional instructions injected into this project's agent session"
+                rows="3"
+                onchange={e => updateProject(activeGroupId, project.id, { systemPrompt: (e.target as HTMLTextAreaElement).value || undefined })}
+              ></textarea>
+            </div>
+
+            <div class="card-footer">
+              <button class="btn-remove" onclick={() => removeProject(activeGroupId, project.id)}>
+                <svg width="12" height="12" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M3 6h18"/><path d="M8 6V4h8v2"/><path d="M19 6v14a2 2 0 0 1-2 2H7a2 2 0 0 1-2-2V6"/></svg>
+                Remove
+              </button>
+            </div>
+          </div>
+        {/each}
+      </div>
+
+      {#if activeGroup.projects.length < 5}
+        <div class="add-project-form">
+          <div class="add-form-row">
+            <input class="add-name" bind:value={newName} placeholder="Project name" />
+            <div class="input-with-browse add-form-path">
+              <input bind:value={newCwd} placeholder="/path/to/project" />
+              <button class="browse-btn" title="Browse..." onclick={async () => { const d = await browseDirectory(); if (d) newCwd = d; }}>
+                <svg width="14" height="14" viewBox="0 0 24 24" fill="none"><path d="M3 7v13h18V7H3zm0-2h7l2 2h9v1H3V5z" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/></svg>
+              </button>
+            </div>
+            <button class="btn-primary" onclick={handleAddProject} disabled={!newName.trim() || !newCwd.trim()}>
+              + Add
+            </button>
+          </div>
+        </div>
+      {:else}
+        <p class="limit-notice">Maximum 5 projects per group reached.</p>
+      {/if}
+    </section>
+  {/if}
+</div>
+
+<style>
+  .settings-tab {
+    padding: 0.75rem 1rem;
+    overflow-y: auto;
+    height: 100%;
+    min-width: 22em;
+  }
+
+  h2 {
+    font-size: 0.8rem;
+    font-weight: 600;
+    color: var(--ctp-text);
+    margin: 0 0 0.625rem;
+    padding-bottom: 0.375rem;
+    border-bottom: 1px solid var(--ctp-surface0);
+  }
+
+  .settings-section {
+    margin-bottom: 1.25rem;
+  }
+
+  .settings-list {
+    display: flex;
+    flex-direction: column;
+    gap: 0.625rem;
+  }
+
+  .setting-field {
+    display: flex;
+    flex-direction: column;
+    gap: 0.25rem;
+  }
+
+  .setting-label {
+    font-size: 0.7rem;
+    color: var(--ctp-subtext0);
+    text-transform: uppercase;
+    letter-spacing: 0.03em;
+  }
+
+  .setting-value {
+    font-size: 0.8rem;
+    color: var(--ctp-text);
+  }
+
+  .setting-muted {
+    color: var(--ctp-overlay0);
+    font-size: 0.75rem;
+  }
+
+  .update-available {
+    color: var(--ctp-green);
+    font-weight: 600;
+  }
+
+  .setting-field > input,
+  .setting-field .input-with-browse input {
+    padding: 0.375rem 0.625rem;
+    background: var(--ctp-surface0);
+    border: 1px solid var(--ctp-surface1);
+    border-radius: 0.25rem;
+    color: var(--ctp-text);
+    font-size: 0.8rem;
+  }
+
+  .setting-row {
+    display: flex;
+    gap: 0.5rem;
+    align-items: stretch;
+  }
+
+  /* Reusable custom dropdown */
+  .custom-dropdown {
+    position: relative;
+  }
+
+  .dropdown-grow {
+    flex: 1;
+    min-width: 0;
+  }
+
+  .dropdown-trigger {
+    display: flex;
+    align-items: center;
+    gap: 0.5rem;
+    width: 100%;
+    padding: 0.375rem 0.625rem;
+    background: var(--ctp-surface0);
+    border: 1px solid var(--ctp-surface1);
+    border-radius: 0.25rem;
+    color: var(--ctp-text);
+    font-size: 0.8rem;
+    cursor: pointer;
+    text-align: left;
+    height: 100%;
+  }
+
+  .dropdown-trigger:hover {
+    border-color: var(--ctp-surface2);
+  }
+
+  .dropdown-label {
+    flex: 1;
+    min-width: 0;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+  }
+
+  .dropdown-arrow {
+    color: var(--ctp-overlay0);
+    font-size: 0.7rem;
+    flex-shrink: 0;
+  }
+
+  .dropdown-menu {
+    position: absolute;
+    top: calc(100% + 0.25rem);
+    left: 0;
+    min-width: 100%;
+    width: max-content;
+    max-height: 22.5rem;
+    overflow-y: auto;
+    background: var(--ctp-mantle);
+    border: 1px solid var(--ctp-surface1);
+    border-radius: 0.25rem;
+    box-shadow: 0 0.5rem 1.5rem rgba(0, 0, 0, 0.4);
+    z-index: 100;
+    padding: 0.25rem 0;
+  }
+
+  .dropdown-group-label {
+    padding: 0.375rem 0.625rem 0.125rem;
+    font-size: 0.65rem;
+    font-weight: 700;
+    color: var(--ctp-overlay0);
+    text-transform: uppercase;
+    letter-spacing: 0.05em;
+  }
+
+  .dropdown-option {
+    display: flex;
+    align-items: center;
+    gap: 0.5rem;
+    width: 100%;
+    padding: 0.3125rem 0.625rem;
+    background: transparent;
+    border: none;
+    color: var(--ctp-subtext1);
+    font-size: 0.8rem;
+    cursor: pointer;
+    text-align: left;
+    white-space: nowrap;
+  }
+
+  .dropdown-option:hover {
+    background: var(--ctp-surface0);
+    color: var(--ctp-text);
+  }
+
+  .dropdown-option.active {
+    background: var(--ctp-surface0);
+    color: var(--ctp-text);
+    font-weight: 600;
+  }
+
+  .dropdown-option-label {
+    flex: 1;
+  }
+
+  /* Theme-specific dropdown extras */
+  .theme-swatch {
+    display: inline-block;
+    width: 14px;
+    height: 14px;
+    border-radius: 0.1875rem;
+    border: 1px solid;
+    flex-shrink: 0;
+  }
+
+  .theme-colors {
+    display: flex;
+    gap: 0.1875rem;
+    flex-shrink: 0;
+  }
+
+  .color-dot {
+    display: inline-block;
+    width: 8px;
+    height: 8px;
+    border-radius: 50%;
+  }
+
+  /* Size control (shared by UI and Terminal font) */
+  .size-control {
+    display: flex;
+    align-items: center;
+    gap: 0.125rem;
+    flex-shrink: 0;
+  }
+
+  .size-btn {
+    width: 1.75rem;
+    height: 1.75rem;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    background: var(--ctp-surface0);
+    border: 1px solid var(--ctp-surface1);
+    border-radius: 0.25rem;
+    color: var(--ctp-text);
+    font-size: 0.9rem;
+    cursor: pointer;
+  }
+
+  .size-btn:hover {
+    background: var(--ctp-surface1);
+  }
+
+  .size-btn:disabled {
+    opacity: 0.3;
+    cursor: not-allowed;
+  }
+
+  .size-input {
+    width: 2.5rem;
+    padding: 0.25rem 0.125rem;
+    background: var(--ctp-surface0);
+    border: 1px solid var(--ctp-surface1);
+    border-radius: 0.25rem;
+    color: var(--ctp-text);
+    font-size: 0.8rem;
+    text-align: center;
+    -moz-appearance: textfield;
+  }
+
+  .size-input::-webkit-inner-spin-button,
+  .size-input::-webkit-outer-spin-button {
+    -webkit-appearance: none;
+  }
+
+  .size-unit {
+    font-size: 0.7rem;
+    color: var(--ctp-overlay0);
+    margin-right: 0.125rem;
+  }
+
+  /* Groups */
+  .group-list {
+    display: flex;
+    flex-direction: column;
+    gap: 0.25rem;
+    margin-bottom: 0.75rem;
+  }
+
+  .group-row {
+    display: flex;
+    align-items: center;
+    gap: 0.5rem;
+    padding: 0.375rem 0.625rem;
+    background: var(--ctp-surface0);
+    border-radius: 0.25rem;
+  }
+
+  .group-row.active {
+    border-left: 3px solid var(--ctp-blue);
+  }
+
+  .group-name {
+    background: transparent;
+    border: none;
+    color: var(--ctp-text);
+    cursor: pointer;
+    font-size: 0.85rem;
+    font-weight: 600;
+    flex: 1;
+    text-align: left;
+  }
+
+  .group-count {
+    color: var(--ctp-overlay0);
+    font-size: 0.75rem;
+  }
+
+  /* Project Cards */
+  .project-cards {
+    display: flex;
+    flex-direction: column;
+    gap: 0.5rem;
+  }
+
+  .project-card {
+    background: var(--ctp-surface0);
+    border: 1px solid var(--ctp-surface1);
+    border-radius: 0.5rem;
+    padding: 0.625rem 0.75rem;
+    display: flex;
+    flex-direction: column;
+    gap: 0.5rem;
+    transition: border-color 0.15s;
+  }
+
+  .project-card:hover {
+    border-color: var(--ctp-surface2);
+  }
+
+  .card-top-row {
+    display: flex;
+    align-items: center;
+    gap: 0.5rem;
+  }
+
+  .card-name-area {
+    flex: 1;
+    min-width: 0;
+  }
+
+  .card-name-input {
+    width: 100%;
+    padding: 0.25rem 0.5rem;
+    background: transparent;
+    border: 1px solid transparent;
+    border-radius: 0.25rem;
+    color: var(--ctp-text);
+    font-size: 0.85rem;
+    font-weight: 600;
+    transition: border-color 0.15s, background 0.15s;
+  }
+
+  .card-name-input:hover {
+    background: var(--ctp-base);
+    border-color: var(--ctp-surface1);
+  }
+
+  .card-name-input:focus {
+    background: var(--ctp-base);
+    border-color: var(--ctp-blue);
+    outline: none;
+  }
+
+  /* Toggle switch */
+  .card-toggle {
+    position: relative;
+    cursor: pointer;
+    flex-shrink: 0;
+  }
+
+  .card-toggle input {
+    position: absolute;
+    opacity: 0;
+    width: 0;
+    height: 0;
+  }
+
+  .toggle-track {
+    display: block;
+    width: 2rem;
+    height: 1.125rem;
+    background: var(--ctp-surface2);
+    border-radius: 0.5625rem;
+    transition: background 0.2s;
+    position: relative;
+  }
+
+  .card-toggle input:checked + .toggle-track {
+    background: var(--ctp-green);
+  }
+
+  .toggle-thumb {
+    position: absolute;
+    top: 0.125rem;
+    left: 0.125rem;
+    width: 0.875rem;
+    height: 0.875rem;
+    background: var(--ctp-text);
+    border-radius: 50%;
+    transition: transform 0.2s;
+  }
+
+  .card-toggle input:checked + .toggle-track .toggle-thumb {
+    transform: translateX(0.875rem);
+  }
+
+  /* Card fields */
+  .card-field {
+    display: flex;
+    flex-direction: column;
+    gap: 0.25rem;
+  }
+
+  .card-field.card-field-row {
+    flex-direction: row;
+    align-items: center;
+    justify-content: space-between;
+  }
+
+  .card-field-label {
+    display: flex;
+    align-items: center;
+    gap: 0.375rem;
+    font-size: 0.65rem;
+    color: var(--ctp-overlay0);
+    text-transform: uppercase;
+    letter-spacing: 0.04em;
+  }
+
+  .card-field-label svg {
+    flex-shrink: 0;
+    opacity: 0.6;
+  }
+
+  .card-field .input-with-browse input {
+    padding: 0.3125rem 0.5rem;
+    background: var(--ctp-base);
+    border: 1px solid var(--ctp-surface1);
+    border-radius: 0.25rem;
+    color: var(--ctp-text);
+    font-size: 0.78rem;
+    font-family: var(--term-font-family, monospace);
+  }
+
+  /* Anchor budget scale slider */
+  .scale-slider {
+    display: flex;
+    align-items: center;
+    gap: 0.5rem;
+  }
+
+  .scale-slider input[type="range"] {
+    flex: 1;
+    height: 0.25rem;
+    appearance: none;
+    background: var(--ctp-surface1);
+    border-radius: 0.125rem;
+    outline: none;
+    cursor: pointer;
+  }
+
+  .scale-slider input[type="range"]::-webkit-slider-thumb {
+    appearance: none;
+    width: 0.875rem;
+    height: 0.875rem;
+    border-radius: 50%;
+    background: var(--ctp-blue);
+    border: 2px solid var(--ctp-base);
+    cursor: pointer;
+  }
+
+  .scale-label {
+    font-size: 0.75rem;
+    color: var(--ctp-subtext0);
+    white-space: nowrap;
+    min-width: 5.5em;
+  }
+
+  .wake-strategy-row {
+    display: flex;
+    gap: 0;
+    border-radius: 0.25rem;
+    overflow: hidden;
+    border: 1px solid var(--ctp-surface1);
+  }
+
+  .strategy-btn {
+    flex: 1;
+    padding: 0.25rem 0.5rem;
+    border: none;
+    background: var(--ctp-surface0);
+    color: var(--ctp-overlay1);
+    font-size: 0.7rem;
+    font-weight: 500;
+    cursor: pointer;
+    transition: background 0.12s, color 0.12s;
+  }
+
+  .strategy-btn:not(:last-child) {
+    border-right: 1px solid var(--ctp-surface1);
+  }
+
+  .strategy-btn:hover {
+    background: var(--ctp-surface1);
+    color: var(--ctp-subtext1);
+  }
+
+  .strategy-btn.active {
+    background: color-mix(in srgb, var(--ctp-blue) 20%, var(--ctp-surface0));
+    color: var(--ctp-blue);
+    font-weight: 600;
+  }
+
+  /* CWD input: left-ellipsis */
+  .cwd-input {
+    direction: rtl;
+    text-align: left;
+    unicode-bidi: plaintext;
+    text-overflow: ellipsis;
+    overflow: hidden;
+    white-space: nowrap;
+  }
+
+  /* Profile field */
+  .profile-trigger {
+    padding: 0.25rem 0.5rem;
+    background: var(--ctp-base);
+    font-size: 0.78rem;
+  }
+
+  .profile-badge {
+    font-weight: 600;
+    color: var(--ctp-blue);
+    flex: 1;
+    min-width: 0;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+  }
+
+  .profile-single {
+    font-size: 0.78rem;
+    font-weight: 600;
+    color: var(--ctp-blue);
+    padding: 0.25rem 0.5rem;
+    background: var(--ctp-base);
+    border: 1px solid var(--ctp-surface1);
+    border-radius: 0.25rem;
+  }
+
+  .profile-menu {
+    min-width: 12rem;
+  }
+
+  .profile-option-name {
+    font-weight: 500;
+    color: var(--ctp-text);
+  }
+
+  .profile-option-email {
+    font-size: 0.7rem;
+    color: var(--ctp-overlay0);
+    margin-left: auto;
+  }
+
+  /* Card footer */
+  .card-footer {
+    display: flex;
+    justify-content: flex-end;
+    padding-top: 0.25rem;
+    border-top: 1px solid var(--ctp-surface1);
+    margin-top: 0.125rem;
+  }
+
+  .btn-remove {
+    display: inline-flex;
+    align-items: center;
+    gap: 0.25rem;
+    padding: 0.25rem 0.5rem;
+    background: transparent;
+    color: var(--ctp-overlay0);
+    border: none;
+    border-radius: 0.25rem;
+    font-size: 0.7rem;
+    cursor: pointer;
+    transition: color 0.15s, background 0.15s;
+  }
+
+  .btn-remove:hover {
+    color: var(--ctp-red);
+    background: color-mix(in srgb, var(--ctp-red) 8%, transparent);
+  }
+
+  /* Icon field & picker */
+  .icon-field {
+    position: relative;
+    flex-shrink: 0;
+  }
+
+  .icon-trigger {
+    width: 2.25rem;
+    height: 2.25rem;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    background: var(--ctp-base);
+    border: 1px solid var(--ctp-surface1);
+    border-radius: 0.375rem;
+    font-size: 1.1rem;
+    cursor: pointer;
+    transition: border-color 0.15s, box-shadow 0.15s;
+  }
+
+  .icon-trigger:hover {
+    border-color: var(--ctp-overlay0);
+    box-shadow: 0 0 0 2px color-mix(in srgb, var(--ctp-blue) 15%, transparent);
+  }
+
+  .icon-picker {
+    display: grid;
+    position: absolute;
+    top: calc(100% + 0.375rem);
+    left: 50%;
+    transform: translateX(-50%);
+    z-index: 50;
+    background: var(--ctp-mantle);
+    border: 1px solid var(--ctp-surface1);
+    border-radius: 0.5rem;
+    padding: 0.5rem;
+    grid-template-columns: repeat(8, 1fr);
+    gap: 2px;
+    box-shadow: 0 0.5rem 1.5rem rgba(0, 0, 0, 0.35);
+    width: max-content;
+  }
+
+  .icon-option {
+    width: 1.75rem;
+    height: 1.75rem;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    background: transparent;
+    border: 1px solid transparent;
+    border-radius: 0.25rem;
+    font-size: 0.9rem;
+    cursor: pointer;
+    transition: background 0.1s, transform 0.1s;
+  }
+
+  .icon-option:hover {
+    background: var(--ctp-surface0);
+    transform: scale(1.15);
+  }
+
+  .icon-option.active {
+    background: var(--ctp-surface1);
+    border-color: var(--ctp-blue);
+  }
+
+  /* Add project form */
+  .add-project-form {
+    margin-top: 0.625rem;
+    padding: 0.5rem 0.625rem;
+    background: var(--ctp-mantle);
+    border: 1px dashed var(--ctp-surface1);
+    border-radius: 0.5rem;
+  }
+
+  .add-form-row {
+    display: flex;
+    gap: 0.5rem;
+    align-items: center;
+    min-width: 0;
+  }
+
+  .add-name {
+    width: 8rem;
+    flex-shrink: 0;
+    padding: 0.3125rem 0.625rem;
+    background: var(--ctp-base);
+    border: 1px solid var(--ctp-surface1);
+    border-radius: 0.25rem;
+    color: var(--ctp-text);
+    font-size: 0.8rem;
+  }
+
+  .add-form {
+    display: flex;
+    gap: 0.5rem;
+    align-items: center;
+    margin-top: 0.5rem;
+    min-width: 0;
+  }
+
+  .add-form input {
+    padding: 0.3125rem 0.625rem;
+    background: var(--ctp-base);
+    border: 1px solid var(--ctp-surface1);
+    border-radius: 0.25rem;
+    color: var(--ctp-text);
+    font-size: 0.8rem;
+    flex: 1;
+    min-width: 0;
+  }
+
+  .btn-primary {
+    padding: 0.3125rem 0.875rem;
+    background: var(--ctp-blue);
+    color: var(--ctp-base);
+    border: none;
+    border-radius: 0.25rem;
+    font-size: 0.78rem;
+    font-weight: 600;
+    cursor: pointer;
+    white-space: nowrap;
+    transition: opacity 0.15s;
+  }
+
+  .btn-primary:hover {
+    opacity: 0.9;
+  }
+
+  .btn-primary:disabled {
+    opacity: 0.4;
+    cursor: not-allowed;
+  }
+
+  .btn-danger {
+    padding: 0.25rem 0.625rem;
+    background: transparent;
+    color: var(--ctp-red);
+    border: 1px solid var(--ctp-red);
+    border-radius: 0.25rem;
+    font-size: 0.75rem;
+    cursor: pointer;
+    white-space: nowrap;
+  }
+
+  .limit-notice {
+    color: var(--ctp-overlay0);
+    font-size: 0.8rem;
+    font-style: italic;
+    margin-top: 0.5rem;
+  }
+
+  .input-with-browse {
+    display: flex;
+    gap: 0.25rem;
+    align-items: stretch;
+  }
+
+  .input-with-browse input {
+    flex: 1;
+    min-width: 0;
+  }
+
+  .add-form-path {
+    flex: 1;
+    min-width: 0;
+  }
+
+  .add-form-path input {
+    padding: 0.3125rem 0.625rem;
+    background: var(--ctp-base);
+    border: 1px solid var(--ctp-surface1);
+    border-radius: 0.25rem;
+    color: var(--ctp-text);
+    font-size: 0.8rem;
+  }
+
+  .browse-btn {
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    padding: 0 0.5rem;
+    background: var(--ctp-surface0);
+    border: 1px solid var(--ctp-surface1);
+    border-radius: 0.25rem;
+    color: var(--ctp-subtext0);
+    cursor: pointer;
+    flex-shrink: 0;
+  }
+
+  .browse-btn:hover {
+    color: var(--ctp-text);
+    background: var(--ctp-surface1);
+  }
+
+  .subsection-title {
+    font-size: 0.725rem;
+    font-weight: 600;
+    color: var(--ctp-subtext1);
+    margin: 0.75rem 0 0.5rem;
+  }
+
+  .setting-hint {
+    font-size: 0.625rem;
+    color: var(--ctp-overlay0);
+  }
+
+  .toggle-label {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    cursor: pointer;
+  }
+
+  .toggle-switch {
+    position: relative;
+    width: 2rem;
+    height: 1.125rem;
+    border: none;
+    border-radius: 0.5625rem;
+    background: var(--ctp-surface1);
+    cursor: pointer;
+    transition: background 0.2s;
+    padding: 0;
+    flex-shrink: 0;
+  }
+
+  .toggle-switch.on {
+    background: var(--ctp-blue);
+  }
+
+  .toggle-thumb {
+    position: absolute;
+    top: 0.125rem;
+    left: 0.125rem;
+    width: 0.875rem;
+    height: 0.875rem;
+    border-radius: 50%;
+    background: var(--ctp-text);
+    transition: transform 0.2s;
+  }
+
+  .toggle-switch.on .toggle-thumb {
+    transform: translateX(0.875rem);
+  }
+
+  /* Provider section */
+  .provider-list {
+    display: flex;
+    flex-direction: column;
+    gap: 0.375rem;
+  }
+
+  .provider-panel {
+    background: var(--ctp-surface0);
+    border: 1px solid var(--ctp-surface1);
+    border-radius: 0.375rem;
+    overflow: hidden;
+    transition: opacity 0.15s;
+  }
+
+  .provider-panel.disabled {
+    opacity: 0.5;
+  }
+
+  .provider-header {
+    display: flex;
+    align-items: center;
+    gap: 0.5rem;
+    width: 100%;
+    padding: 0.5rem 0.625rem;
+    background: transparent;
+    border: none;
+    color: var(--ctp-text);
+    cursor: pointer;
+    text-align: left;
+    font-size: 0.8rem;
+  }
+
+  .provider-header:hover {
+    background: var(--ctp-base);
+  }
+
+  .provider-name {
+    font-weight: 600;
+    white-space: nowrap;
+  }
+
+  .provider-desc {
+    flex: 1;
+    color: var(--ctp-overlay0);
+    font-size: 0.7rem;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+  }
+
+  .provider-chevron {
+    color: var(--ctp-overlay0);
+    font-size: 0.7rem;
+    flex-shrink: 0;
+  }
+
+  .provider-body {
+    padding: 0.5rem 0.625rem;
+    border-top: 1px solid var(--ctp-surface1);
+    display: flex;
+    flex-direction: column;
+    gap: 0.5rem;
+  }
+
+  .provider-body > .setting-field > input {
+    padding: 0.375rem 0.625rem;
+    background: var(--ctp-base);
+    border: 1px solid var(--ctp-surface1);
+    border-radius: 0.25rem;
+    color: var(--ctp-text);
+    font-size: 0.8rem;
+  }
+
+  .provider-caps {
+    display: flex;
+    flex-direction: column;
+    gap: 0.25rem;
+  }
+
+  .caps-grid {
+    display: flex;
+    flex-wrap: wrap;
+    gap: 0.25rem;
+  }
+
+  .cap-badge {
+    padding: 0.125rem 0.5rem;
+    background: color-mix(in srgb, var(--ctp-blue) 10%, transparent);
+    color: var(--ctp-blue);
+    border-radius: 0.75rem;
+    font-size: 0.65rem;
+    font-weight: 500;
+    white-space: nowrap;
+  }
+
+  .provider-trigger {
+    padding: 0.25rem 0.5rem;
+    background: var(--ctp-base);
+    font-size: 0.78rem;
+  }
+
+  /* Agent config cards */
+  .agent-cards {
+    display: flex;
+    flex-direction: column;
+    gap: 0.5rem;
+  }
+
+  .agent-config-card {
+    background: var(--ctp-surface0);
+    border: 1px solid var(--ctp-surface1);
+    border-left: 3px solid var(--ctp-mauve);
+    border-radius: 0.5rem;
+    padding: 0.625rem 0.75rem;
+    display: flex;
+    flex-direction: column;
+    gap: 0.5rem;
+    transition: border-color 0.15s;
+  }
+
+  .agent-config-card:hover {
+    border-color: var(--ctp-surface2);
+    border-left-color: var(--ctp-mauve);
+  }
+
+  .agent-config-icon {
+    font-size: 1.1rem;
+    flex-shrink: 0;
+  }
+
+  .agent-role-badge {
+    font-size: 0.6rem;
+    font-weight: 600;
+    text-transform: uppercase;
+    letter-spacing: 0.04em;
+    color: var(--ctp-mauve);
+    background: color-mix(in srgb, var(--ctp-mauve) 10%, transparent);
+    padding: 0.125rem 0.375rem;
+    border-radius: 0.25rem;
+    flex-shrink: 0;
+  }
+
+  .card-field-input {
+    padding: 0.3125rem 0.5rem;
+    background: var(--ctp-base);
+    border: 1px solid var(--ctp-surface1);
+    border-radius: 0.25rem;
+    color: var(--ctp-text);
+    font-size: 0.78rem;
+  }
+
+  .card-field-input:focus {
+    border-color: var(--ctp-blue);
+    outline: none;
+  }
+
+  .agent-prompt-input {
+    padding: 0.375rem 0.5rem;
+    background: var(--ctp-base);
+    border: 1px solid var(--ctp-surface1);
+    border-radius: 0.25rem;
+    color: var(--ctp-text);
+    font-size: 0.75rem;
+    font-family: var(--ui-font-family, sans-serif);
+    line-height: 1.4;
+    resize: vertical;
+    min-height: 3rem;
+  }
+
+  .agent-prompt-input:focus {
+    border-color: var(--ctp-blue);
+    outline: none;
+  }
+
+  .agent-prompt-input::placeholder {
+    color: var(--ctp-overlay0);
+  }
+
+  .prompt-preview {
+    border: 1px solid var(--ctp-surface1);
+    border-radius: 0.25rem;
+    overflow: hidden;
+  }
+
+  .prompt-preview-toggle {
+    display: flex;
+    align-items: center;
+    gap: 0.375rem;
+    padding: 0.3125rem 0.5rem;
+    font-size: 0.65rem;
+    color: var(--ctp-overlay0);
+    cursor: pointer;
+    user-select: none;
+    transition: color 0.15s;
+  }
+
+  .prompt-preview-toggle:hover {
+    color: var(--ctp-subtext0);
+  }
+
+  .prompt-preview-content {
+    padding: 0.5rem;
+    margin: 0;
+    background: var(--ctp-base);
+    color: var(--ctp-subtext0);
+    font-size: 0.65rem;
+    font-family: var(--term-font-family, monospace);
+    line-height: 1.45;
+    white-space: pre-wrap;
+    word-break: break-word;
+    max-height: 20rem;
+    overflow-y: auto;
+    border-top: 1px solid var(--ctp-surface1);
+  }
+
+  /* Secrets section */
+  .secrets-status {
+    display: flex;
+    align-items: center;
+    gap: 0.5rem;
+    margin-bottom: 0.625rem;
+  }
+
+  .keyring-indicator {
+    width: 8px;
+    height: 8px;
+    border-radius: 50%;
+    flex-shrink: 0;
+  }
+
+  .keyring-indicator.available {
+    background: var(--ctp-green);
+    box-shadow: 0 0 4px color-mix(in srgb, var(--ctp-green) 50%, transparent);
+  }
+
+  .keyring-indicator.unavailable {
+    background: var(--ctp-red);
+    box-shadow: 0 0 4px color-mix(in srgb, var(--ctp-red) 50%, transparent);
+  }
+
+  .keyring-label {
+    font-size: 0.75rem;
+    color: var(--ctp-subtext0);
+  }
+
+  .secrets-warning {
+    display: flex;
+    align-items: center;
+    gap: 0.5rem;
+    padding: 0.5rem 0.625rem;
+    background: color-mix(in srgb, var(--ctp-red) 8%, var(--ctp-surface0));
+    border: 1px solid color-mix(in srgb, var(--ctp-red) 30%, var(--ctp-surface1));
+    border-radius: 0.375rem;
+    color: var(--ctp-red);
+    font-size: 0.75rem;
+    line-height: 1.4;
+  }
+
+  .secrets-warning svg {
+    flex-shrink: 0;
+  }
+
+  .secrets-list {
+    display: flex;
+    flex-direction: column;
+    gap: 0.375rem;
+    margin-bottom: 0.625rem;
+  }
+
+  .secret-row {
+    display: flex;
+    align-items: center;
+    gap: 0.5rem;
+    padding: 0.375rem 0.625rem;
+    background: var(--ctp-surface0);
+    border: 1px solid var(--ctp-surface1);
+    border-radius: 0.375rem;
+    transition: border-color 0.15s;
+  }
+
+  .secret-row:hover {
+    border-color: var(--ctp-surface2);
+  }
+
+  .secret-info {
+    display: flex;
+    flex-direction: column;
+    gap: 0.0625rem;
+    min-width: 0;
+    flex-shrink: 0;
+  }
+
+  .secret-key-name {
+    font-size: 0.78rem;
+    font-weight: 600;
+    color: var(--ctp-text);
+    white-space: nowrap;
+  }
+
+  .secret-key-id {
+    font-size: 0.625rem;
+    color: var(--ctp-overlay0);
+    font-family: var(--term-font-family, monospace);
+  }
+
+  .secret-value-area {
+    flex: 1;
+    min-width: 0;
+    display: flex;
+    align-items: center;
+  }
+
+  .secret-masked {
+    color: var(--ctp-overlay0);
+    font-size: 0.75rem;
+    letter-spacing: 0.1em;
+  }
+
+  .secret-value-input {
+    width: 100%;
+    padding: 0.25rem 0.5rem;
+    background: var(--ctp-base);
+    border: 1px solid var(--ctp-surface1);
+    border-radius: 0.25rem;
+    color: var(--ctp-text);
+    font-size: 0.75rem;
+    font-family: var(--term-font-family, monospace);
+  }
+
+  .secret-actions {
+    display: flex;
+    gap: 0.25rem;
+    flex-shrink: 0;
+  }
+
+  .secret-btn {
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    width: 1.75rem;
+    height: 1.75rem;
+    background: transparent;
+    border: 1px solid var(--ctp-surface1);
+    border-radius: 0.25rem;
+    color: var(--ctp-overlay1);
+    cursor: pointer;
+    transition: color 0.15s, background 0.15s, border-color 0.15s;
+  }
+
+  .secret-btn:hover {
+    color: var(--ctp-text);
+    background: var(--ctp-surface0);
+    border-color: var(--ctp-surface2);
+  }
+
+  .secret-btn-danger:hover {
+    color: var(--ctp-red);
+    background: color-mix(in srgb, var(--ctp-red) 8%, transparent);
+    border-color: color-mix(in srgb, var(--ctp-red) 30%, var(--ctp-surface1));
+  }
+
+  .secret-add-form {
+    padding: 0.5rem 0.625rem;
+    background: var(--ctp-mantle);
+    border: 1px dashed var(--ctp-surface1);
+    border-radius: 0.375rem;
+  }
+
+  .secret-add-row {
+    display: flex;
+    gap: 0.375rem;
+    align-items: stretch;
+  }
+
+  .secret-key-dropdown {
+    min-width: 10rem;
+    flex-shrink: 0;
+  }
+
+  .secret-key-hint {
+    font-size: 0.625rem;
+    color: var(--ctp-overlay0);
+    font-family: var(--term-font-family, monospace);
+    margin-left: auto;
+    padding-left: 0.5rem;
+  }
+
+  .dropdown-empty {
+    display: block;
+    padding: 0.375rem 0.625rem;
+    font-size: 0.75rem;
+    color: var(--ctp-overlay0);
+    font-style: italic;
+  }
+
+  .secret-value-new {
+    flex: 1;
+    min-width: 0;
+    padding: 0.375rem 0.625rem;
+    background: var(--ctp-surface0);
+    border: 1px solid var(--ctp-surface1);
+    border-radius: 0.25rem;
+    color: var(--ctp-text);
+    font-size: 0.8rem;
+  }
+
+  .secret-value-new:disabled {
+    opacity: 0.4;
+    cursor: not-allowed;
+  }
+
+  .secret-value-new:focus {
+    border-color: var(--ctp-blue);
+    outline: none;
+  }
+
+  /* --- Plugins section --- */
+
+  .plugin-list {
+    display: flex;
+    flex-direction: column;
+    gap: 0.5rem;
+    margin-bottom: 0.625rem;
+  }
+
+  .plugin-row {
+    position: relative;
+    background: var(--ctp-surface0);
+    border-radius: 0.375rem;
+    padding: 0.5rem 0.75rem;
+  }
+
+  .plugin-info {
+    display: flex;
+    align-items: center;
+    gap: 0.375rem;
+    margin-bottom: 0.125rem;
+  }
+
+  .plugin-name {
+    font-size: 0.82rem;
+    font-weight: 600;
+    color: var(--ctp-text);
+  }
+
+  .plugin-version {
+    font-size: 0.68rem;
+    color: var(--ctp-overlay0);
+  }
+
+  .plugin-badge {
+    font-size: 0.6rem;
+    padding: 0.05rem 0.3rem;
+    border-radius: 0.1875rem;
+    font-weight: 600;
+    text-transform: uppercase;
+    letter-spacing: 0.03em;
+  }
+
+  .plugin-badge.loaded {
+    background: color-mix(in srgb, var(--ctp-green) 20%, transparent);
+    color: var(--ctp-green);
+  }
+
+  .plugin-badge.error {
+    background: color-mix(in srgb, var(--ctp-red) 20%, transparent);
+    color: var(--ctp-red);
+  }
+
+  .plugin-badge.disabled {
+    background: color-mix(in srgb, var(--ctp-overlay0) 20%, transparent);
+    color: var(--ctp-overlay0);
+  }
+
+  .plugin-badge.discovered {
+    background: color-mix(in srgb, var(--ctp-blue) 20%, transparent);
+    color: var(--ctp-blue);
+  }
+
+  .plugin-desc {
+    font-size: 0.75rem;
+    color: var(--ctp-subtext0);
+    margin: 0.125rem 0 0.25rem;
+  }
+
+  .plugin-perms {
+    display: flex;
+    gap: 0.25rem;
+    flex-wrap: wrap;
+    margin-top: 0.125rem;
+  }
+
+  .perm-badge {
+    font-size: 0.6rem;
+    padding: 0.05rem 0.25rem;
+    border-radius: 0.125rem;
+    background: color-mix(in srgb, var(--ctp-mauve) 15%, transparent);
+    color: var(--ctp-mauve);
+    font-family: var(--font-mono, monospace);
+  }
+
+  .plugin-error {
+    font-size: 0.7rem;
+    color: var(--ctp-red);
+    margin: 0.25rem 0 0;
+    word-break: break-word;
+  }
+
+  .plugin-row .card-toggle {
+    position: absolute;
+    top: 0.5rem;
+    right: 0.5rem;
+  }
+
+  .empty-notice {
+    font-size: 0.78rem;
+    color: var(--ctp-overlay0);
+    margin: 0 0 0.5rem;
+  }
+
+  .reload-plugins-btn {
+    margin-top: 0.25rem;
+  }
+</style>
diff --git a/v2/src/lib/components/Workspace/SshTab.svelte b/v2/src/lib/components/Workspace/SshTab.svelte
new file mode 100644
index 0000000..91c698a
--- /dev/null
+++ b/v2/src/lib/components/Workspace/SshTab.svelte
@@ -0,0 +1,425 @@
+<script lang="ts">
+  import { onMount } from 'svelte';
+  import { listSshSessions, saveSshSession, deleteSshSession, type SshSession } from '../../adapters/ssh-bridge';
+  import { addTerminalTab } from '../../stores/workspace.svelte';
+
+  interface Props {
+    projectId: string;
+  }
+
+  let { projectId }: Props = $props();
+
+  let sessions = $state<SshSession[]>([]);
+  let loading = $state(true);
+  let editing = $state<SshSession | null>(null);
+  let showForm = $state(false);
+
+  // Form fields
+  let formName = $state('');
+  let formHost = $state('');
+  let formPort = $state(22);
+  let formUsername = $state('');
+  let formKeyFile = $state('');
+  let formFolder = $state('');
+
+  onMount(loadSessions);
+
+  async function loadSessions() {
+    loading = true;
+    try {
+      sessions = await listSshSessions();
+    } catch (e) {
+      console.warn('Failed to load SSH sessions:', e);
+    } finally {
+      loading = false;
+    }
+  }
+
+  function resetForm() {
+    formName = '';
+    formHost = '';
+    formPort = 22;
+    formUsername = '';
+    formKeyFile = '';
+    formFolder = '';
+    editing = null;
+    showForm = false;
+  }
+
+  function editSession(session: SshSession) {
+    formName = session.name;
+    formHost = session.host;
+    formPort = session.port;
+    formUsername = session.username;
+    formKeyFile = session.key_file;
+    formFolder = session.folder;
+    editing = session;
+    showForm = true;
+  }
+
+  function startNew() {
+    resetForm();
+    showForm = true;
+  }
+
+  async function saveForm() {
+    if (!formName.trim() || !formHost.trim()) return;
+
+    const session: SshSession = {
+      id: editing?.id ?? crypto.randomUUID(),
+      name: formName.trim(),
+      host: formHost.trim(),
+      port: formPort,
+      username: formUsername.trim() || 'root',
+      key_file: formKeyFile.trim(),
+      folder: formFolder.trim(),
+      color: editing?.color ?? '',
+      created_at: editing?.created_at ?? Date.now(),
+      last_used_at: Date.now(),
+    };
+
+    try {
+      await saveSshSession(session);
+      await loadSessions();
+      resetForm();
+    } catch (e) {
+      console.warn('Failed to save SSH session:', e);
+    }
+  }
+
+  async function removeSession(id: string) {
+    try {
+      await deleteSshSession(id);
+      await loadSessions();
+    } catch (e) {
+      console.warn('Failed to delete SSH session:', e);
+    }
+  }
+
+  function launchSession(session: SshSession) {
+    addTerminalTab(projectId, {
+      id: `ssh-${session.id}-${Date.now()}`,
+      title: `SSH: ${session.name}`,
+      type: 'ssh',
+      sshSessionId: session.id,
+    });
+  }
+</script>
+
+<div class="ssh-tab">
+  <div class="ssh-header">
+    <h3>SSH Connections</h3>
+    <button class="add-btn" onclick={startNew}>+ New</button>
+  </div>
+
+  {#if showForm}
+    <div class="ssh-form">
+      <div class="form-title">{editing ? 'Edit Connection' : 'New Connection'}</div>
+      <div class="form-grid">
+        <label class="form-label">
+          <span>Name</span>
+          <input type="text" bind:value={formName} placeholder="My Server" />
+        </label>
+        <label class="form-label">
+          <span>Host</span>
+          <input type="text" bind:value={formHost} placeholder="192.168.1.100" />
+        </label>
+        <label class="form-label">
+          <span>Port</span>
+          <input type="number" bind:value={formPort} min="1" max="65535" />
+        </label>
+        <label class="form-label">
+          <span>Username</span>
+          <input type="text" bind:value={formUsername} placeholder="root" />
+        </label>
+        <label class="form-label">
+          <span>Key File</span>
+          <input type="text" bind:value={formKeyFile} placeholder="~/.ssh/id_ed25519" />
+        </label>
+        <label class="form-label">
+          <span>Remote Folder</span>
+          <input type="text" bind:value={formFolder} placeholder="/home/user" />
+        </label>
+      </div>
+      <div class="form-actions">
+        <button class="btn-cancel" onclick={resetForm}>Cancel</button>
+        <button class="btn-save" onclick={saveForm} disabled={!formName.trim() || !formHost.trim()}>
+          {editing ? 'Update' : 'Save'}
+        </button>
+      </div>
+    </div>
+  {/if}
+
+  <div class="ssh-list">
+    {#if loading}
+      <div class="ssh-empty">Loading…</div>
+    {:else if sessions.length === 0 && !showForm}
+      <div class="ssh-empty">
+        <p>No SSH connections configured.</p>
+        <p>Add a connection to launch it as a terminal in the Model tab.</p>
+      </div>
+    {:else}
+      {#each sessions as session (session.id)}
+        <div class="ssh-card">
+          <div class="ssh-card-info">
+            <span class="ssh-card-name">{session.name}</span>
+            <span class="ssh-card-detail">{session.username}@{session.host}:{session.port}</span>
+            {#if session.folder}
+              <span class="ssh-card-folder">{session.folder}</span>
+            {/if}
+          </div>
+          <div class="ssh-card-actions">
+            <button class="ssh-btn launch" onclick={() => launchSession(session)} title="Launch in terminal">
+              ▶
+            </button>
+            <button class="ssh-btn edit" onclick={() => editSession(session)} title="Edit">
+              ✎
+            </button>
+            <button class="ssh-btn delete" onclick={() => removeSession(session.id)} title="Delete">
+              ✕
+            </button>
+          </div>
+        </div>
+      {/each}
+    {/if}
+  </div>
+</div>
+
+<style>
+  .ssh-tab {
+    display: flex;
+    flex-direction: column;
+    height: 100%;
+    background: var(--ctp-base);
+    color: var(--ctp-text);
+    overflow: hidden;
+  }
+
+  .ssh-header {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    padding: 0.5rem 0.75rem;
+    border-bottom: 1px solid var(--ctp-surface0);
+    flex-shrink: 0;
+  }
+
+  .ssh-header h3 {
+    font-size: 0.8rem;
+    font-weight: 600;
+    color: var(--ctp-blue);
+    margin: 0;
+  }
+
+  .add-btn {
+    background: var(--ctp-surface0);
+    border: none;
+    color: var(--ctp-text);
+    font-size: 0.7rem;
+    font-weight: 500;
+    padding: 0.2rem 0.5rem;
+    border-radius: 0.25rem;
+    cursor: pointer;
+    transition: background 0.12s;
+  }
+
+  .add-btn:hover {
+    background: var(--ctp-surface1);
+  }
+
+  .ssh-form {
+    padding: 0.75rem;
+    border-bottom: 1px solid var(--ctp-surface0);
+    background: var(--ctp-mantle);
+    flex-shrink: 0;
+  }
+
+  .form-title {
+    font-size: 0.725rem;
+    font-weight: 600;
+    color: var(--ctp-subtext1);
+    margin-bottom: 0.5rem;
+  }
+
+  .form-grid {
+    display: grid;
+    grid-template-columns: 1fr 1fr;
+    gap: 0.375rem;
+  }
+
+  .form-label {
+    display: flex;
+    flex-direction: column;
+    gap: 0.125rem;
+  }
+
+  .form-label span {
+    font-size: 0.625rem;
+    font-weight: 500;
+    color: var(--ctp-overlay1);
+    text-transform: uppercase;
+    letter-spacing: 0.03em;
+  }
+
+  .form-label input {
+    background: var(--ctp-surface0);
+    border: 1px solid var(--ctp-surface0);
+    border-radius: 0.25rem;
+    color: var(--ctp-text);
+    font-size: 0.725rem;
+    padding: 0.25rem 0.375rem;
+    font-family: var(--term-font-family, monospace);
+  }
+
+  .form-label input:focus {
+    outline: none;
+    border-color: var(--ctp-blue);
+  }
+
+  .form-actions {
+    display: flex;
+    gap: 0.375rem;
+    justify-content: flex-end;
+    margin-top: 0.5rem;
+  }
+
+  .btn-cancel, .btn-save {
+    padding: 0.25rem 0.625rem;
+    border: none;
+    border-radius: 0.25rem;
+    font-size: 0.7rem;
+    font-weight: 500;
+    cursor: pointer;
+    transition: opacity 0.12s;
+  }
+
+  .btn-cancel {
+    background: var(--ctp-surface0);
+    color: var(--ctp-subtext0);
+  }
+
+  .btn-cancel:hover {
+    background: var(--ctp-surface1);
+  }
+
+  .btn-save {
+    background: var(--ctp-blue);
+    color: var(--ctp-base);
+  }
+
+  .btn-save:hover:not(:disabled) {
+    opacity: 0.85;
+  }
+
+  .btn-save:disabled {
+    opacity: 0.4;
+    cursor: not-allowed;
+  }
+
+  .ssh-list {
+    flex: 1;
+    overflow-y: auto;
+    padding: 0.5rem;
+  }
+
+  .ssh-empty {
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    justify-content: center;
+    height: 100%;
+    color: var(--ctp-overlay0);
+    font-size: 0.75rem;
+    text-align: center;
+    gap: 0.25rem;
+  }
+
+  .ssh-empty p {
+    margin: 0;
+  }
+
+  .ssh-card {
+    display: flex;
+    align-items: center;
+    gap: 0.5rem;
+    padding: 0.5rem 0.625rem;
+    background: var(--ctp-surface0);
+    border-radius: 0.25rem;
+    margin-bottom: 0.375rem;
+    transition: background 0.12s;
+  }
+
+  .ssh-card:hover {
+    background: var(--ctp-surface1);
+  }
+
+  .ssh-card-info {
+    flex: 1;
+    min-width: 0;
+    display: flex;
+    flex-direction: column;
+    gap: 0.125rem;
+  }
+
+  .ssh-card-name {
+    font-size: 0.75rem;
+    font-weight: 600;
+    color: var(--ctp-text);
+  }
+
+  .ssh-card-detail {
+    font-size: 0.65rem;
+    font-family: var(--term-font-family, monospace);
+    color: var(--ctp-subtext0);
+  }
+
+  .ssh-card-folder {
+    font-size: 0.6rem;
+    color: var(--ctp-overlay0);
+    font-family: var(--term-font-family, monospace);
+  }
+
+  .ssh-card-actions {
+    display: flex;
+    gap: 0.25rem;
+    flex-shrink: 0;
+  }
+
+  .ssh-btn {
+    width: 1.5rem;
+    height: 1.5rem;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    border: none;
+    border-radius: 0.25rem;
+    background: transparent;
+    cursor: pointer;
+    font-size: 0.7rem;
+    transition: background 0.12s, color 0.12s;
+  }
+
+  .ssh-btn.launch {
+    color: var(--ctp-green);
+  }
+
+  .ssh-btn.launch:hover {
+    background: color-mix(in srgb, var(--ctp-green) 15%, transparent);
+  }
+
+  .ssh-btn.edit {
+    color: var(--ctp-blue);
+  }
+
+  .ssh-btn.edit:hover {
+    background: color-mix(in srgb, var(--ctp-blue) 15%, transparent);
+  }
+
+  .ssh-btn.delete {
+    color: var(--ctp-red);
+  }
+
+  .ssh-btn.delete:hover {
+    background: color-mix(in srgb, var(--ctp-red) 15%, transparent);
+  }
+</style>
diff --git a/v2/src/lib/components/Workspace/TaskBoardTab.svelte b/v2/src/lib/components/Workspace/TaskBoardTab.svelte
new file mode 100644
index 0000000..4042bdc
--- /dev/null
+++ b/v2/src/lib/components/Workspace/TaskBoardTab.svelte
@@ -0,0 +1,582 @@
+<script lang="ts">
+  import { onMount, onDestroy } from 'svelte';
+  import { listTasks, updateTaskStatus, createTask, deleteTask, addTaskComment, type Task, type TaskComment, getTaskComments } from '../../adapters/bttask-bridge';
+  import type { GroupId } from '../../types/ids';
+  import { AgentId } from '../../types/ids';
+
+  interface Props {
+    groupId: GroupId;
+    projectId?: string;
+  }
+
+  let { groupId, projectId }: Props = $props();
+
+  const STATUSES = ['todo', 'progress', 'review', 'done', 'blocked'] as const;
+  const STATUS_LABELS: Record<string, string> = {
+    todo: 'To Do',
+    progress: 'In Progress',
+    review: 'Review',
+    done: 'Done',
+    blocked: 'Blocked',
+  };
+  const STATUS_ICONS: Record<string, string> = {
+    todo: '○',
+    progress: '◐',
+    review: '◑',
+    done: '●',
+    blocked: '✗',
+  };
+  const PRIORITY_LABELS: Record<string, string> = {
+    critical: 'CRIT',
+    high: 'HIGH',
+    medium: 'MED',
+    low: 'LOW',
+  };
+
+  let tasks = $state<Task[]>([]);
+  let loading = $state(true);
+  let error = $state<string | null>(null);
+  let pollTimer: ReturnType<typeof setInterval> | null = null;
+
+  // New task form
+  let showAddForm = $state(false);
+  let newTitle = $state('');
+  let newDesc = $state('');
+  let newPriority = $state('medium');
+
+  // Expanded task detail
+  let expandedTaskId = $state<string | null>(null);
+  let taskComments = $state<TaskComment[]>([]);
+  let newComment = $state('');
+
+  let tasksByStatus = $derived.by(() => {
+    const map: Record<string, Task[]> = {};
+    for (const s of STATUSES) map[s] = [];
+    for (const t of tasks) {
+      if (map[t.status]) map[t.status].push(t);
+    }
+    return map;
+  });
+
+  let pendingCount = $derived(
+    tasks.filter(t => t.status !== 'done').length
+  );
+
+  async function loadTasks() {
+    try {
+      tasks = await listTasks(groupId);
+      error = null;
+    } catch (e) {
+      error = String(e);
+    } finally {
+      loading = false;
+    }
+  }
+
+  onMount(() => {
+    loadTasks();
+    pollTimer = setInterval(loadTasks, 5000);
+  });
+
+  onDestroy(() => {
+    if (pollTimer) clearInterval(pollTimer);
+  });
+
+  async function handleStatusChange(taskId: string, newStatus: string) {
+    try {
+      const task = tasks.find(t => t.id === taskId);
+      const version = task?.version ?? 1;
+      await updateTaskStatus(taskId, newStatus, version);
+      await loadTasks();
+    } catch (e: any) {
+      const msg = e?.message ?? String(e);
+      if (msg.includes('version conflict')) {
+        console.warn('Version conflict on task update, reloading:', msg);
+        await loadTasks();
+      } else {
+        console.warn('Failed to update task status:', e);
+      }
+    }
+  }
+
+  async function handleAddTask() {
+    if (!newTitle.trim()) return;
+    try {
+      await createTask(newTitle.trim(), newDesc.trim(), newPriority, groupId, AgentId('admin'));
+      newTitle = '';
+      newDesc = '';
+      newPriority = 'medium';
+      showAddForm = false;
+      await loadTasks();
+    } catch (e) {
+      console.warn('Failed to create task:', e);
+    }
+  }
+
+  async function handleDelete(taskId: string) {
+    try {
+      await deleteTask(taskId);
+      if (expandedTaskId === taskId) expandedTaskId = null;
+      await loadTasks();
+    } catch (e) {
+      console.warn('Failed to delete task:', e);
+    }
+  }
+
+  async function toggleExpand(taskId: string) {
+    if (expandedTaskId === taskId) {
+      expandedTaskId = null;
+      return;
+    }
+    expandedTaskId = taskId;
+    try {
+      taskComments = await getTaskComments(taskId);
+    } catch {
+      taskComments = [];
+    }
+  }
+
+  async function handleAddComment() {
+    if (!expandedTaskId || !newComment.trim()) return;
+    try {
+      await addTaskComment(expandedTaskId, AgentId('admin'), newComment.trim());
+      newComment = '';
+      taskComments = await getTaskComments(expandedTaskId);
+    } catch (e) {
+      console.warn('Failed to add comment:', e);
+    }
+  }
+</script>
+
+<div class="task-board-tab">
+  <div class="board-header">
+    <span class="board-title">Task Board</span>
+    <span class="pending-badge" class:all-done={pendingCount === 0}>
+      {pendingCount === 0 ? 'All done' : `${pendingCount} pending`}
+    </span>
+    <button class="btn-add" onclick={() => showAddForm = !showAddForm}>
+      {showAddForm ? '✕' : '+ Task'}
+    </button>
+  </div>
+
+  {#if showAddForm}
+    <div class="add-task-form">
+      <input
+        class="task-title-input"
+        bind:value={newTitle}
+        placeholder="Task title"
+        onkeydown={e => { if (e.key === 'Enter') handleAddTask(); }}
+      />
+      <textarea
+        class="task-desc-input"
+        bind:value={newDesc}
+        placeholder="Description (optional)"
+        rows="2"
+      ></textarea>
+      <div class="form-row">
+        <select class="priority-select" bind:value={newPriority}>
+          <option value="low">Low</option>
+          <option value="medium">Medium</option>
+          <option value="high">High</option>
+          <option value="critical">Critical</option>
+        </select>
+        <button class="btn-create" onclick={handleAddTask} disabled={!newTitle.trim()}>Create</button>
+      </div>
+    </div>
+  {/if}
+
+  {#if loading}
+    <div class="loading">Loading tasks...</div>
+  {:else if error}
+    <div class="error">{error}</div>
+  {:else}
+    <div class="kanban">
+      {#each STATUSES as status}
+        <div class="kanban-column">
+          <div class="column-header">
+            <span class="column-icon">{STATUS_ICONS[status]}</span>
+            <span class="column-title">{STATUS_LABELS[status]}</span>
+            <span class="column-count">{tasksByStatus[status].length}</span>
+          </div>
+          <div class="column-cards">
+            {#each tasksByStatus[status] as task (task.id)}
+              <div
+                class="task-card"
+                class:expanded={expandedTaskId === task.id}
+                class:critical={task.priority === 'critical'}
+                class:high={task.priority === 'high'}
+              >
+                <button class="task-card-body" onclick={() => toggleExpand(task.id)}>
+                  <span class="task-priority priority-{task.priority}">{PRIORITY_LABELS[task.priority]}</span>
+                  <span class="task-title">{task.title}</span>
+                  {#if task.assignedTo}
+                    <span class="task-assignee">{task.assignedTo}</span>
+                  {/if}
+                </button>
+
+                {#if expandedTaskId === task.id}
+                  <div class="task-detail">
+                    {#if task.description}
+                      <p class="task-description">{task.description}</p>
+                    {/if}
+
+                    <div class="status-actions">
+                      {#each STATUSES as s}
+                        <button
+                          class="status-btn"
+                          class:active={task.status === s}
+                          onclick={() => handleStatusChange(task.id, s)}
+                        >{STATUS_ICONS[s]} {STATUS_LABELS[s]}</button>
+                      {/each}
+                    </div>
+
+                    {#if taskComments.length > 0}
+                      <div class="comments-list">
+                        {#each taskComments as comment}
+                          <div class="comment">
+                            <span class="comment-agent">{comment.agentId}</span>
+                            <span class="comment-text">{comment.content}</span>
+                          </div>
+                        {/each}
+                      </div>
+                    {/if}
+
+                    <div class="comment-form">
+                      <input
+                        class="comment-input"
+                        bind:value={newComment}
+                        placeholder="Add comment..."
+                        onkeydown={e => { if (e.key === 'Enter') handleAddComment(); }}
+                      />
+                    </div>
+
+                    <button class="btn-delete" onclick={() => handleDelete(task.id)}>Delete</button>
+                  </div>
+                {/if}
+              </div>
+            {/each}
+          </div>
+        </div>
+      {/each}
+    </div>
+  {/if}
+</div>
+
+<style>
+  .task-board-tab {
+    display: flex;
+    flex-direction: column;
+    height: 100%;
+    overflow: hidden;
+    padding: 0.5rem;
+    gap: 0.5rem;
+  }
+
+  .board-header {
+    display: flex;
+    align-items: center;
+    gap: 0.5rem;
+    flex-shrink: 0;
+  }
+
+  .board-title {
+    font-size: 0.8rem;
+    font-weight: 600;
+    color: var(--ctp-text);
+  }
+
+  .pending-badge {
+    font-size: 0.65rem;
+    padding: 0.125rem 0.375rem;
+    border-radius: 0.5rem;
+    background: color-mix(in srgb, var(--ctp-yellow) 15%, transparent);
+    color: var(--ctp-yellow);
+    font-weight: 600;
+  }
+
+  .pending-badge.all-done {
+    background: color-mix(in srgb, var(--ctp-green) 15%, transparent);
+    color: var(--ctp-green);
+  }
+
+  .btn-add {
+    margin-left: auto;
+    padding: 0.2rem 0.5rem;
+    background: var(--ctp-surface0);
+    border: 1px solid var(--ctp-surface1);
+    border-radius: 0.25rem;
+    color: var(--ctp-subtext0);
+    font-size: 0.7rem;
+    cursor: pointer;
+  }
+
+  .btn-add:hover {
+    background: var(--ctp-surface1);
+    color: var(--ctp-text);
+  }
+
+  .add-task-form {
+    display: flex;
+    flex-direction: column;
+    gap: 0.375rem;
+    padding: 0.5rem;
+    background: var(--ctp-surface0);
+    border-radius: 0.375rem;
+    flex-shrink: 0;
+  }
+
+  .task-title-input, .task-desc-input, .comment-input {
+    padding: 0.3125rem 0.5rem;
+    background: var(--ctp-base);
+    border: 1px solid var(--ctp-surface1);
+    border-radius: 0.25rem;
+    color: var(--ctp-text);
+    font-size: 0.75rem;
+  }
+
+  .task-desc-input {
+    resize: vertical;
+    min-height: 2rem;
+    font-family: var(--ui-font-family, sans-serif);
+  }
+
+  .form-row {
+    display: flex;
+    gap: 0.375rem;
+    align-items: center;
+  }
+
+  .priority-select {
+    padding: 0.25rem 0.375rem;
+    background: var(--ctp-base);
+    border: 1px solid var(--ctp-surface1);
+    border-radius: 0.25rem;
+    color: var(--ctp-text);
+    font-size: 0.7rem;
+  }
+
+  .btn-create {
+    padding: 0.25rem 0.625rem;
+    background: var(--ctp-blue);
+    color: var(--ctp-base);
+    border: none;
+    border-radius: 0.25rem;
+    font-size: 0.7rem;
+    font-weight: 600;
+    cursor: pointer;
+  }
+
+  .btn-create:disabled {
+    opacity: 0.4;
+    cursor: default;
+  }
+
+  .loading, .error {
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    flex: 1;
+    font-size: 0.8rem;
+    color: var(--ctp-overlay0);
+  }
+
+  .error { color: var(--ctp-red); }
+
+  .kanban {
+    display: flex;
+    gap: 0.375rem;
+    flex: 1;
+    overflow-x: auto;
+    overflow-y: hidden;
+  }
+
+  .kanban-column {
+    flex: 1;
+    min-width: 8rem;
+    display: flex;
+    flex-direction: column;
+    overflow: hidden;
+  }
+
+  .column-header {
+    display: flex;
+    align-items: center;
+    gap: 0.25rem;
+    padding: 0.25rem 0.375rem;
+    font-size: 0.6rem;
+    font-weight: 600;
+    text-transform: uppercase;
+    letter-spacing: 0.04em;
+    color: var(--ctp-overlay0);
+    border-bottom: 1px solid var(--ctp-surface0);
+    flex-shrink: 0;
+  }
+
+  .column-icon { font-size: 0.7rem; }
+
+  .column-count {
+    margin-left: auto;
+    font-size: 0.55rem;
+    background: var(--ctp-surface0);
+    padding: 0 0.25rem;
+    border-radius: 0.5rem;
+  }
+
+  .column-cards {
+    flex: 1;
+    overflow-y: auto;
+    display: flex;
+    flex-direction: column;
+    gap: 0.25rem;
+    padding: 0.25rem 0;
+  }
+
+  .task-card {
+    background: var(--ctp-surface0);
+    border: 1px solid var(--ctp-surface1);
+    border-radius: 0.25rem;
+    transition: border-color 0.15s;
+  }
+
+  .task-card:hover {
+    border-color: var(--ctp-surface2);
+  }
+
+  .task-card.critical {
+    border-left: 2px solid var(--ctp-red);
+  }
+
+  .task-card.high {
+    border-left: 2px solid var(--ctp-yellow);
+  }
+
+  .task-card-body {
+    display: flex;
+    flex-wrap: wrap;
+    align-items: center;
+    gap: 0.25rem;
+    padding: 0.3125rem 0.375rem;
+    background: transparent;
+    border: none;
+    color: var(--ctp-text);
+    font-size: 0.7rem;
+    text-align: left;
+    cursor: pointer;
+    width: 100%;
+  }
+
+  .task-priority {
+    font-size: 0.5rem;
+    font-weight: 700;
+    padding: 0.0625rem 0.25rem;
+    border-radius: 0.125rem;
+    letter-spacing: 0.03em;
+    flex-shrink: 0;
+  }
+
+  .priority-critical { background: var(--ctp-red); color: var(--ctp-base); }
+  .priority-high { background: var(--ctp-yellow); color: var(--ctp-base); }
+  .priority-medium { background: var(--ctp-surface1); color: var(--ctp-subtext0); }
+  .priority-low { background: var(--ctp-surface0); color: var(--ctp-overlay0); }
+
+  .task-title {
+    flex: 1;
+    min-width: 0;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+  }
+
+  .task-assignee {
+    font-size: 0.55rem;
+    color: var(--ctp-overlay0);
+    background: var(--ctp-base);
+    padding: 0.0625rem 0.25rem;
+    border-radius: 0.125rem;
+  }
+
+  .task-detail {
+    padding: 0.375rem;
+    border-top: 1px solid var(--ctp-surface1);
+    display: flex;
+    flex-direction: column;
+    gap: 0.375rem;
+  }
+
+  .task-description {
+    margin: 0;
+    font-size: 0.7rem;
+    color: var(--ctp-subtext0);
+    line-height: 1.4;
+  }
+
+  .status-actions {
+    display: flex;
+    flex-wrap: wrap;
+    gap: 0.25rem;
+  }
+
+  .status-btn {
+    padding: 0.125rem 0.375rem;
+    background: var(--ctp-base);
+    border: 1px solid var(--ctp-surface1);
+    border-radius: 0.25rem;
+    color: var(--ctp-overlay0);
+    font-size: 0.6rem;
+    cursor: pointer;
+  }
+
+  .status-btn.active {
+    background: var(--ctp-surface1);
+    color: var(--ctp-text);
+    font-weight: 600;
+  }
+
+  .status-btn:hover {
+    border-color: var(--ctp-surface2);
+    color: var(--ctp-text);
+  }
+
+  .comments-list {
+    display: flex;
+    flex-direction: column;
+    gap: 0.25rem;
+    max-height: 8rem;
+    overflow-y: auto;
+  }
+
+  .comment {
+    font-size: 0.65rem;
+    color: var(--ctp-subtext0);
+  }
+
+  .comment-agent {
+    font-weight: 600;
+    color: var(--ctp-blue);
+    margin-right: 0.25rem;
+  }
+
+  .comment-form {
+    display: flex;
+    gap: 0.25rem;
+  }
+
+  .comment-input {
+    flex: 1;
+    font-size: 0.65rem;
+  }
+
+  .btn-delete {
+    align-self: flex-end;
+    padding: 0.125rem 0.375rem;
+    background: transparent;
+    border: none;
+    color: var(--ctp-overlay0);
+    font-size: 0.6rem;
+    cursor: pointer;
+  }
+
+  .btn-delete:hover {
+    color: var(--ctp-red);
+  }
+</style>
diff --git a/v2/src/lib/components/Workspace/TeamAgentsPanel.svelte b/v2/src/lib/components/Workspace/TeamAgentsPanel.svelte
new file mode 100644
index 0000000..5707693
--- /dev/null
+++ b/v2/src/lib/components/Workspace/TeamAgentsPanel.svelte
@@ -0,0 +1,91 @@
+<script lang="ts">
+  import { getAgentSessions, getChildSessions, type AgentSession } from '../../stores/agents.svelte';
+  import AgentCard from './AgentCard.svelte';
+
+  interface Props {
+    /** The main Claude session ID for this project */
+    mainSessionId: string;
+  }
+
+  let { mainSessionId }: Props = $props();
+
+  // Get subagent sessions spawned by the main session
+  let childSessions = $derived(getChildSessions(mainSessionId));
+  let hasAgents = $derived(childSessions.length > 0);
+  let expanded = $state(true);
+</script>
+
+{#if hasAgents}
+  <div class="team-agents-panel">
+    <button class="panel-header" onclick={() => expanded = !expanded}>
+      <span class="header-icon">{expanded ? '▾' : '▸'}</span>
+      <span class="header-title">Team Agents</span>
+      <span class="agent-count">{childSessions.length}</span>
+    </button>
+
+    {#if expanded}
+      <div class="agent-list">
+        {#each childSessions as child (child.id)}
+          <AgentCard session={child} />
+        {/each}
+      </div>
+    {/if}
+  </div>
+{/if}
+
+<style>
+  .team-agents-panel {
+    border-left: 1px solid var(--ctp-surface0);
+    background: var(--ctp-mantle);
+    display: flex;
+    flex-direction: column;
+    overflow: hidden;
+    width: 13.75rem;
+    flex-shrink: 0;
+  }
+
+  .panel-header {
+    display: flex;
+    align-items: center;
+    gap: 0.25rem;
+    padding: 0.3125rem 0.5rem;
+    background: transparent;
+    border: none;
+    color: var(--ctp-subtext0);
+    font-size: 0.72rem;
+    cursor: pointer;
+    border-bottom: 1px solid var(--ctp-surface0);
+    text-transform: uppercase;
+    letter-spacing: 0.04em;
+  }
+
+  .panel-header:hover {
+    color: var(--ctp-text);
+  }
+
+  .header-icon {
+    font-size: 0.65rem;
+  }
+
+  .header-title {
+    font-weight: 600;
+  }
+
+  .agent-count {
+    margin-left: auto;
+    background: var(--ctp-surface0);
+    padding: 0 0.3125rem;
+    border-radius: 0.5rem;
+    font-size: 0.65rem;
+    color: var(--ctp-overlay1);
+  }
+
+  .agent-list {
+    display: flex;
+    flex-direction: column;
+    gap: 0.1875rem;
+    padding: 0.25rem;
+    overflow-y: auto;
+    flex: 1;
+  }
+</style>
diff --git a/v2/src/lib/components/Workspace/TerminalTabs.svelte b/v2/src/lib/components/Workspace/TerminalTabs.svelte
new file mode 100644
index 0000000..a316179
--- /dev/null
+++ b/v2/src/lib/components/Workspace/TerminalTabs.svelte
@@ -0,0 +1,275 @@
+<script lang="ts">
+  import { onMount } from 'svelte';
+  import type { ProjectConfig } from '../../types/groups';
+  import {
+    getTerminalTabs,
+    addTerminalTab,
+    removeTerminalTab,
+    type TerminalTab,
+  } from '../../stores/workspace.svelte';
+  import { listSshSessions, type SshSession } from '../../adapters/ssh-bridge';
+  import TerminalPane from '../Terminal/TerminalPane.svelte';
+  import AgentPreviewPane from '../Terminal/AgentPreviewPane.svelte';
+
+  /** Cached SSH sessions for building args */
+  let sshSessions = $state<SshSession[]>([]);
+
+  onMount(() => {
+    listSshSessions().then(s => { sshSessions = s; }).catch(() => {});
+  });
+
+  /** Resolved SSH args per tab, keyed by tab id */
+  let sshArgsCache = $derived.by(() => {
+    const cache: Record<string, string[]> = {};
+    for (const tab of tabs) {
+      if (tab.type !== 'ssh' || !tab.sshSessionId) continue;
+      const session = sshSessions.find(s => s.id === tab.sshSessionId);
+      if (!session) continue;
+      const args: string[] = [];
+      if (session.key_file) args.push('-i', session.key_file);
+      if (session.port && session.port !== 22) args.push('-p', String(session.port));
+      args.push(`${session.username}@${session.host}`);
+      cache[tab.id] = args;
+    }
+    return cache;
+  });
+
+  interface Props {
+    project: ProjectConfig;
+    agentSessionId?: string | null;
+  }
+
+  let { project, agentSessionId }: Props = $props();
+
+  let tabs = $derived(getTerminalTabs(project.id));
+  let activeTabId = $state<string | null>(null);
+
+  // Auto-select first tab
+  $effect(() => {
+    if (tabs.length > 0 && (!activeTabId || !tabs.find(t => t.id === activeTabId))) {
+      activeTabId = tabs[0].id;
+    }
+    if (tabs.length === 0) {
+      activeTabId = null;
+    }
+  });
+
+  function addShellTab() {
+    const id = crypto.randomUUID();
+    const num = tabs.filter(t => t.type === 'shell').length + 1;
+    addTerminalTab(project.id, {
+      id,
+      title: `Shell ${num}`,
+      type: 'shell',
+    });
+    activeTabId = id;
+  }
+
+  function addAgentPreviewTab() {
+    if (!agentSessionId) return;
+    // Don't create duplicate — check if one already exists for this session
+    const existing = tabs.find(
+      t => t.type === 'agent-preview' && t.agentSessionId === agentSessionId,
+    );
+    if (existing) {
+      activeTabId = existing.id;
+      return;
+    }
+    const id = crypto.randomUUID();
+    addTerminalTab(project.id, {
+      id,
+      title: 'Agent Preview',
+      type: 'agent-preview',
+      agentSessionId,
+    });
+    activeTabId = id;
+  }
+
+  function closeTab(tabId: string) {
+    removeTerminalTab(project.id, tabId);
+  }
+
+  function handleTabExit(tabId: string) {
+    closeTab(tabId);
+  }
+</script>
+
+<div class="terminal-tabs" data-testid="terminal-tabs">
+  <div class="tab-bar">
+    {#each tabs as tab (tab.id)}
+      <div
+        class="tab"
+        class:active={activeTabId === tab.id}
+        role="tab"
+        tabindex="0"
+        onclick={() => (activeTabId = tab.id)}
+        onkeydown={e => e.key === 'Enter' && (activeTabId = tab.id)}
+      >
+        <span class="tab-title">{tab.title}</span>
+        <button
+          class="tab-close"
+          onclick={(e) => { e.stopPropagation(); closeTab(tab.id); }}
+          title="Close"
+        >×</button>
+      </div>
+    {/each}
+    <button class="tab-add" data-testid="tab-add" onclick={addShellTab} title="New shell">+</button>
+    {#if agentSessionId}
+      <button
+        class="tab-add tab-agent-preview"
+        onclick={addAgentPreviewTab}
+        title="Watch agent activity"
+      >👁</button>
+    {/if}
+  </div>
+
+  <div class="tab-content">
+    {#each tabs as tab (tab.id)}
+      <div class="tab-pane" style:display={activeTabId === tab.id ? 'block' : 'none'}>
+        {#if tab.type === 'agent-preview' && tab.agentSessionId}
+          {#if activeTabId === tab.id}
+            <AgentPreviewPane sessionId={tab.agentSessionId} />
+          {/if}
+        {:else if tab.type === 'ssh' && sshArgsCache[tab.id]}
+          <TerminalPane
+            cwd={project.cwd}
+            shell="/usr/bin/ssh"
+            args={sshArgsCache[tab.id]}
+            onExit={() => handleTabExit(tab.id)}
+          />
+        {:else if tab.type === 'shell'}
+          <TerminalPane
+            cwd={project.cwd}
+            onExit={() => handleTabExit(tab.id)}
+          />
+        {/if}
+      </div>
+    {/each}
+
+    {#if tabs.length === 0}
+      <div class="empty-terminals">
+        <button class="add-first" onclick={addShellTab}>
+          + Open terminal
+        </button>
+      </div>
+    {/if}
+  </div>
+</div>
+
+<style>
+  .terminal-tabs {
+    display: flex;
+    flex-direction: column;
+    height: 100%;
+  }
+
+  .tab-bar {
+    display: flex;
+    align-items: center;
+    gap: 1px;
+    padding: 0 0.25rem;
+    background: var(--ctp-mantle);
+    border-bottom: 1px solid var(--ctp-surface0);
+    overflow-x: auto;
+    flex-shrink: 0;
+  }
+
+  .tab {
+    display: flex;
+    align-items: center;
+    gap: 0.25rem;
+    padding: 0.25rem 0.5rem;
+    background: transparent;
+    border: none;
+    color: var(--ctp-overlay1);
+    font-size: 0.72rem;
+    cursor: pointer;
+    border-radius: 0.1875rem 0.1875rem 0 0;
+    white-space: nowrap;
+    transition: color 0.1s, background 0.1s;
+  }
+
+  .tab:hover {
+    color: var(--ctp-text);
+    background: var(--ctp-surface0);
+  }
+
+  .tab.active {
+    color: var(--ctp-text);
+    background: var(--ctp-base);
+    border-bottom: 1px solid var(--ctp-blue);
+  }
+
+  .tab-title {
+    max-width: 6.25rem;
+    overflow: hidden;
+    text-overflow: ellipsis;
+  }
+
+  .tab-close {
+    background: transparent;
+    border: none;
+    color: var(--ctp-overlay0);
+    font-size: 0.8rem;
+    cursor: pointer;
+    padding: 0 0.125rem;
+    line-height: 1;
+  }
+
+  .tab-close:hover {
+    color: var(--ctp-red);
+  }
+
+  .tab-add {
+    background: transparent;
+    border: none;
+    color: var(--ctp-overlay0);
+    font-size: 0.85rem;
+    cursor: pointer;
+    padding: 0.125rem 0.375rem;
+    border-radius: 0.1875rem;
+  }
+
+  .tab-add:hover {
+    color: var(--ctp-text);
+    background: var(--ctp-surface0);
+  }
+
+  .tab-agent-preview {
+    font-size: 0.7rem;
+  }
+
+  .tab-content {
+    flex: 1;
+    position: relative;
+    overflow: hidden;
+  }
+
+  .tab-pane {
+    position: absolute;
+    inset: 0;
+  }
+
+  .empty-terminals {
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    height: 100%;
+  }
+
+  .add-first {
+    padding: 0.375rem 1rem;
+    background: var(--ctp-surface0);
+    border: 1px solid var(--ctp-surface1);
+    border-radius: 0.25rem;
+    color: var(--ctp-subtext0);
+    font-size: 0.8rem;
+    cursor: pointer;
+    transition: background 0.15s, color 0.15s;
+  }
+
+  .add-first:hover {
+    background: var(--ctp-surface1);
+    color: var(--ctp-text);
+  }
+</style>
diff --git a/v2/src/lib/components/Workspace/TestingTab.svelte b/v2/src/lib/components/Workspace/TestingTab.svelte
new file mode 100644
index 0000000..7a258b6
--- /dev/null
+++ b/v2/src/lib/components/Workspace/TestingTab.svelte
@@ -0,0 +1,428 @@
+<script lang="ts">
+  import { onMount, onDestroy } from 'svelte';
+  import { convertFileSrc } from '@tauri-apps/api/core';
+  import { listDirectoryChildren, readFileContent, type DirEntry } from '../../adapters/files-bridge';
+
+  interface Props {
+    cwd: string;
+    mode: 'selenium' | 'tests';
+  }
+
+  let { cwd, mode }: Props = $props();
+
+  // ─── Selenium mode ────────────────────────────────────────
+  let seleniumConnected = $state(false);
+  let screenshots = $state<string[]>([]);
+  let selectedScreenshot = $state<string | null>(null);
+  let seleniumLog = $state<string[]>([]);
+  let seleniumPollTimer: ReturnType<typeof setInterval> | null = null;
+
+  const SCREENSHOTS_DIR = '.selenium/screenshots';
+  const SELENIUM_LOG = '.selenium/session.log';
+
+  async function loadSeleniumState() {
+    const screenshotPath = `${cwd}/${SCREENSHOTS_DIR}`;
+    try {
+      const entries = await listDirectoryChildren(screenshotPath);
+      const imageFiles = entries
+        .filter(e => /\.(png|jpg|jpeg|webp)$/i.test(e.name))
+        .map(e => e.path)
+        .sort()
+        .reverse();
+      screenshots = imageFiles;
+
+      // Select latest if nothing selected
+      if (!selectedScreenshot && imageFiles.length > 0) {
+        selectedScreenshot = imageFiles[0];
+      }
+      seleniumConnected = imageFiles.length > 0;
+    } catch {
+      screenshots = [];
+      seleniumConnected = false;
+    }
+
+    // Load session log
+    try {
+      const content = await readFileContent(`${cwd}/${SELENIUM_LOG}`);
+      if (content.type === 'Text') {
+        seleniumLog = content.content.split('\n').filter(Boolean).slice(-50);
+      }
+    } catch {
+      seleniumLog = [];
+    }
+  }
+
+  // ─── Tests mode ───────────────────────────────────────────
+  let testFiles = $state<DirEntry[]>([]);
+  let selectedTestFile = $state<string | null>(null);
+  let testOutput = $state('');
+  let testRunning = $state(false);
+  let lastTestResult = $state<'pass' | 'fail' | null>(null);
+
+  const TEST_DIRS = ['tests', 'test', '__tests__', 'spec', 'e2e'];
+
+  async function loadTestFiles() {
+    for (const dir of TEST_DIRS) {
+      try {
+        const entries = await listDirectoryChildren(`${cwd}/${dir}`);
+        const tests = entries.filter(e =>
+          /\.(test|spec)\.(ts|js|py|rs)$/.test(e.name) ||
+          /test_.*\.py$/.test(e.name)
+        );
+        if (tests.length > 0) {
+          testFiles = tests;
+          return;
+        }
+      } catch {
+        // Directory doesn't exist, try next
+      }
+    }
+    testFiles = [];
+  }
+
+  async function viewTestFile(filePath: string) {
+    selectedTestFile = filePath;
+    try {
+      const content = await readFileContent(filePath);
+      if (content.type === 'Text') {
+        testOutput = content.content;
+      }
+    } catch (e) {
+      testOutput = `Error: ${e}`;
+    }
+  }
+
+  onMount(() => {
+    if (mode === 'selenium') {
+      loadSeleniumState();
+      seleniumPollTimer = setInterval(loadSeleniumState, 3000);
+    } else {
+      loadTestFiles();
+    }
+  });
+
+  onDestroy(() => {
+    if (seleniumPollTimer) clearInterval(seleniumPollTimer);
+  });
+</script>
+
+<div class="testing-tab">
+  {#if mode === 'selenium'}
+    <!-- Selenium Live View -->
+    <div class="selenium-view">
+      <div class="selenium-sidebar">
+        <div class="sidebar-header">
+          <span class="sidebar-title">Screenshots</span>
+          <span class="status-dot" class:connected={seleniumConnected}></span>
+        </div>
+        <div class="screenshot-list">
+          {#each screenshots as path}
+            <button
+              class="screenshot-item"
+              class:active={selectedScreenshot === path}
+              onclick={() => selectedScreenshot = path}
+            >
+              <span class="screenshot-name">{path.split('/').pop()}</span>
+            </button>
+          {/each}
+          {#if screenshots.length === 0}
+            <div class="empty-hint">
+              No screenshots yet. The Tester agent saves screenshots to <code>{SCREENSHOTS_DIR}/</code>
+            </div>
+          {/if}
+        </div>
+
+        <div class="log-section">
+          <div class="sidebar-header">
+            <span class="sidebar-title">Session Log</span>
+          </div>
+          <div class="log-output">
+            {#each seleniumLog as line}
+              <div class="log-line">{line}</div>
+            {/each}
+            {#if seleniumLog.length === 0}
+              <div class="empty-hint">No log entries</div>
+            {/if}
+          </div>
+        </div>
+      </div>
+
+      <div class="selenium-content">
+        {#if selectedScreenshot}
+          <div class="screenshot-preview">
+            <img
+              src={convertFileSrc(selectedScreenshot)}
+              alt="Selenium screenshot"
+              class="screenshot-img"
+            />
+          </div>
+        {:else}
+          <div class="empty-state">
+            Selenium screenshots will appear here during testing.
+            <br />
+            The Tester agent uses Selenium WebDriver for UI testing.
+          </div>
+        {/if}
+      </div>
+    </div>
+
+  {:else}
+    <!-- Automated Tests View -->
+    <div class="tests-view">
+      <div class="tests-sidebar">
+        <div class="sidebar-header">
+          <span class="sidebar-title">Test Files</span>
+          {#if lastTestResult}
+            <span class="result-badge" class:pass={lastTestResult === 'pass'} class:fail={lastTestResult === 'fail'}>
+              {lastTestResult === 'pass' ? '✓ PASS' : '✗ FAIL'}
+            </span>
+          {/if}
+        </div>
+        <div class="test-file-list">
+          {#each testFiles as file (file.path)}
+            <button
+              class="test-file-item"
+              class:active={selectedTestFile === file.path}
+              onclick={() => viewTestFile(file.path)}
+            >
+              <span class="test-icon">🧪</span>
+              <span class="test-name">{file.name}</span>
+            </button>
+          {/each}
+          {#if testFiles.length === 0}
+            <div class="empty-hint">
+              No test files found. The Tester agent creates tests in standard directories (tests/, test/, spec/).
+            </div>
+          {/if}
+        </div>
+      </div>
+
+      <div class="tests-content">
+        {#if selectedTestFile}
+          <div class="test-file-header">
+            <span class="test-file-name">{selectedTestFile.split('/').pop()}</span>
+          </div>
+          <pre class="test-output">{testOutput}</pre>
+        {:else}
+          <div class="empty-state">
+            Select a test file to view its contents.
+            <br />
+            The Tester agent runs tests via the terminal.
+          </div>
+        {/if}
+      </div>
+    </div>
+  {/if}
+</div>
+
+<style>
+  .testing-tab {
+    display: flex;
+    height: 100%;
+    overflow: hidden;
+  }
+
+  /* Shared sidebar patterns */
+  .selenium-sidebar, .tests-sidebar {
+    width: 12rem;
+    flex-shrink: 0;
+    border-right: 1px solid var(--ctp-surface0);
+    display: flex;
+    flex-direction: column;
+    overflow: hidden;
+  }
+
+  .sidebar-header {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    padding: 0.375rem 0.5rem;
+    border-bottom: 1px solid var(--ctp-surface0);
+  }
+
+  .sidebar-title {
+    font-size: 0.7rem;
+    font-weight: 600;
+    color: var(--ctp-subtext0);
+    text-transform: uppercase;
+    letter-spacing: 0.04em;
+  }
+
+  .status-dot {
+    width: 6px;
+    height: 6px;
+    border-radius: 50%;
+    background: var(--ctp-overlay0);
+  }
+
+  .status-dot.connected {
+    background: var(--ctp-green);
+    box-shadow: 0 0 4px var(--ctp-green);
+  }
+
+  .empty-hint {
+    padding: 0.5rem;
+    font-size: 0.65rem;
+    color: var(--ctp-overlay0);
+    line-height: 1.4;
+  }
+
+  .empty-hint code {
+    background: var(--ctp-surface0);
+    padding: 0.0625rem 0.25rem;
+    border-radius: 0.125rem;
+    font-size: 0.6rem;
+  }
+
+  .empty-state {
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    justify-content: center;
+    height: 100%;
+    color: var(--ctp-overlay0);
+    font-size: 0.8rem;
+    text-align: center;
+    line-height: 1.6;
+    padding: 1rem;
+  }
+
+  /* Selenium view */
+  .selenium-view, .tests-view {
+    display: flex;
+    flex: 1;
+    overflow: hidden;
+  }
+
+  .screenshot-list, .test-file-list {
+    flex: 1;
+    overflow-y: auto;
+    display: flex;
+    flex-direction: column;
+  }
+
+  .screenshot-item, .test-file-item {
+    display: flex;
+    align-items: center;
+    gap: 0.25rem;
+    padding: 0.3125rem 0.5rem;
+    background: transparent;
+    border: none;
+    color: var(--ctp-subtext0);
+    font-size: 0.65rem;
+    text-align: left;
+    cursor: pointer;
+    transition: background 0.1s;
+  }
+
+  .screenshot-item:hover, .test-file-item:hover {
+    background: var(--ctp-surface0);
+    color: var(--ctp-text);
+  }
+
+  .screenshot-item.active, .test-file-item.active {
+    background: var(--ctp-surface0);
+    color: var(--ctp-text);
+    font-weight: 600;
+  }
+
+  .screenshot-name, .test-name {
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+  }
+
+  .test-icon { font-size: 0.75rem; }
+
+  .log-section {
+    border-top: 1px solid var(--ctp-surface0);
+    display: flex;
+    flex-direction: column;
+    max-height: 40%;
+  }
+
+  .log-output {
+    flex: 1;
+    overflow-y: auto;
+    padding: 0.25rem 0.5rem;
+  }
+
+  .log-line {
+    font-size: 0.6rem;
+    font-family: var(--term-font-family, monospace);
+    color: var(--ctp-subtext0);
+    line-height: 1.4;
+    white-space: pre-wrap;
+    word-break: break-all;
+  }
+
+  .selenium-content, .tests-content {
+    flex: 1;
+    display: flex;
+    flex-direction: column;
+    overflow: hidden;
+  }
+
+  .screenshot-preview {
+    flex: 1;
+    overflow: auto;
+    display: flex;
+    align-items: flex-start;
+    justify-content: center;
+    padding: 0.5rem;
+    background: var(--ctp-mantle);
+  }
+
+  .screenshot-img {
+    max-width: 100%;
+    height: auto;
+    border-radius: 0.25rem;
+    border: 1px solid var(--ctp-surface0);
+  }
+
+  /* Tests view */
+  .result-badge {
+    font-size: 0.55rem;
+    font-weight: 700;
+    padding: 0.0625rem 0.25rem;
+    border-radius: 0.125rem;
+  }
+
+  .result-badge.pass {
+    background: color-mix(in srgb, var(--ctp-green) 15%, transparent);
+    color: var(--ctp-green);
+  }
+
+  .result-badge.fail {
+    background: color-mix(in srgb, var(--ctp-red) 15%, transparent);
+    color: var(--ctp-red);
+  }
+
+  .test-file-header {
+    display: flex;
+    align-items: center;
+    padding: 0.375rem 0.5rem;
+    border-bottom: 1px solid var(--ctp-surface0);
+    flex-shrink: 0;
+  }
+
+  .test-file-name {
+    font-size: 0.75rem;
+    font-weight: 600;
+    color: var(--ctp-text);
+  }
+
+  .test-output {
+    flex: 1;
+    overflow: auto;
+    padding: 0.5rem;
+    margin: 0;
+    background: var(--ctp-mantle);
+    color: var(--ctp-subtext0);
+    font-size: 0.7rem;
+    font-family: var(--term-font-family, monospace);
+    line-height: 1.5;
+    white-space: pre-wrap;
+    word-break: break-word;
+  }
+</style>
diff --git a/v2/src/lib/plugins/plugin-host.test.ts b/v2/src/lib/plugins/plugin-host.test.ts
new file mode 100644
index 0000000..0caf513
--- /dev/null
+++ b/v2/src/lib/plugins/plugin-host.test.ts
@@ -0,0 +1,373 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+// --- Mocks ---
+
+const { mockInvoke } = vi.hoisted(() => ({
+  mockInvoke: vi.fn(),
+}));
+
+vi.mock('@tauri-apps/api/core', () => ({
+  invoke: mockInvoke,
+}));
+
+// Mock the plugins store to avoid Svelte 5 rune issues in test context
+vi.mock('../stores/plugins.svelte', () => {
+  const commands: Array<{ pluginId: string; label: string; callback: () => void }> = [];
+  return {
+    addPluginCommand: vi.fn((pluginId: string, label: string, callback: () => void) => {
+      commands.push({ pluginId, label, callback });
+    }),
+    removePluginCommands: vi.fn((pluginId: string) => {
+      const toRemove = commands.filter(c => c.pluginId === pluginId);
+      for (const cmd of toRemove) {
+        const idx = commands.indexOf(cmd);
+        if (idx >= 0) commands.splice(idx, 1);
+      }
+    }),
+    pluginEventBus: {
+      on: vi.fn(),
+      off: vi.fn(),
+      emit: vi.fn(),
+      clear: vi.fn(),
+    },
+    getPluginCommands: () => [...commands],
+  };
+});
+
+import {
+  loadPlugin,
+  unloadPlugin,
+  getLoadedPlugins,
+  unloadAllPlugins,
+} from './plugin-host';
+import { addPluginCommand, removePluginCommands } from '../stores/plugins.svelte';
+import type { PluginMeta } from '../adapters/plugins-bridge';
+import type { GroupId, AgentId } from '../types/ids';
+
+// --- Helpers ---
+
+function makeMeta(overrides: Partial<PluginMeta> = {}): PluginMeta {
+  return {
+    id: overrides.id ?? 'test-plugin',
+    name: overrides.name ?? 'Test Plugin',
+    version: overrides.version ?? '1.0.0',
+    description: overrides.description ?? 'A test plugin',
+    main: overrides.main ?? 'index.js',
+    permissions: overrides.permissions ?? [],
+  };
+}
+
+/** Set mockInvoke to return the given code when plugin_read_file is called */
+function mockPluginCode(code: string): void {
+  mockInvoke.mockImplementation((cmd: string) => {
+    if (cmd === 'plugin_read_file') return Promise.resolve(code);
+    return Promise.reject(new Error(`Unexpected invoke: ${cmd}`));
+  });
+}
+
+const GROUP_ID = 'test-group' as GroupId;
+const AGENT_ID = 'test-agent' as AgentId;
+
+beforeEach(() => {
+  vi.clearAllMocks();
+  unloadAllPlugins();
+});
+
+// --- Sandbox escape prevention tests ---
+
+describe('plugin-host sandbox', () => {
+  describe('global shadowing', () => {
+    // `eval` is intentionally excluded: `var eval` is a SyntaxError in strict mode.
+    // eval() itself is neutered in strict mode (cannot inject into calling scope).
+    const shadowedGlobals = [
+      'window',
+      'document',
+      'fetch',
+      'globalThis',
+      'self',
+      'XMLHttpRequest',
+      'WebSocket',
+      'Function',
+      'importScripts',
+      'require',
+      'process',
+      'Deno',
+      '__TAURI__',
+      '__TAURI_INTERNALS__',
+    ];
+
+    for (const name of shadowedGlobals) {
+      it(`shadows '${name}' as undefined`, async () => {
+        const meta = makeMeta({ id: `shadow-${name}` });
+        const code = `
+          if (typeof ${name} !== 'undefined') {
+            throw new Error('ESCAPE: ${name} is accessible');
+          }
+        `;
+        mockPluginCode(code);
+        await expect(loadPlugin(meta, GROUP_ID, AGENT_ID)).resolves.toBeUndefined();
+      });
+    }
+  });
+
+  describe('this binding', () => {
+    it('this is undefined in strict mode (cannot reach global scope)', async () => {
+      const meta = makeMeta({ id: 'this-test' });
+      mockPluginCode(`
+        if (this !== undefined) {
+          throw new Error('ESCAPE: this is not undefined, got: ' + typeof this);
+        }
+      `);
+      await expect(loadPlugin(meta, GROUP_ID, AGENT_ID)).resolves.toBeUndefined();
+    });
+  });
+
+  describe('runtime-level shadowing', () => {
+    it('require is shadowed (blocks CJS imports)', async () => {
+      const meta = makeMeta({ id: 'require-test' });
+      mockPluginCode(`
+        if (typeof require !== 'undefined') {
+          throw new Error('ESCAPE: require is accessible');
+        }
+      `);
+      await expect(loadPlugin(meta, GROUP_ID, AGENT_ID)).resolves.toBeUndefined();
+    });
+
+    it('process is shadowed (blocks env access)', async () => {
+      const meta = makeMeta({ id: 'process-test' });
+      mockPluginCode(`
+        if (typeof process !== 'undefined') {
+          throw new Error('ESCAPE: process is accessible');
+        }
+      `);
+      await expect(loadPlugin(meta, GROUP_ID, AGENT_ID)).resolves.toBeUndefined();
+    });
+
+    it('Deno is shadowed', async () => {
+      const meta = makeMeta({ id: 'deno-test' });
+      mockPluginCode(`
+        if (typeof Deno !== 'undefined') {
+          throw new Error('ESCAPE: Deno is accessible');
+        }
+      `);
+      await expect(loadPlugin(meta, GROUP_ID, AGENT_ID)).resolves.toBeUndefined();
+    });
+  });
+
+  describe('Tauri IPC shadowing', () => {
+    it('__TAURI__ is shadowed (blocks Tauri IPC bridge)', async () => {
+      const meta = makeMeta({ id: 'tauri-test' });
+      mockPluginCode(`
+        if (typeof __TAURI__ !== 'undefined') {
+          throw new Error('ESCAPE: __TAURI__ is accessible');
+        }
+      `);
+      await expect(loadPlugin(meta, GROUP_ID, AGENT_ID)).resolves.toBeUndefined();
+    });
+
+    it('__TAURI_INTERNALS__ is shadowed', async () => {
+      const meta = makeMeta({ id: 'tauri-internals-test' });
+      mockPluginCode(`
+        if (typeof __TAURI_INTERNALS__ !== 'undefined') {
+          throw new Error('ESCAPE: __TAURI_INTERNALS__ is accessible');
+        }
+      `);
+      await expect(loadPlugin(meta, GROUP_ID, AGENT_ID)).resolves.toBeUndefined();
+    });
+  });
+});
+
+// --- Permission-gated API tests ---
+
+describe('plugin-host permissions', () => {
+  describe('palette permission', () => {
+    it('plugin with palette permission can register commands', async () => {
+      const meta = makeMeta({ id: 'palette-plugin', permissions: ['palette'] });
+      mockPluginCode(`
+        bterminal.palette.registerCommand('Test Command', function() {});
+      `);
+
+      await loadPlugin(meta, GROUP_ID, AGENT_ID);
+
+      expect(addPluginCommand).toHaveBeenCalledWith(
+        'palette-plugin',
+        'Test Command',
+        expect.any(Function),
+      );
+    });
+
+    it('plugin without palette permission has no palette API', async () => {
+      const meta = makeMeta({ id: 'no-palette-plugin', permissions: [] });
+      mockPluginCode(`
+        if (bterminal.palette !== undefined) {
+          throw new Error('palette API should not be available');
+        }
+      `);
+      await expect(loadPlugin(meta, GROUP_ID, AGENT_ID)).resolves.toBeUndefined();
+    });
+
+    it('palette.registerCommand rejects non-string label', async () => {
+      const meta = makeMeta({ id: 'bad-label-plugin', permissions: ['palette'] });
+      mockPluginCode(`
+        bterminal.palette.registerCommand(123, function() {});
+      `);
+      await expect(loadPlugin(meta, GROUP_ID, AGENT_ID)).rejects.toThrow(
+        'execution failed',
+      );
+    });
+
+    it('palette.registerCommand rejects non-function callback', async () => {
+      const meta = makeMeta({ id: 'bad-cb-plugin', permissions: ['palette'] });
+      mockPluginCode(`
+        bterminal.palette.registerCommand('Test', 'not-a-function');
+      `);
+      await expect(loadPlugin(meta, GROUP_ID, AGENT_ID)).rejects.toThrow(
+        'execution failed',
+      );
+    });
+
+    it('palette.registerCommand rejects empty label', async () => {
+      const meta = makeMeta({ id: 'empty-label-plugin', permissions: ['palette'] });
+      mockPluginCode(`
+        bterminal.palette.registerCommand('   ', function() {});
+      `);
+      await expect(loadPlugin(meta, GROUP_ID, AGENT_ID)).rejects.toThrow(
+        'execution failed',
+      );
+    });
+  });
+
+  describe('API object is frozen', () => {
+    it('cannot add properties to bterminal', async () => {
+      const meta = makeMeta({ id: 'freeze-test', permissions: [] });
+      // In strict mode, assigning to a frozen object throws TypeError
+      mockPluginCode(`
+        try {
+          bterminal.hacked = true;
+          throw new Error('FREEZE FAILED: could add property');
+        } catch (e) {
+          if (e.message === 'FREEZE FAILED: could add property') throw e;
+          // TypeError from strict mode + frozen object is expected
+        }
+      `);
+      await expect(loadPlugin(meta, GROUP_ID, AGENT_ID)).resolves.toBeUndefined();
+    });
+
+    it('cannot delete properties from bterminal', async () => {
+      const meta = makeMeta({ id: 'freeze-delete-test', permissions: [] });
+      mockPluginCode(`
+        try {
+          delete bterminal.meta;
+          throw new Error('FREEZE FAILED: could delete property');
+        } catch (e) {
+          if (e.message === 'FREEZE FAILED: could delete property') throw e;
+        }
+      `);
+      await expect(loadPlugin(meta, GROUP_ID, AGENT_ID)).resolves.toBeUndefined();
+    });
+  });
+});
+
+// --- Lifecycle tests ---
+
+describe('plugin-host lifecycle', () => {
+  it('loadPlugin registers the plugin', async () => {
+    const meta = makeMeta({ id: 'lifecycle-load' });
+    mockPluginCode('// no-op');
+
+    await loadPlugin(meta, GROUP_ID, AGENT_ID);
+
+    const loaded = getLoadedPlugins();
+    expect(loaded).toHaveLength(1);
+    expect(loaded[0].id).toBe('lifecycle-load');
+  });
+
+  it('loadPlugin warns on duplicate load and returns early', async () => {
+    const meta = makeMeta({ id: 'duplicate-load' });
+    mockPluginCode('// no-op');
+
+    await loadPlugin(meta, GROUP_ID, AGENT_ID);
+
+    const consoleSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+    await loadPlugin(meta, GROUP_ID, AGENT_ID);
+    expect(consoleSpy).toHaveBeenCalledWith("Plugin 'duplicate-load' is already loaded");
+    consoleSpy.mockRestore();
+
+    // Still only one entry
+    expect(getLoadedPlugins()).toHaveLength(1);
+  });
+
+  it('unloadPlugin removes the plugin and cleans up commands', async () => {
+    const meta = makeMeta({ id: 'lifecycle-unload', permissions: ['palette'] });
+    mockPluginCode(`
+      bterminal.palette.registerCommand('Cmd1', function() {});
+    `);
+
+    await loadPlugin(meta, GROUP_ID, AGENT_ID);
+    expect(getLoadedPlugins()).toHaveLength(1);
+
+    unloadPlugin('lifecycle-unload');
+    expect(getLoadedPlugins()).toHaveLength(0);
+    expect(removePluginCommands).toHaveBeenCalledWith('lifecycle-unload');
+  });
+
+  it('unloadPlugin is no-op for unknown plugin', () => {
+    unloadPlugin('nonexistent');
+    expect(getLoadedPlugins()).toHaveLength(0);
+  });
+
+  it('unloadAllPlugins clears all loaded plugins', async () => {
+    mockPluginCode('// no-op');
+
+    const meta1 = makeMeta({ id: 'all-1' });
+    await loadPlugin(meta1, GROUP_ID, AGENT_ID);
+
+    const meta2 = makeMeta({ id: 'all-2' });
+    await loadPlugin(meta2, GROUP_ID, AGENT_ID);
+
+    expect(getLoadedPlugins()).toHaveLength(2);
+
+    unloadAllPlugins();
+    expect(getLoadedPlugins()).toHaveLength(0);
+  });
+
+  it('loadPlugin cleans up commands on execution error', async () => {
+    const meta = makeMeta({ id: 'error-cleanup' });
+    mockPluginCode('throw new Error("plugin crash");');
+
+    await expect(loadPlugin(meta, GROUP_ID, AGENT_ID)).rejects.toThrow(
+      "Plugin 'error-cleanup' execution failed",
+    );
+    expect(removePluginCommands).toHaveBeenCalledWith('error-cleanup');
+    expect(getLoadedPlugins()).toHaveLength(0);
+  });
+
+  it('loadPlugin throws on file read failure', async () => {
+    const meta = makeMeta({ id: 'read-fail' });
+    mockInvoke.mockRejectedValue(new Error('file not found'));
+
+    await expect(loadPlugin(meta, GROUP_ID, AGENT_ID)).rejects.toThrow(
+      "Failed to read plugin 'read-fail'",
+    );
+  });
+
+  it('plugin meta is accessible and frozen', async () => {
+    const meta = makeMeta({ id: 'meta-access', permissions: [] });
+    mockPluginCode(`
+      if (bterminal.meta.id !== 'meta-access') {
+        throw new Error('meta.id mismatch');
+      }
+      if (bterminal.meta.name !== 'Test Plugin') {
+        throw new Error('meta.name mismatch');
+      }
+      // meta should also be frozen
+      try {
+        bterminal.meta.id = 'hacked';
+        throw new Error('META FREEZE FAILED');
+      } catch (e) {
+        if (e.message === 'META FREEZE FAILED') throw e;
+      }
+    `);
+    await expect(loadPlugin(meta, GROUP_ID, AGENT_ID)).resolves.toBeUndefined();
+  });
+});
diff --git a/v2/src/lib/plugins/plugin-host.ts b/v2/src/lib/plugins/plugin-host.ts
new file mode 100644
index 0000000..de32f89
--- /dev/null
+++ b/v2/src/lib/plugins/plugin-host.ts
@@ -0,0 +1,213 @@
+/**
+ * Plugin Host — sandboxed runtime for BTerminal plugins.
+ *
+ * Plugins run via `new Function()` with a controlled API object (`bterminal`).
+ * Dangerous globals are shadowed via `var` declarations inside strict mode.
+ *
+ * SECURITY BOUNDARY: Best-effort sandbox, NOT a security boundary.
+ * `new Function()` executes in the same JS realm. Known limitations:
+ *  - `arguments.callee.constructor('return this')()` can recover the real global
+ *    object — this is inherent to `new Function()` and cannot be fully blocked
+ *    without a separate realm (iframe, Worker, or wasm-based isolate).
+ *  - Prototype chain walking (e.g., `({}).constructor.constructor`) can also
+ *    reach Function and thus the global scope.
+ *  - Plugins MUST be treated as UNTRUSTED. This sandbox reduces the attack
+ *    surface but does not eliminate it. Defense in depth comes from the Rust
+ *    backend's Landlock sandbox and permission-gated Tauri commands.
+ */
+
+import type { PluginMeta } from '../adapters/plugins-bridge';
+import { readPluginFile } from '../adapters/plugins-bridge';
+import { listTasks, getTaskComments } from '../adapters/bttask-bridge';
+import {
+  getUnreadMessages,
+  getChannels,
+} from '../adapters/btmsg-bridge';
+import {
+  addPluginCommand,
+  removePluginCommands,
+  pluginEventBus,
+} from '../stores/plugins.svelte';
+import type { GroupId, AgentId } from '../types/ids';
+
+interface LoadedPlugin {
+  meta: PluginMeta;
+  cleanup: () => void;
+}
+
+const loadedPlugins = new Map<string, LoadedPlugin>();
+
+/**
+ * Build the sandboxed API object for a plugin.
+ * Only exposes capabilities matching the plugin's declared permissions.
+ */
+function buildPluginAPI(meta: PluginMeta, groupId: GroupId, agentId: AgentId): Record<string, unknown> {
+  const api: Record<string, unknown> = {
+    meta: Object.freeze({ ...meta }),
+  };
+
+  // palette permission — register command palette commands
+  if (meta.permissions.includes('palette')) {
+    api.palette = {
+      registerCommand(label: string, callback: () => void) {
+        if (typeof label !== 'string' || !label.trim()) {
+          throw new Error('Command label must be a non-empty string');
+        }
+        if (typeof callback !== 'function') {
+          throw new Error('Command callback must be a function');
+        }
+        addPluginCommand(meta.id, label, callback);
+      },
+    };
+  }
+
+  // bttask:read permission — read-only task access
+  if (meta.permissions.includes('bttask:read')) {
+    api.tasks = {
+      async list() {
+        return listTasks(groupId);
+      },
+      async comments(taskId: string) {
+        return getTaskComments(taskId);
+      },
+    };
+  }
+
+  // btmsg:read permission — read-only message access
+  if (meta.permissions.includes('btmsg:read')) {
+    api.messages = {
+      async inbox() {
+        return getUnreadMessages(agentId);
+      },
+      async channels() {
+        return getChannels(groupId);
+      },
+    };
+  }
+
+  // events permission — subscribe to app events
+  if (meta.permissions.includes('events')) {
+    const subscriptions: Array<{ event: string; callback: (data: unknown) => void }> = [];
+
+    api.events = {
+      on(event: string, callback: (data: unknown) => void) {
+        if (typeof event !== 'string' || typeof callback !== 'function') {
+          throw new Error('event.on requires (string, function)');
+        }
+        pluginEventBus.on(event, callback);
+        subscriptions.push({ event, callback });
+      },
+      off(event: string, callback: (data: unknown) => void) {
+        pluginEventBus.off(event, callback);
+        const idx = subscriptions.findIndex(s => s.event === event && s.callback === callback);
+        if (idx >= 0) subscriptions.splice(idx, 1);
+      },
+    };
+
+    // Return a cleanup function that removes all subscriptions
+    const originalCleanup = () => {
+      for (const sub of subscriptions) {
+        pluginEventBus.off(sub.event, sub.callback);
+      }
+      subscriptions.length = 0;
+    };
+    // Attach to meta for later use
+    (api as { _eventCleanup?: () => void })._eventCleanup = originalCleanup;
+  }
+
+  return api;
+}
+
+/**
+ * Load and execute a plugin in a sandboxed context.
+ */
+export async function loadPlugin(
+  meta: PluginMeta,
+  groupId: GroupId,
+  agentId: AgentId,
+): Promise<void> {
+  if (loadedPlugins.has(meta.id)) {
+    console.warn(`Plugin '${meta.id}' is already loaded`);
+    return;
+  }
+
+  // Read the plugin's entry file
+  let code: string;
+  try {
+    code = await readPluginFile(meta.id, meta.main);
+  } catch (e) {
+    throw new Error(`Failed to read plugin '${meta.id}' entry file '${meta.main}': ${e}`);
+  }
+
+  const api = buildPluginAPI(meta, groupId, agentId);
+
+  // Execute the plugin code in a sandbox via new Function().
+  // The plugin receives `bterminal` as its only external reference.
+  // No access to window, document, fetch, globalThis, etc.
+  try {
+    const sandbox = new Function(
+      'bterminal',
+      // Explicitly shadow dangerous globals.
+      // `var` declarations in strict mode shadow the outer scope names,
+      // making direct references resolve to `undefined`.
+      // See file-level JSDoc for known limitations of this approach.
+      `"use strict";
+       var window = undefined;
+       var document = undefined;
+       var fetch = undefined;
+       var globalThis = undefined;
+       var self = undefined;
+       var XMLHttpRequest = undefined;
+       var WebSocket = undefined;
+       var Function = undefined;
+       var importScripts = undefined;
+       var require = undefined;
+       var process = undefined;
+       var Deno = undefined;
+       var __TAURI__ = undefined;
+       var __TAURI_INTERNALS__ = undefined;
+       ${code}`,
+    );
+    // Bind `this` to undefined so plugin code cannot use `this` to reach
+    // the global scope. In strict mode, `this` remains undefined.
+    sandbox.call(undefined, Object.freeze(api));
+  } catch (e) {
+    // Clean up any partially registered commands
+    removePluginCommands(meta.id);
+    throw new Error(`Plugin '${meta.id}' execution failed: ${e}`);
+  }
+
+  const cleanup = () => {
+    removePluginCommands(meta.id);
+    const eventCleanup = (api as { _eventCleanup?: () => void })._eventCleanup;
+    if (eventCleanup) eventCleanup();
+  };
+
+  loadedPlugins.set(meta.id, { meta, cleanup });
+}
+
+/**
+ * Unload a plugin, removing all its registered commands and event subscriptions.
+ */
+export function unloadPlugin(id: string): void {
+  const plugin = loadedPlugins.get(id);
+  if (!plugin) return;
+  plugin.cleanup();
+  loadedPlugins.delete(id);
+}
+
+/**
+ * Get all currently loaded plugins.
+ */
+export function getLoadedPlugins(): PluginMeta[] {
+  return Array.from(loadedPlugins.values()).map(p => p.meta);
+}
+
+/**
+ * Unload all plugins.
+ */
+export function unloadAllPlugins(): void {
+  for (const [id] of loadedPlugins) {
+    unloadPlugin(id);
+  }
+}
diff --git a/v2/src/lib/providers/claude.ts b/v2/src/lib/providers/claude.ts
new file mode 100644
index 0000000..c458651
--- /dev/null
+++ b/v2/src/lib/providers/claude.ts
@@ -0,0 +1,20 @@
+// Claude Provider — metadata and capabilities for Claude Code
+
+import type { ProviderMeta } from './types';
+
+export const CLAUDE_PROVIDER: ProviderMeta = {
+  id: 'claude',
+  name: 'Claude Code',
+  description: 'Anthropic Claude Code agent via SDK',
+  capabilities: {
+    hasProfiles: true,
+    hasSkills: true,
+    hasModelSelection: true,
+    hasSandbox: false,
+    supportsSubagents: true,
+    supportsCost: true,
+    supportsResume: true,
+  },
+  sidecarRunner: 'claude-runner.mjs',
+  defaultModel: 'claude-opus-4-6',
+};
diff --git a/v2/src/lib/providers/codex.ts b/v2/src/lib/providers/codex.ts
new file mode 100644
index 0000000..f5b6d8b
--- /dev/null
+++ b/v2/src/lib/providers/codex.ts
@@ -0,0 +1,20 @@
+// Codex Provider — metadata and capabilities for OpenAI Codex CLI
+
+import type { ProviderMeta } from './types';
+
+export const CODEX_PROVIDER: ProviderMeta = {
+  id: 'codex',
+  name: 'Codex CLI',
+  description: 'OpenAI Codex CLI agent via SDK',
+  capabilities: {
+    hasProfiles: false,
+    hasSkills: false,
+    hasModelSelection: true,
+    hasSandbox: true,
+    supportsSubagents: false,
+    supportsCost: false,
+    supportsResume: true,
+  },
+  sidecarRunner: 'codex-runner.mjs',
+  defaultModel: 'gpt-5.4',
+};
diff --git a/v2/src/lib/providers/ollama.ts b/v2/src/lib/providers/ollama.ts
new file mode 100644
index 0000000..9d58419
--- /dev/null
+++ b/v2/src/lib/providers/ollama.ts
@@ -0,0 +1,20 @@
+// Ollama Provider — metadata and capabilities for local Ollama models
+
+import type { ProviderMeta } from './types';
+
+export const OLLAMA_PROVIDER: ProviderMeta = {
+  id: 'ollama',
+  name: 'Ollama',
+  description: 'Local Ollama models via REST API',
+  capabilities: {
+    hasProfiles: false,
+    hasSkills: false,
+    hasModelSelection: true,
+    hasSandbox: false,
+    supportsSubagents: false,
+    supportsCost: false,
+    supportsResume: false,
+  },
+  sidecarRunner: 'ollama-runner.mjs',
+  defaultModel: 'qwen3:8b',
+};
diff --git a/v2/src/lib/providers/registry.svelte.ts b/v2/src/lib/providers/registry.svelte.ts
new file mode 100644
index 0000000..90e80ac
--- /dev/null
+++ b/v2/src/lib/providers/registry.svelte.ts
@@ -0,0 +1,26 @@
+// Provider Registry — singleton registry of available providers (Svelte 5 runes)
+
+import type { ProviderId, ProviderMeta } from './types';
+
+const providers = $state(new Map<ProviderId, ProviderMeta>());
+
+export function registerProvider(meta: ProviderMeta): void {
+  providers.set(meta.id, meta);
+}
+
+export function getProvider(id: ProviderId): ProviderMeta | undefined {
+  return providers.get(id);
+}
+
+export function getProviders(): ProviderMeta[] {
+  return Array.from(providers.values());
+}
+
+export function getDefaultProviderId(): ProviderId {
+  return 'claude';
+}
+
+/** Check if a specific provider is registered */
+export function hasProvider(id: ProviderId): boolean {
+  return providers.has(id);
+}
diff --git a/v2/src/lib/providers/types.ts b/v2/src/lib/providers/types.ts
new file mode 100644
index 0000000..63401eb
--- /dev/null
+++ b/v2/src/lib/providers/types.ts
@@ -0,0 +1,34 @@
+// Provider abstraction types — defines the interface for multi-provider agent support
+
+export type ProviderId = 'claude' | 'codex' | 'ollama';
+
+/** What a provider can do — UI gates features on these flags */
+export interface ProviderCapabilities {
+  hasProfiles: boolean;
+  hasSkills: boolean;
+  hasModelSelection: boolean;
+  hasSandbox: boolean;
+  supportsSubagents: boolean;
+  supportsCost: boolean;
+  supportsResume: boolean;
+}
+
+/** Static metadata about a provider */
+export interface ProviderMeta {
+  id: ProviderId;
+  name: string;
+  description: string;
+  capabilities: ProviderCapabilities;
+  /** Name of the sidecar runner file (e.g. 'claude-runner.mjs') */
+  sidecarRunner: string;
+  /** Default model identifier, if applicable */
+  defaultModel?: string;
+}
+
+/** Per-provider configuration (stored in settings) */
+export interface ProviderSettings {
+  enabled: boolean;
+  defaultModel?: string;
+  /** Provider-specific config blob */
+  config: Record<string, unknown>;
+}
diff --git a/v2/src/lib/stores/agents.svelte.ts b/v2/src/lib/stores/agents.svelte.ts
new file mode 100644
index 0000000..b301f6a
--- /dev/null
+++ b/v2/src/lib/stores/agents.svelte.ts
@@ -0,0 +1,148 @@
+// Agent tracking state — Svelte 5 runes
+// Manages agent session lifecycle and message history
+
+import type { AgentMessage } from '../adapters/claude-messages';
+
+export type AgentStatus = 'idle' | 'starting' | 'running' | 'done' | 'error';
+
+export interface AgentSession {
+  id: string;
+  sdkSessionId?: string;
+  status: AgentStatus;
+  model?: string;
+  prompt: string;
+  messages: AgentMessage[];
+  costUsd: number;
+  inputTokens: number;
+  outputTokens: number;
+  numTurns: number;
+  durationMs: number;
+  error?: string;
+  // Agent Teams: parent/child hierarchy
+  parentSessionId?: string;
+  parentToolUseId?: string;
+  childSessionIds: string[];
+}
+
+let sessions = $state<AgentSession[]>([]);
+
+export function getAgentSessions(): AgentSession[] {
+  return sessions;
+}
+
+export function getAgentSession(id: string): AgentSession | undefined {
+  return sessions.find(s => s.id === id);
+}
+
+export function createAgentSession(id: string, prompt: string, parent?: { sessionId: string; toolUseId: string }): void {
+  sessions.push({
+    id,
+    status: 'starting',
+    prompt,
+    messages: [],
+    costUsd: 0,
+    inputTokens: 0,
+    outputTokens: 0,
+    numTurns: 0,
+    durationMs: 0,
+    parentSessionId: parent?.sessionId,
+    parentToolUseId: parent?.toolUseId,
+    childSessionIds: [],
+  });
+
+  // Register as child of parent
+  if (parent) {
+    const parentSession = sessions.find(s => s.id === parent.sessionId);
+    if (parentSession) {
+      parentSession.childSessionIds.push(id);
+    }
+  }
+}
+
+export function updateAgentStatus(id: string, status: AgentStatus, error?: string): void {
+  const session = sessions.find(s => s.id === id);
+  if (!session) return;
+  session.status = status;
+  if (error) session.error = error;
+}
+
+export function setAgentSdkSessionId(id: string, sdkSessionId: string): void {
+  const session = sessions.find(s => s.id === id);
+  if (session) session.sdkSessionId = sdkSessionId;
+}
+
+export function setAgentModel(id: string, model: string): void {
+  const session = sessions.find(s => s.id === id);
+  if (session) session.model = model;
+}
+
+export function appendAgentMessage(id: string, message: AgentMessage): void {
+  const session = sessions.find(s => s.id === id);
+  if (!session) return;
+  session.messages.push(message);
+}
+
+export function appendAgentMessages(id: string, messages: AgentMessage[]): void {
+  const session = sessions.find(s => s.id === id);
+  if (!session) return;
+  session.messages.push(...messages);
+}
+
+export function updateAgentCost(
+  id: string,
+  cost: { costUsd: number; inputTokens: number; outputTokens: number; numTurns: number; durationMs: number },
+): void {
+  const session = sessions.find(s => s.id === id);
+  if (!session) return;
+  // Accumulate across query invocations (each resume produces its own cost event)
+  session.costUsd += cost.costUsd;
+  session.inputTokens += cost.inputTokens;
+  session.outputTokens += cost.outputTokens;
+  session.numTurns += cost.numTurns;
+  session.durationMs += cost.durationMs;
+}
+
+/** Find a child session that was spawned by a specific tool_use */
+export function findChildByToolUseId(parentId: string, toolUseId: string): AgentSession | undefined {
+  return sessions.find(s => s.parentSessionId === parentId && s.parentToolUseId === toolUseId);
+}
+
+/** Get all child sessions for a given parent */
+export function getChildSessions(parentId: string): AgentSession[] {
+  return sessions.filter(s => s.parentSessionId === parentId);
+}
+
+/** Aggregate cost of a session plus all its children (recursive) */
+export function getTotalCost(id: string): { costUsd: number; inputTokens: number; outputTokens: number } {
+  const session = sessions.find(s => s.id === id);
+  if (!session) return { costUsd: 0, inputTokens: 0, outputTokens: 0 };
+
+  let costUsd = session.costUsd;
+  let inputTokens = session.inputTokens;
+  let outputTokens = session.outputTokens;
+
+  for (const childId of session.childSessionIds) {
+    const childCost = getTotalCost(childId);
+    costUsd += childCost.costUsd;
+    inputTokens += childCost.inputTokens;
+    outputTokens += childCost.outputTokens;
+  }
+
+  return { costUsd, inputTokens, outputTokens };
+}
+
+export function clearAllAgentSessions(): void {
+  sessions = [];
+}
+
+export function removeAgentSession(id: string): void {
+  // Also remove from parent's childSessionIds
+  const session = sessions.find(s => s.id === id);
+  if (session?.parentSessionId) {
+    const parent = sessions.find(s => s.id === session.parentSessionId);
+    if (parent) {
+      parent.childSessionIds = parent.childSessionIds.filter(cid => cid !== id);
+    }
+  }
+  sessions = sessions.filter(s => s.id !== id);
+}
diff --git a/v2/src/lib/stores/anchors.svelte.ts b/v2/src/lib/stores/anchors.svelte.ts
new file mode 100644
index 0000000..4b4144a
--- /dev/null
+++ b/v2/src/lib/stores/anchors.svelte.ts
@@ -0,0 +1,129 @@
+// Session Anchors store — Svelte 5 runes
+// Per-project anchor management with re-injection support
+
+import type { SessionAnchor, AnchorType, AnchorBudgetScale, SessionAnchorRecord } from '../types/anchors';
+import { DEFAULT_ANCHOR_SETTINGS, ANCHOR_BUDGET_SCALE_MAP } from '../types/anchors';
+import {
+  saveSessionAnchors,
+  loadSessionAnchors,
+  deleteSessionAnchor,
+  updateAnchorType as updateAnchorTypeBridge,
+} from '../adapters/anchors-bridge';
+
+// Per-project anchor state
+const projectAnchors = $state<Map<string, SessionAnchor[]>>(new Map());
+
+// Track which projects have had auto-anchoring triggered (prevents re-anchoring on subsequent compactions)
+const autoAnchoredProjects = $state<Set<string>>(new Set());
+
+export function getProjectAnchors(projectId: string): SessionAnchor[] {
+  return projectAnchors.get(projectId) ?? [];
+}
+
+/** Get only re-injectable anchors (auto + promoted, not pinned-only) */
+export function getInjectableAnchors(projectId: string): SessionAnchor[] {
+  const anchors = projectAnchors.get(projectId) ?? [];
+  return anchors.filter(a => a.anchorType === 'auto' || a.anchorType === 'promoted');
+}
+
+/** Total estimated tokens for re-injectable anchors */
+export function getInjectableTokenCount(projectId: string): number {
+  return getInjectableAnchors(projectId).reduce((sum, a) => sum + a.estimatedTokens, 0);
+}
+
+/** Check if auto-anchoring has already run for this project */
+export function hasAutoAnchored(projectId: string): boolean {
+  return autoAnchoredProjects.has(projectId);
+}
+
+/** Mark project as having been auto-anchored */
+export function markAutoAnchored(projectId: string): void {
+  autoAnchoredProjects.add(projectId);
+}
+
+/** Add anchors to a project (in-memory + persist) */
+export async function addAnchors(projectId: string, anchors: SessionAnchor[]): Promise<void> {
+  const existing = projectAnchors.get(projectId) ?? [];
+  const updated = [...existing, ...anchors];
+  projectAnchors.set(projectId, updated);
+
+  // Persist to SQLite
+  const records: SessionAnchorRecord[] = anchors.map(a => ({
+    id: a.id,
+    project_id: a.projectId,
+    message_id: a.messageId,
+    anchor_type: a.anchorType,
+    content: a.content,
+    estimated_tokens: a.estimatedTokens,
+    turn_index: a.turnIndex,
+    created_at: a.createdAt,
+  }));
+
+  try {
+    await saveSessionAnchors(records);
+  } catch (e) {
+    console.warn('Failed to persist anchors:', e);
+  }
+}
+
+/** Remove a single anchor */
+export async function removeAnchor(projectId: string, anchorId: string): Promise<void> {
+  const existing = projectAnchors.get(projectId) ?? [];
+  projectAnchors.set(projectId, existing.filter(a => a.id !== anchorId));
+
+  try {
+    await deleteSessionAnchor(anchorId);
+  } catch (e) {
+    console.warn('Failed to delete anchor:', e);
+  }
+}
+
+/** Change anchor type (pinned <-> promoted) */
+export async function changeAnchorType(projectId: string, anchorId: string, newType: AnchorType): Promise<void> {
+  const existing = projectAnchors.get(projectId) ?? [];
+  const anchor = existing.find(a => a.id === anchorId);
+  if (!anchor) return;
+
+  anchor.anchorType = newType;
+  // Trigger reactivity
+  projectAnchors.set(projectId, [...existing]);
+
+  try {
+    await updateAnchorTypeBridge(anchorId, newType);
+  } catch (e) {
+    console.warn('Failed to update anchor type:', e);
+  }
+}
+
+/** Load anchors from SQLite for a project */
+export async function loadAnchorsForProject(projectId: string): Promise<void> {
+  try {
+    const records = await loadSessionAnchors(projectId);
+    const anchors: SessionAnchor[] = records.map(r => ({
+      id: r.id,
+      projectId: r.project_id,
+      messageId: r.message_id,
+      anchorType: r.anchor_type as AnchorType,
+      content: r.content,
+      estimatedTokens: r.estimated_tokens,
+      turnIndex: r.turn_index,
+      createdAt: r.created_at,
+    }));
+    projectAnchors.set(projectId, anchors);
+    // If anchors exist, mark as already auto-anchored
+    if (anchors.some(a => a.anchorType === 'auto')) {
+      autoAnchoredProjects.add(projectId);
+    }
+  } catch (e) {
+    console.warn('Failed to load anchors for project:', e);
+  }
+}
+
+/** Get anchor settings, resolving budget from per-project scale if provided */
+export function getAnchorSettings(budgetScale?: AnchorBudgetScale) {
+  if (!budgetScale) return DEFAULT_ANCHOR_SETTINGS;
+  return {
+    ...DEFAULT_ANCHOR_SETTINGS,
+    anchorTokenBudget: ANCHOR_BUDGET_SCALE_MAP[budgetScale],
+  };
+}
diff --git a/v2/src/lib/stores/conflicts.svelte.ts b/v2/src/lib/stores/conflicts.svelte.ts
new file mode 100644
index 0000000..e5427f7
--- /dev/null
+++ b/v2/src/lib/stores/conflicts.svelte.ts
@@ -0,0 +1,284 @@
+// File overlap conflict detection — Svelte 5 runes
+// Tracks which files each agent session writes to per project.
+// Detects when two or more sessions write to the same file (file overlap conflict).
+// Also detects external filesystem writes (S-1 Phase 2) via inotify events.
+
+import { SessionId, ProjectId, type SessionId as SessionIdType, type ProjectId as ProjectIdType } from '../types/ids';
+
+/** Sentinel session ID for external (non-agent) writes */
+export const EXTERNAL_SESSION_ID = SessionId('__external__');
+
+export interface FileConflict {
+  /** Absolute file path */
+  filePath: string;
+  /** Short display name (last path segment) */
+  shortName: string;
+  /** Session IDs that have written to this file */
+  sessionIds: SessionIdType[];
+  /** Timestamp of most recent write */
+  lastWriteTs: number;
+  /** True if this conflict involves an external (non-agent) writer */
+  isExternal: boolean;
+}
+
+export interface ProjectConflicts {
+  projectId: ProjectIdType;
+  /** Active file conflicts (2+ sessions writing same file) */
+  conflicts: FileConflict[];
+  /** Total conflicting files */
+  conflictCount: number;
+  /** Number of files with external write conflicts */
+  externalConflictCount: number;
+}
+
+// --- State ---
+
+interface FileWriteEntry {
+  sessionIds: Set<SessionIdType>;
+  lastWriteTs: number;
+}
+
+// projectId -> filePath -> FileWriteEntry
+let projectFileWrites = $state<Map<ProjectIdType, Map<string, FileWriteEntry>>>(new Map());
+
+// projectId -> set of acknowledged file paths (suppresses badge until new conflict on that file)
+let acknowledgedFiles = $state<Map<ProjectIdType, Set<string>>>(new Map());
+
+// sessionId -> worktree path (null = main working tree)
+let sessionWorktrees = $state<Map<SessionIdType, string | null>>(new Map());
+
+// projectId -> filePath -> timestamp of most recent agent write (for external write heuristic)
+let agentWriteTimestamps = $state<Map<ProjectIdType, Map<string, number>>>(new Map());
+
+// Time window: if an fs event arrives within this window after an agent tool_call write,
+// it's attributed to the agent (suppressed). Otherwise it's external.
+const AGENT_WRITE_GRACE_MS = 2000;
+
+// --- Public API ---
+
+/** Register the worktree path for a session (null = main working tree) */
+export function setSessionWorktree(sessionId: SessionIdType, worktreePath: string | null): void {
+  sessionWorktrees.set(sessionId, worktreePath ?? null);
+}
+
+/** Check if two sessions are in different worktrees (conflict suppression) */
+function areInDifferentWorktrees(sessionIdA: SessionIdType, sessionIdB: SessionIdType): boolean {
+  const wtA = sessionWorktrees.get(sessionIdA) ?? null;
+  const wtB = sessionWorktrees.get(sessionIdB) ?? null;
+  // Both null = same main tree, both same string = same worktree → not different
+  if (wtA === wtB) return false;
+  // One or both non-null and different → different worktrees
+  return true;
+}
+
+/** Record that a session wrote to a file. Returns true if this creates a new conflict. */
+export function recordFileWrite(projectId: ProjectIdType, sessionId: SessionIdType, filePath: string): boolean {
+  let projectMap = projectFileWrites.get(projectId);
+  if (!projectMap) {
+    projectMap = new Map();
+    projectFileWrites.set(projectId, projectMap);
+  }
+
+  // Track agent write timestamp for external write heuristic
+  if (sessionId !== EXTERNAL_SESSION_ID) {
+    let tsMap = agentWriteTimestamps.get(projectId);
+    if (!tsMap) {
+      tsMap = new Map();
+      agentWriteTimestamps.set(projectId, tsMap);
+    }
+    tsMap.set(filePath, Date.now());
+  }
+
+  let entry = projectMap.get(filePath);
+  const hadConflict = entry ? countRealConflictSessions(entry, sessionId) >= 2 : false;
+
+  if (!entry) {
+    entry = { sessionIds: new Set([sessionId]), lastWriteTs: Date.now() };
+    projectMap.set(filePath, entry);
+    return false;
+  }
+
+  const isNewSession = !entry.sessionIds.has(sessionId);
+  entry.sessionIds.add(sessionId);
+  entry.lastWriteTs = Date.now();
+
+  // Check if this is a real conflict (not suppressed by worktrees)
+  const realConflictCount = countRealConflictSessions(entry, sessionId);
+  const isNewConflict = !hadConflict && realConflictCount >= 2;
+
+  // Clear acknowledgement when a new session writes to a previously-acknowledged file
+  if (isNewSession && realConflictCount >= 2) {
+    const ackSet = acknowledgedFiles.get(projectId);
+    if (ackSet) ackSet.delete(filePath);
+  }
+
+  return isNewConflict;
+}
+
+/**
+ * Record an external filesystem write detected via inotify.
+ * Uses timing heuristic: if an agent wrote this file within AGENT_WRITE_GRACE_MS,
+ * the write is attributed to the agent and suppressed.
+ * Returns true if this creates a new external write conflict.
+ */
+export function recordExternalWrite(projectId: ProjectIdType, filePath: string, timestampMs: number): boolean {
+  // Timing heuristic: check if any agent recently wrote this file
+  const tsMap = agentWriteTimestamps.get(projectId);
+  if (tsMap) {
+    const lastAgentWrite = tsMap.get(filePath);
+    if (lastAgentWrite && (timestampMs - lastAgentWrite) < AGENT_WRITE_GRACE_MS) {
+      // This is likely our agent's write — suppress
+      return false;
+    }
+  }
+
+  // Check if any agent session has written this file (for conflict to be meaningful)
+  const projectMap = projectFileWrites.get(projectId);
+  if (!projectMap) return false; // No agent writes at all — not a conflict
+  const entry = projectMap.get(filePath);
+  if (!entry || entry.sessionIds.size === 0) return false; // No agent wrote this file
+
+  // Record external write as a conflict
+  return recordFileWrite(projectId, EXTERNAL_SESSION_ID, filePath);
+}
+
+/** Get the count of external write conflicts for a project */
+export function getExternalConflictCount(projectId: ProjectIdType): number {
+  const projectMap = projectFileWrites.get(projectId);
+  if (!projectMap) return 0;
+  const ackSet = acknowledgedFiles.get(projectId);
+  let count = 0;
+  for (const [filePath, entry] of projectMap) {
+    if (entry.sessionIds.has(EXTERNAL_SESSION_ID) && !(ackSet?.has(filePath))) {
+      count++;
+    }
+  }
+  return count;
+}
+
+/**
+ * Count sessions that are in a real conflict with the given session
+ * (same worktree or both in main tree). Returns total including the session itself.
+ */
+function countRealConflictSessions(entry: FileWriteEntry, forSessionId: SessionIdType): number {
+  let count = 0;
+  for (const sid of entry.sessionIds) {
+    if (sid === forSessionId || !areInDifferentWorktrees(sid, forSessionId)) {
+      count++;
+    }
+  }
+  return count;
+}
+
+/** Get all conflicts for a project (excludes acknowledged and worktree-suppressed) */
+export function getProjectConflicts(projectId: ProjectIdType): ProjectConflicts {
+  const projectMap = projectFileWrites.get(projectId);
+  if (!projectMap) return { projectId, conflicts: [], conflictCount: 0, externalConflictCount: 0 };
+
+  const ackSet = acknowledgedFiles.get(projectId);
+  const conflicts: FileConflict[] = [];
+  let externalConflictCount = 0;
+  for (const [filePath, entry] of projectMap) {
+    if (hasRealConflict(entry) && !(ackSet?.has(filePath))) {
+      const isExternal = entry.sessionIds.has(EXTERNAL_SESSION_ID);
+      if (isExternal) externalConflictCount++;
+      conflicts.push({
+        filePath,
+        shortName: filePath.split('/').pop() ?? filePath,
+        sessionIds: Array.from(entry.sessionIds),
+        lastWriteTs: entry.lastWriteTs,
+        isExternal,
+      });
+    }
+  }
+
+  // Most recent conflicts first
+  conflicts.sort((a, b) => b.lastWriteTs - a.lastWriteTs);
+  return { projectId, conflicts, conflictCount: conflicts.length, externalConflictCount };
+}
+
+/** Check if a project has any unacknowledged real conflicts */
+export function hasConflicts(projectId: ProjectIdType): boolean {
+  const projectMap = projectFileWrites.get(projectId);
+  if (!projectMap) return false;
+  const ackSet = acknowledgedFiles.get(projectId);
+  for (const [filePath, entry] of projectMap) {
+    if (hasRealConflict(entry) && !(ackSet?.has(filePath))) return true;
+  }
+  return false;
+}
+
+/** Get total unacknowledged conflict count across all projects */
+export function getTotalConflictCount(): number {
+  let total = 0;
+  for (const [projectId, projectMap] of projectFileWrites) {
+    const ackSet = acknowledgedFiles.get(projectId);
+    for (const [filePath, entry] of projectMap) {
+      if (hasRealConflict(entry) && !(ackSet?.has(filePath))) total++;
+    }
+  }
+  return total;
+}
+
+/** Check if a file write entry has a real conflict (2+ sessions in same worktree) */
+function hasRealConflict(entry: FileWriteEntry): boolean {
+  if (entry.sessionIds.size < 2) return false;
+  // Check all pairs for same-worktree conflict
+  const sids = Array.from(entry.sessionIds);
+  for (let i = 0; i < sids.length; i++) {
+    for (let j = i + 1; j < sids.length; j++) {
+      if (!areInDifferentWorktrees(sids[i], sids[j])) return true;
+    }
+  }
+  return false;
+}
+
+/** Acknowledge all current conflicts for a project (suppresses badge until new conflict) */
+export function acknowledgeConflicts(projectId: ProjectIdType): void {
+  const projectMap = projectFileWrites.get(projectId);
+  if (!projectMap) return;
+
+  const ackSet = acknowledgedFiles.get(projectId) ?? new Set();
+  for (const [filePath, entry] of projectMap) {
+    if (hasRealConflict(entry)) {
+      ackSet.add(filePath);
+    }
+  }
+  acknowledgedFiles.set(projectId, ackSet);
+}
+
+/** Remove a session from all file write tracking (call on session end) */
+export function clearSessionWrites(projectId: ProjectIdType, sessionId: SessionIdType): void {
+  const projectMap = projectFileWrites.get(projectId);
+  if (!projectMap) return;
+
+  for (const [filePath, entry] of projectMap) {
+    entry.sessionIds.delete(sessionId);
+    if (entry.sessionIds.size === 0) {
+      projectMap.delete(filePath);
+    }
+  }
+
+  if (projectMap.size === 0) {
+    projectFileWrites.delete(projectId);
+    acknowledgedFiles.delete(projectId);
+  }
+
+  // Clean up worktree tracking
+  sessionWorktrees.delete(sessionId);
+}
+
+/** Clear all conflict tracking for a project */
+export function clearProjectConflicts(projectId: ProjectIdType): void {
+  projectFileWrites.delete(projectId);
+  acknowledgedFiles.delete(projectId);
+  agentWriteTimestamps.delete(projectId);
+}
+
+/** Clear all conflict state */
+export function clearAllConflicts(): void {
+  projectFileWrites = new Map();
+  acknowledgedFiles = new Map();
+  sessionWorktrees = new Map();
+  agentWriteTimestamps = new Map();
+}
diff --git a/v2/src/lib/stores/conflicts.test.ts b/v2/src/lib/stores/conflicts.test.ts
new file mode 100644
index 0000000..86a1991
--- /dev/null
+++ b/v2/src/lib/stores/conflicts.test.ts
@@ -0,0 +1,344 @@
+import { describe, it, expect, beforeEach, vi, afterEach } from 'vitest';
+import { SessionId, ProjectId } from '../types/ids';
+import {
+  recordFileWrite,
+  recordExternalWrite,
+  getProjectConflicts,
+  getExternalConflictCount,
+  hasConflicts,
+  getTotalConflictCount,
+  clearSessionWrites,
+  clearProjectConflicts,
+  clearAllConflicts,
+  acknowledgeConflicts,
+  setSessionWorktree,
+  EXTERNAL_SESSION_ID,
+} from './conflicts.svelte';
+
+// Test helpers — branded IDs
+const P1 = ProjectId('proj-1');
+const P2 = ProjectId('proj-2');
+const SA = SessionId('sess-a');
+const SB = SessionId('sess-b');
+const SC = SessionId('sess-c');
+const SD = SessionId('sess-d');
+
+beforeEach(() => {
+  clearAllConflicts();
+});
+
+describe('conflicts store', () => {
+  describe('recordFileWrite', () => {
+    it('returns false for first write to a file', () => {
+      expect(recordFileWrite(P1, SA, '/src/main.ts')).toBe(false);
+    });
+
+    it('returns false for same session writing same file again', () => {
+      recordFileWrite(P1, SA, '/src/main.ts');
+      expect(recordFileWrite(P1, SA, '/src/main.ts')).toBe(false);
+    });
+
+    it('returns true when a second session writes same file (new conflict)', () => {
+      recordFileWrite(P1, SA, '/src/main.ts');
+      expect(recordFileWrite(P1, SB, '/src/main.ts')).toBe(true);
+    });
+
+    it('returns false when third session writes already-conflicted file', () => {
+      recordFileWrite(P1, SA, '/src/main.ts');
+      recordFileWrite(P1, SB, '/src/main.ts');
+      expect(recordFileWrite(P1, SC, '/src/main.ts')).toBe(false);
+    });
+
+    it('tracks writes per project independently', () => {
+      recordFileWrite(P1, SA, '/src/main.ts');
+      expect(recordFileWrite(P2, SB, '/src/main.ts')).toBe(false);
+    });
+  });
+
+  describe('getProjectConflicts', () => {
+    it('returns empty for unknown project', () => {
+      const result = getProjectConflicts(ProjectId('nonexistent'));
+      expect(result.conflicts).toEqual([]);
+      expect(result.conflictCount).toBe(0);
+    });
+
+    it('returns empty when no overlapping writes', () => {
+      recordFileWrite(P1, SA, '/src/a.ts');
+      recordFileWrite(P1, SB, '/src/b.ts');
+      const result = getProjectConflicts(P1);
+      expect(result.conflicts).toEqual([]);
+      expect(result.conflictCount).toBe(0);
+    });
+
+    it('returns conflict when two sessions write same file', () => {
+      recordFileWrite(P1, SA, '/src/main.ts');
+      recordFileWrite(P1, SB, '/src/main.ts');
+      const result = getProjectConflicts(P1);
+      expect(result.conflictCount).toBe(1);
+      expect(result.conflicts[0].filePath).toBe('/src/main.ts');
+      expect(result.conflicts[0].shortName).toBe('main.ts');
+      expect(result.conflicts[0].sessionIds).toContain(SA);
+      expect(result.conflicts[0].sessionIds).toContain(SB);
+    });
+
+    it('returns multiple conflicts sorted by recency', () => {
+      vi.useFakeTimers();
+      vi.setSystemTime(1000);
+      recordFileWrite(P1, SA, '/src/old.ts');
+      recordFileWrite(P1, SB, '/src/old.ts');
+      vi.setSystemTime(2000);
+      recordFileWrite(P1, SA, '/src/new.ts');
+      recordFileWrite(P1, SB, '/src/new.ts');
+      const result = getProjectConflicts(P1);
+      expect(result.conflictCount).toBe(2);
+      // Most recent first
+      expect(result.conflicts[0].filePath).toBe('/src/new.ts');
+      vi.useRealTimers();
+    });
+  });
+
+  describe('hasConflicts', () => {
+    it('returns false for unknown project', () => {
+      expect(hasConflicts(ProjectId('nonexistent'))).toBe(false);
+    });
+
+    it('returns false with no overlapping writes', () => {
+      recordFileWrite(P1, SA, '/src/a.ts');
+      expect(hasConflicts(P1)).toBe(false);
+    });
+
+    it('returns true with overlapping writes', () => {
+      recordFileWrite(P1, SA, '/src/a.ts');
+      recordFileWrite(P1, SB, '/src/a.ts');
+      expect(hasConflicts(P1)).toBe(true);
+    });
+  });
+
+  describe('getTotalConflictCount', () => {
+    it('returns 0 with no conflicts', () => {
+      expect(getTotalConflictCount()).toBe(0);
+    });
+
+    it('counts conflicts across projects', () => {
+      recordFileWrite(P1, SA, '/a.ts');
+      recordFileWrite(P1, SB, '/a.ts');
+      recordFileWrite(P2, SC, '/b.ts');
+      recordFileWrite(P2, SD, '/b.ts');
+      expect(getTotalConflictCount()).toBe(2);
+    });
+  });
+
+  describe('clearSessionWrites', () => {
+    it('removes session from file write tracking', () => {
+      recordFileWrite(P1, SA, '/a.ts');
+      recordFileWrite(P1, SB, '/a.ts');
+      expect(hasConflicts(P1)).toBe(true);
+      clearSessionWrites(P1, SB);
+      expect(hasConflicts(P1)).toBe(false);
+    });
+
+    it('cleans up empty entries', () => {
+      recordFileWrite(P1, SA, '/a.ts');
+      clearSessionWrites(P1, SA);
+      expect(getProjectConflicts(P1).conflictCount).toBe(0);
+    });
+
+    it('no-ops for unknown project', () => {
+      clearSessionWrites(ProjectId('nonexistent'), SA); // Should not throw
+    });
+  });
+
+  describe('clearProjectConflicts', () => {
+    it('clears all tracking for a project', () => {
+      recordFileWrite(P1, SA, '/a.ts');
+      recordFileWrite(P1, SB, '/a.ts');
+      clearProjectConflicts(P1);
+      expect(hasConflicts(P1)).toBe(false);
+      expect(getTotalConflictCount()).toBe(0);
+    });
+  });
+
+  describe('clearAllConflicts', () => {
+    it('clears everything', () => {
+      recordFileWrite(P1, SA, '/a.ts');
+      recordFileWrite(P1, SB, '/a.ts');
+      recordFileWrite(P2, SC, '/b.ts');
+      recordFileWrite(P2, SD, '/b.ts');
+      clearAllConflicts();
+      expect(getTotalConflictCount()).toBe(0);
+    });
+  });
+
+  describe('acknowledgeConflicts', () => {
+    it('suppresses conflict from counts after acknowledge', () => {
+      recordFileWrite(P1, SA, '/a.ts');
+      recordFileWrite(P1, SB, '/a.ts');
+      expect(hasConflicts(P1)).toBe(true);
+      acknowledgeConflicts(P1);
+      expect(hasConflicts(P1)).toBe(false);
+      expect(getTotalConflictCount()).toBe(0);
+      expect(getProjectConflicts(P1).conflictCount).toBe(0);
+    });
+
+    it('resurfaces conflict when new write arrives on acknowledged file', () => {
+      recordFileWrite(P1, SA, '/a.ts');
+      recordFileWrite(P1, SB, '/a.ts');
+      acknowledgeConflicts(P1);
+      expect(hasConflicts(P1)).toBe(false);
+      // Third session writes same file — should resurface
+      recordFileWrite(P1, SC, '/a.ts');
+      // recordFileWrite returns false for already-conflicted file, but the ack should be cleared
+      expect(hasConflicts(P1)).toBe(true);
+    });
+
+    it('no-ops for unknown project', () => {
+      acknowledgeConflicts(ProjectId('nonexistent')); // Should not throw
+    });
+  });
+
+  describe('worktree suppression', () => {
+    it('suppresses conflict between sessions in different worktrees', () => {
+      setSessionWorktree(SA, null); // main tree
+      setSessionWorktree(SB, '/tmp/wt-1'); // worktree
+      recordFileWrite(P1, SA, '/a.ts');
+      recordFileWrite(P1, SB, '/a.ts');
+      expect(hasConflicts(P1)).toBe(false);
+      expect(getTotalConflictCount()).toBe(0);
+    });
+
+    it('detects conflict between sessions in same worktree', () => {
+      setSessionWorktree(SA, '/tmp/wt-1');
+      setSessionWorktree(SB, '/tmp/wt-1');
+      recordFileWrite(P1, SA, '/a.ts');
+      recordFileWrite(P1, SB, '/a.ts');
+      expect(hasConflicts(P1)).toBe(true);
+    });
+
+    it('detects conflict between sessions both in main tree', () => {
+      setSessionWorktree(SA, null);
+      setSessionWorktree(SB, null);
+      recordFileWrite(P1, SA, '/a.ts');
+      recordFileWrite(P1, SB, '/a.ts');
+      expect(hasConflicts(P1)).toBe(true);
+    });
+
+    it('suppresses conflict when two worktrees differ', () => {
+      setSessionWorktree(SA, '/tmp/wt-1');
+      setSessionWorktree(SB, '/tmp/wt-2');
+      recordFileWrite(P1, SA, '/a.ts');
+      recordFileWrite(P1, SB, '/a.ts');
+      expect(hasConflicts(P1)).toBe(false);
+    });
+
+    it('sessions without worktree info conflict normally (backward compat)', () => {
+      // No setSessionWorktree calls — both default to null (main tree)
+      recordFileWrite(P1, SA, '/a.ts');
+      recordFileWrite(P1, SB, '/a.ts');
+      expect(hasConflicts(P1)).toBe(true);
+    });
+
+    it('clearSessionWrites cleans up worktree tracking', () => {
+      setSessionWorktree(SA, '/tmp/wt-1');
+      recordFileWrite(P1, SA, '/a.ts');
+      clearSessionWrites(P1, SA);
+      // Subsequent session in main tree should not be compared against stale wt data
+      recordFileWrite(P1, SB, '/a.ts');
+      recordFileWrite(P1, SC, '/a.ts');
+      expect(hasConflicts(P1)).toBe(true);
+    });
+  });
+
+  describe('external write detection (S-1 Phase 2)', () => {
+    it('suppresses external write within grace period after agent write', () => {
+      vi.useFakeTimers();
+      vi.setSystemTime(1000);
+      recordFileWrite(P1, SA, '/src/main.ts');
+      // External write arrives 500ms later — within 2s grace period
+      vi.setSystemTime(1500);
+      const result = recordExternalWrite(P1, '/src/main.ts', 1500);
+      expect(result).toBe(false);
+      expect(getExternalConflictCount(P1)).toBe(0);
+      vi.useRealTimers();
+    });
+
+    it('detects external write outside grace period', () => {
+      vi.useFakeTimers();
+      vi.setSystemTime(1000);
+      recordFileWrite(P1, SA, '/src/main.ts');
+      // External write arrives 3s later — outside 2s grace period
+      vi.setSystemTime(4000);
+      const result = recordExternalWrite(P1, '/src/main.ts', 4000);
+      expect(result).toBe(true);
+      expect(getExternalConflictCount(P1)).toBe(1);
+      vi.useRealTimers();
+    });
+
+    it('ignores external write to file no agent has written', () => {
+      recordFileWrite(P1, SA, '/src/other.ts');
+      const result = recordExternalWrite(P1, '/src/unrelated.ts', Date.now());
+      expect(result).toBe(false);
+    });
+
+    it('ignores external write for project with no agent writes', () => {
+      const result = recordExternalWrite(P1, '/src/main.ts', Date.now());
+      expect(result).toBe(false);
+    });
+
+    it('marks conflict as external in getProjectConflicts', () => {
+      vi.useFakeTimers();
+      vi.setSystemTime(1000);
+      recordFileWrite(P1, SA, '/src/main.ts');
+      vi.setSystemTime(4000);
+      recordExternalWrite(P1, '/src/main.ts', 4000);
+      const result = getProjectConflicts(P1);
+      expect(result.conflictCount).toBe(1);
+      expect(result.externalConflictCount).toBe(1);
+      expect(result.conflicts[0].isExternal).toBe(true);
+      expect(result.conflicts[0].sessionIds).toContain(EXTERNAL_SESSION_ID);
+      vi.useRealTimers();
+    });
+
+    it('external conflicts can be acknowledged', () => {
+      vi.useFakeTimers();
+      vi.setSystemTime(1000);
+      recordFileWrite(P1, SA, '/src/main.ts');
+      vi.setSystemTime(4000);
+      recordExternalWrite(P1, '/src/main.ts', 4000);
+      expect(hasConflicts(P1)).toBe(true);
+      acknowledgeConflicts(P1);
+      expect(hasConflicts(P1)).toBe(false);
+      expect(getExternalConflictCount(P1)).toBe(0);
+      vi.useRealTimers();
+    });
+
+    it('clearAllConflicts clears external write timestamps', () => {
+      vi.useFakeTimers();
+      vi.setSystemTime(1000);
+      recordFileWrite(P1, SA, '/src/main.ts');
+      clearAllConflicts();
+      // After clearing, external writes should not create conflicts (no agent writes tracked)
+      vi.setSystemTime(4000);
+      const result = recordExternalWrite(P1, '/src/main.ts', 4000);
+      expect(result).toBe(false);
+      vi.useRealTimers();
+    });
+
+    it('external conflict coexists with agent-agent conflict', () => {
+      vi.useFakeTimers();
+      vi.setSystemTime(1000);
+      recordFileWrite(P1, SA, '/src/agent.ts');
+      recordFileWrite(P1, SB, '/src/agent.ts');
+      recordFileWrite(P1, SA, '/src/ext.ts');
+      vi.setSystemTime(4000);
+      recordExternalWrite(P1, '/src/ext.ts', 4000);
+      const result = getProjectConflicts(P1);
+      expect(result.conflictCount).toBe(2);
+      expect(result.externalConflictCount).toBe(1);
+      const extConflict = result.conflicts.find(c => c.isExternal);
+      const agentConflict = result.conflicts.find(c => !c.isExternal);
+      expect(extConflict?.filePath).toBe('/src/ext.ts');
+      expect(agentConflict?.filePath).toBe('/src/agent.ts');
+      vi.useRealTimers();
+    });
+  });
+});
diff --git a/v2/src/lib/stores/health.svelte.ts b/v2/src/lib/stores/health.svelte.ts
new file mode 100644
index 0000000..c7cb0bb
--- /dev/null
+++ b/v2/src/lib/stores/health.svelte.ts
@@ -0,0 +1,329 @@
+// Project health tracking — Svelte 5 runes
+// Tracks per-project activity state, burn rate, context pressure, and attention scoring
+
+import type { SessionId as SessionIdType, ProjectId as ProjectIdType } from '../types/ids';
+import { getAgentSession, type AgentSession } from './agents.svelte';
+import { getProjectConflicts } from './conflicts.svelte';
+import { scoreAttention } from '../utils/attention-scorer';
+
+// --- Types ---
+
+export type ActivityState = 'inactive' | 'running' | 'idle' | 'stalled';
+
+export interface ProjectHealth {
+  projectId: ProjectIdType;
+  sessionId: SessionIdType | null;
+  /** Current activity state */
+  activityState: ActivityState;
+  /** Name of currently running tool (if any) */
+  activeTool: string | null;
+  /** Duration in ms since last activity (0 if running a tool) */
+  idleDurationMs: number;
+  /** Burn rate in USD per hour (0 if no data) */
+  burnRatePerHour: number;
+  /** Context pressure as fraction 0..1 (null if unknown) */
+  contextPressure: number | null;
+  /** Number of file conflicts (2+ agents writing same file) */
+  fileConflictCount: number;
+  /** Number of external write conflicts (filesystem writes by non-agent processes) */
+  externalConflictCount: number;
+  /** Attention urgency score (higher = more urgent, 0 = no attention needed) */
+  attentionScore: number;
+  /** Human-readable attention reason */
+  attentionReason: string | null;
+}
+
+export type AttentionItem = ProjectHealth & { projectName: string; projectIcon: string };
+
+// --- Configuration ---
+
+const DEFAULT_STALL_THRESHOLD_MS = 15 * 60 * 1000; // 15 minutes
+const TICK_INTERVAL_MS = 5_000; // Update derived state every 5s
+const BURN_RATE_WINDOW_MS = 5 * 60 * 1000; // 5-minute window for burn rate calc
+
+// Context limits by model (tokens)
+const MODEL_CONTEXT_LIMITS: Record<string, number> = {
+  'claude-sonnet-4-20250514': 200_000,
+  'claude-opus-4-20250514': 200_000,
+  'claude-haiku-4-20250506': 200_000,
+  'claude-3-5-sonnet-20241022': 200_000,
+  'claude-3-5-haiku-20241022': 200_000,
+  'claude-sonnet-4-6': 200_000,
+  'claude-opus-4-6': 200_000,
+};
+const DEFAULT_CONTEXT_LIMIT = 200_000;
+
+
+// --- State ---
+
+interface ProjectTracker {
+  projectId: ProjectIdType;
+  sessionId: SessionIdType | null;
+  lastActivityTs: number; // epoch ms
+  lastToolName: string | null;
+  toolInFlight: boolean;
+  /** Token snapshots for burn rate calculation: [timestamp, totalTokens] */
+  tokenSnapshots: Array<[number, number]>;
+  /** Cost snapshots for $/hr: [timestamp, costUsd] */
+  costSnapshots: Array<[number, number]>;
+  /** Number of tasks in 'review' status (for reviewer agents) */
+  reviewQueueDepth: number;
+}
+
+let trackers = $state<Map<ProjectIdType, ProjectTracker>>(new Map());
+let stallThresholds = $state<Map<ProjectIdType, number>>(new Map()); // projectId → ms
+let tickTs = $state<number>(Date.now());
+let tickInterval: ReturnType<typeof setInterval> | null = null;
+
+// --- Public API ---
+
+/** Register a project for health tracking */
+export function trackProject(projectId: ProjectIdType, sessionId: SessionIdType | null): void {
+  const existing = trackers.get(projectId);
+  if (existing) {
+    existing.sessionId = sessionId;
+    return;
+  }
+  trackers.set(projectId, {
+    projectId,
+    sessionId,
+    lastActivityTs: Date.now(),
+    lastToolName: null,
+    toolInFlight: false,
+    tokenSnapshots: [],
+    costSnapshots: [],
+    reviewQueueDepth: 0,
+  });
+}
+
+/** Remove a project from health tracking */
+export function untrackProject(projectId: ProjectIdType): void {
+  trackers.delete(projectId);
+}
+
+/** Set per-project stall threshold in minutes (null to use default) */
+export function setStallThreshold(projectId: ProjectIdType, minutes: number | null): void {
+  if (minutes === null) {
+    stallThresholds.delete(projectId);
+  } else {
+    stallThresholds.set(projectId, minutes * 60 * 1000);
+  }
+}
+
+/** Update session ID for a tracked project */
+export function updateProjectSession(projectId: ProjectIdType, sessionId: SessionIdType): void {
+  const t = trackers.get(projectId);
+  if (t) {
+    t.sessionId = sessionId;
+  }
+}
+
+/** Record activity — call on every agent message. Auto-starts tick if stopped. */
+export function recordActivity(projectId: ProjectIdType, toolName?: string): void {
+  const t = trackers.get(projectId);
+  if (!t) return;
+  t.lastActivityTs = Date.now();
+  if (toolName !== undefined) {
+    t.lastToolName = toolName;
+    t.toolInFlight = true;
+  }
+  // Auto-start tick when activity resumes
+  if (!tickInterval) startHealthTick();
+}
+
+/** Record tool completion */
+export function recordToolDone(projectId: ProjectIdType): void {
+  const t = trackers.get(projectId);
+  if (!t) return;
+  t.lastActivityTs = Date.now();
+  t.toolInFlight = false;
+}
+
+/** Record a token/cost snapshot for burn rate calculation */
+export function recordTokenSnapshot(projectId: ProjectIdType, totalTokens: number, costUsd: number): void {
+  const t = trackers.get(projectId);
+  if (!t) return;
+  const now = Date.now();
+  t.tokenSnapshots.push([now, totalTokens]);
+  t.costSnapshots.push([now, costUsd]);
+  // Prune old snapshots beyond window
+  const cutoff = now - BURN_RATE_WINDOW_MS * 2;
+  t.tokenSnapshots = t.tokenSnapshots.filter(([ts]) => ts > cutoff);
+  t.costSnapshots = t.costSnapshots.filter(([ts]) => ts > cutoff);
+}
+
+/** Check if any tracked project has an active (running/starting) session */
+function hasActiveSession(): boolean {
+  for (const t of trackers.values()) {
+    if (!t.sessionId) continue;
+    const session = getAgentSession(t.sessionId);
+    if (session && (session.status === 'running' || session.status === 'starting')) return true;
+  }
+  return false;
+}
+
+/** Start the health tick timer (auto-stops when no active sessions) */
+export function startHealthTick(): void {
+  if (tickInterval) return;
+  tickInterval = setInterval(() => {
+    if (!hasActiveSession()) {
+      stopHealthTick();
+      return;
+    }
+    tickTs = Date.now();
+  }, TICK_INTERVAL_MS);
+}
+
+/** Stop the health tick timer */
+export function stopHealthTick(): void {
+  if (tickInterval) {
+    clearInterval(tickInterval);
+    tickInterval = null;
+  }
+}
+
+/** Set review queue depth for a project (used by reviewer agents) */
+export function setReviewQueueDepth(projectId: ProjectIdType, depth: number): void {
+  const t = trackers.get(projectId);
+  if (t) t.reviewQueueDepth = depth;
+}
+
+/** Clear all tracked projects */
+export function clearHealthTracking(): void {
+  trackers = new Map();
+  stallThresholds = new Map();
+}
+
+// --- Derived health per project ---
+
+function getContextLimit(model?: string): number {
+  if (!model) return DEFAULT_CONTEXT_LIMIT;
+  return MODEL_CONTEXT_LIMITS[model] ?? DEFAULT_CONTEXT_LIMIT;
+}
+
+function computeBurnRate(snapshots: Array<[number, number]>): number {
+  if (snapshots.length < 2) return 0;
+  const windowStart = Date.now() - BURN_RATE_WINDOW_MS;
+  const recent = snapshots.filter(([ts]) => ts >= windowStart);
+  if (recent.length < 2) return 0;
+  const first = recent[0];
+  const last = recent[recent.length - 1];
+  const elapsedHours = (last[0] - first[0]) / 3_600_000;
+  if (elapsedHours < 0.001) return 0; // Less than ~4 seconds
+  const costDelta = last[1] - first[1];
+  return Math.max(0, costDelta / elapsedHours);
+}
+
+function computeHealth(tracker: ProjectTracker, now: number): ProjectHealth {
+  const session: AgentSession | undefined = tracker.sessionId
+    ? getAgentSession(tracker.sessionId)
+    : undefined;
+
+  // Activity state
+  let activityState: ActivityState;
+  let idleDurationMs = 0;
+  let activeTool: string | null = null;
+
+  if (!session || session.status === 'idle' || session.status === 'done' || session.status === 'error') {
+    activityState = session?.status === 'error' ? 'inactive' : 'inactive';
+  } else if (tracker.toolInFlight) {
+    activityState = 'running';
+    activeTool = tracker.lastToolName;
+    idleDurationMs = 0;
+  } else {
+    idleDurationMs = now - tracker.lastActivityTs;
+    const stallMs = stallThresholds.get(tracker.projectId) ?? DEFAULT_STALL_THRESHOLD_MS;
+    if (idleDurationMs >= stallMs) {
+      activityState = 'stalled';
+    } else {
+      activityState = 'idle';
+    }
+  }
+
+  // Context pressure
+  let contextPressure: number | null = null;
+  if (session && (session.inputTokens + session.outputTokens) > 0) {
+    const limit = getContextLimit(session.model);
+    contextPressure = Math.min(1, (session.inputTokens + session.outputTokens) / limit);
+  }
+
+  // Burn rate
+  const burnRatePerHour = computeBurnRate(tracker.costSnapshots);
+
+  // File conflicts
+  const conflicts = getProjectConflicts(tracker.projectId);
+  const fileConflictCount = conflicts.conflictCount;
+  const externalConflictCount = conflicts.externalConflictCount;
+
+  // Attention scoring — delegated to pure function
+  const attention = scoreAttention({
+    sessionStatus: session?.status,
+    sessionError: session?.error,
+    activityState,
+    idleDurationMs,
+    contextPressure,
+    fileConflictCount,
+    externalConflictCount,
+    reviewQueueDepth: tracker.reviewQueueDepth,
+  });
+
+  return {
+    projectId: tracker.projectId,
+    sessionId: tracker.sessionId,
+    activityState,
+    activeTool,
+    idleDurationMs,
+    burnRatePerHour,
+    contextPressure,
+    fileConflictCount,
+    externalConflictCount,
+    attentionScore: attention.score,
+    attentionReason: attention.reason,
+  };
+}
+
+/** Get health for a single project (reactive via tickTs) */
+export function getProjectHealth(projectId: ProjectIdType): ProjectHealth | null {
+  // Touch tickTs to make this reactive to the timer
+  const now = tickTs;
+  const t = trackers.get(projectId);
+  if (!t) return null;
+  return computeHealth(t, now);
+}
+
+/** Get all project health sorted by attention score descending */
+export function getAllProjectHealth(): ProjectHealth[] {
+  const now = tickTs;
+  const results: ProjectHealth[] = [];
+  for (const t of trackers.values()) {
+    results.push(computeHealth(t, now));
+  }
+  results.sort((a, b) => b.attentionScore - a.attentionScore);
+  return results;
+}
+
+/** Get top N items needing attention */
+export function getAttentionQueue(limit = 5): ProjectHealth[] {
+  return getAllProjectHealth().filter(h => h.attentionScore > 0).slice(0, limit);
+}
+
+/** Get aggregate stats across all tracked projects */
+export function getHealthAggregates(): {
+  running: number;
+  idle: number;
+  stalled: number;
+  totalBurnRatePerHour: number;
+} {
+  const all = getAllProjectHealth();
+  let running = 0;
+  let idle = 0;
+  let stalled = 0;
+  let totalBurnRatePerHour = 0;
+  for (const h of all) {
+    if (h.activityState === 'running') running++;
+    else if (h.activityState === 'idle') idle++;
+    else if (h.activityState === 'stalled') stalled++;
+    totalBurnRatePerHour += h.burnRatePerHour;
+  }
+  return { running, idle, stalled, totalBurnRatePerHour };
+}
diff --git a/v2/src/lib/stores/layout.svelte.ts b/v2/src/lib/stores/layout.svelte.ts
new file mode 100644
index 0000000..acfe905
--- /dev/null
+++ b/v2/src/lib/stores/layout.svelte.ts
@@ -0,0 +1,193 @@
+import {
+  listSessions,
+  saveSession,
+  deleteSession,
+  updateSessionTitle,
+  touchSession,
+  saveLayout,
+  loadLayout,
+  updateSessionGroup,
+  type PersistedSession,
+} from '../adapters/session-bridge';
+
+export type LayoutPreset = '1-col' | '2-col' | '3-col' | '2x2' | 'master-stack';
+
+export type PaneType = 'terminal' | 'agent' | 'markdown' | 'ssh' | 'context' | 'empty';
+
+export interface Pane {
+  id: string;
+  type: PaneType;
+  title: string;
+  shell?: string;
+  cwd?: string;
+  args?: string[];
+  group?: string;
+  focused: boolean;
+  remoteMachineId?: string;
+}
+
+let panes = $state<Pane[]>([]);
+let activePreset = $state<LayoutPreset>('1-col');
+let focusedPaneId = $state<string | null>(null);
+let initialized = false;
+
+// --- Persistence helpers (fire-and-forget with error logging) ---
+
+function persistSession(pane: Pane): void {
+  const now = Math.floor(Date.now() / 1000);
+  const session: PersistedSession = {
+    id: pane.id,
+    type: pane.type,
+    title: pane.title,
+    shell: pane.shell,
+    cwd: pane.cwd,
+    args: pane.args,
+    group_name: pane.group ?? '',
+    created_at: now,
+    last_used_at: now,
+  };
+  saveSession(session).catch(e => console.warn('Failed to persist session:', e));
+}
+
+function persistLayout(): void {
+  saveLayout({
+    preset: activePreset,
+    pane_ids: panes.map(p => p.id),
+  }).catch(e => console.warn('Failed to persist layout:', e));
+}
+
+// --- Public API ---
+
+export function getPanes(): Pane[] {
+  return panes;
+}
+
+export function getActivePreset(): LayoutPreset {
+  return activePreset;
+}
+
+export function getFocusedPaneId(): string | null {
+  return focusedPaneId;
+}
+
+export function addPane(pane: Omit<Pane, 'focused'>): void {
+  panes.push({ ...pane, focused: false });
+  focusPane(pane.id);
+  autoPreset();
+  persistSession({ ...pane, focused: false });
+  persistLayout();
+}
+
+export function removePane(id: string): void {
+  panes = panes.filter(p => p.id !== id);
+  if (focusedPaneId === id) {
+    focusedPaneId = panes.length > 0 ? panes[0].id : null;
+  }
+  autoPreset();
+  deleteSession(id).catch(e => console.warn('Failed to delete session:', e));
+  persistLayout();
+}
+
+export function focusPane(id: string): void {
+  focusedPaneId = id;
+  panes = panes.map(p => ({ ...p, focused: p.id === id }));
+  touchSession(id).catch(e => console.warn('Failed to touch session:', e));
+}
+
+export function focusPaneByIndex(index: number): void {
+  if (index >= 0 && index < panes.length) {
+    focusPane(panes[index].id);
+  }
+}
+
+export function setPreset(preset: LayoutPreset): void {
+  activePreset = preset;
+  persistLayout();
+}
+
+export function renamePaneTitle(id: string, title: string): void {
+  const pane = panes.find(p => p.id === id);
+  if (pane) {
+    pane.title = title;
+    updateSessionTitle(id, title).catch(e => console.warn('Failed to update title:', e));
+  }
+}
+
+export function setPaneGroup(id: string, group: string): void {
+  const pane = panes.find(p => p.id === id);
+  if (pane) {
+    pane.group = group || undefined;
+    updateSessionGroup(id, group).catch(e => console.warn('Failed to update group:', e));
+  }
+}
+
+/** Restore panes and layout from SQLite on app startup */
+export async function restoreFromDb(): Promise<void> {
+  if (initialized) return;
+  initialized = true;
+
+  try {
+    const [sessions, layout] = await Promise.all([listSessions(), loadLayout()]);
+
+    if (layout.preset) {
+      activePreset = layout.preset as LayoutPreset;
+    }
+
+    // Restore panes in layout order, falling back to DB order
+    const sessionMap = new Map(sessions.map(s => [s.id, s]));
+    const orderedIds = layout.pane_ids.length > 0 ? layout.pane_ids : sessions.map(s => s.id);
+
+    for (const id of orderedIds) {
+      const s = sessionMap.get(id);
+      if (!s) continue;
+      panes.push({
+        id: s.id,
+        type: s.type as PaneType,
+        title: s.title,
+        shell: s.shell ?? undefined,
+        cwd: s.cwd ?? undefined,
+        args: s.args ?? undefined,
+        group: s.group_name || undefined,
+        focused: false,
+      });
+    }
+
+    if (panes.length > 0) {
+      focusPane(panes[0].id);
+    }
+  } catch (e) {
+    console.warn('Failed to restore sessions from DB:', e);
+  }
+}
+
+function autoPreset(): void {
+  const count = panes.length;
+  if (count <= 1) activePreset = '1-col';
+  else if (count === 2) activePreset = '2-col';
+  else if (count === 3) activePreset = 'master-stack';
+  else activePreset = '2x2';
+}
+
+/** CSS grid-template for current preset */
+export function getGridTemplate(): { columns: string; rows: string } {
+  switch (activePreset) {
+    case '1-col':
+      return { columns: '1fr', rows: '1fr' };
+    case '2-col':
+      return { columns: '1fr 1fr', rows: '1fr' };
+    case '3-col':
+      return { columns: '1fr 1fr 1fr', rows: '1fr' };
+    case '2x2':
+      return { columns: '1fr 1fr', rows: '1fr 1fr' };
+    case 'master-stack':
+      return { columns: '2fr 1fr', rows: '1fr 1fr' };
+  }
+}
+
+/** For master-stack: first pane spans full height */
+export function getPaneGridArea(index: number): string | undefined {
+  if (activePreset === 'master-stack' && index === 0) {
+    return '1 / 1 / 3 / 2';
+  }
+  return undefined;
+}
diff --git a/v2/src/lib/stores/layout.test.ts b/v2/src/lib/stores/layout.test.ts
new file mode 100644
index 0000000..ffd4b1b
--- /dev/null
+++ b/v2/src/lib/stores/layout.test.ts
@@ -0,0 +1,299 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+// Mock session-bridge before importing the layout store
+vi.mock('../adapters/session-bridge', () => ({
+  listSessions: vi.fn().mockResolvedValue([]),
+  saveSession: vi.fn().mockResolvedValue(undefined),
+  deleteSession: vi.fn().mockResolvedValue(undefined),
+  updateSessionTitle: vi.fn().mockResolvedValue(undefined),
+  touchSession: vi.fn().mockResolvedValue(undefined),
+  saveLayout: vi.fn().mockResolvedValue(undefined),
+  loadLayout: vi.fn().mockResolvedValue({ preset: '1-col', pane_ids: [] }),
+}));
+
+import {
+  getPanes,
+  getActivePreset,
+  getFocusedPaneId,
+  addPane,
+  removePane,
+  focusPane,
+  focusPaneByIndex,
+  setPreset,
+  renamePaneTitle,
+  getGridTemplate,
+  getPaneGridArea,
+  type LayoutPreset,
+  type Pane,
+} from './layout.svelte';
+
+// Helper to reset module state between tests
+// The layout store uses module-level $state, so we need to clean up
+function clearAllPanes(): void {
+  const panes = getPanes();
+  const ids = panes.map(p => p.id);
+  for (const id of ids) {
+    removePane(id);
+  }
+}
+
+beforeEach(() => {
+  clearAllPanes();
+  setPreset('1-col');
+  vi.clearAllMocks();
+});
+
+describe('layout store', () => {
+  describe('addPane', () => {
+    it('adds a pane to the list', () => {
+      addPane({ id: 'p1', type: 'terminal', title: 'Terminal 1' });
+
+      const panes = getPanes();
+      expect(panes).toHaveLength(1);
+      expect(panes[0].id).toBe('p1');
+      expect(panes[0].type).toBe('terminal');
+      expect(panes[0].title).toBe('Terminal 1');
+    });
+
+    it('sets focused to false initially then focuses via focusPane', () => {
+      addPane({ id: 'p1', type: 'terminal', title: 'T1' });
+
+      // addPane calls focusPane internally, so the pane should be focused
+      expect(getFocusedPaneId()).toBe('p1');
+      const panes = getPanes();
+      expect(panes[0].focused).toBe(true);
+    });
+
+    it('focuses the newly added pane', () => {
+      addPane({ id: 'p1', type: 'terminal', title: 'T1' });
+      addPane({ id: 'p2', type: 'agent', title: 'Agent 1' });
+
+      expect(getFocusedPaneId()).toBe('p2');
+    });
+
+    it('calls autoPreset when adding panes', () => {
+      // 1 pane -> 1-col
+      addPane({ id: 'p1', type: 'terminal', title: 'T1' });
+      expect(getActivePreset()).toBe('1-col');
+
+      // 2 panes -> 2-col
+      addPane({ id: 'p2', type: 'terminal', title: 'T2' });
+      expect(getActivePreset()).toBe('2-col');
+
+      // 3 panes -> master-stack
+      addPane({ id: 'p3', type: 'terminal', title: 'T3' });
+      expect(getActivePreset()).toBe('master-stack');
+
+      // 4+ panes -> 2x2
+      addPane({ id: 'p4', type: 'terminal', title: 'T4' });
+      expect(getActivePreset()).toBe('2x2');
+    });
+  });
+
+  describe('removePane', () => {
+    it('removes a pane by id', () => {
+      addPane({ id: 'p1', type: 'terminal', title: 'T1' });
+      addPane({ id: 'p2', type: 'terminal', title: 'T2' });
+
+      removePane('p1');
+
+      const panes = getPanes();
+      expect(panes).toHaveLength(1);
+      expect(panes[0].id).toBe('p2');
+    });
+
+    it('focuses the first remaining pane when focused pane is removed', () => {
+      addPane({ id: 'p1', type: 'terminal', title: 'T1' });
+      addPane({ id: 'p2', type: 'terminal', title: 'T2' });
+      addPane({ id: 'p3', type: 'terminal', title: 'T3' });
+
+      // p3 is focused (last added)
+      expect(getFocusedPaneId()).toBe('p3');
+
+      removePane('p3');
+
+      // Should focus p1 (first remaining)
+      expect(getFocusedPaneId()).toBe('p1');
+    });
+
+    it('sets focusedPaneId to null when last pane is removed', () => {
+      addPane({ id: 'p1', type: 'terminal', title: 'T1' });
+      removePane('p1');
+
+      expect(getFocusedPaneId()).toBeNull();
+    });
+
+    it('adjusts preset via autoPreset after removal', () => {
+      addPane({ id: 'p1', type: 'terminal', title: 'T1' });
+      addPane({ id: 'p2', type: 'terminal', title: 'T2' });
+      expect(getActivePreset()).toBe('2-col');
+
+      removePane('p2');
+      expect(getActivePreset()).toBe('1-col');
+    });
+
+    it('does not change focus if removed pane was not focused', () => {
+      addPane({ id: 'p1', type: 'terminal', title: 'T1' });
+      addPane({ id: 'p2', type: 'terminal', title: 'T2' });
+
+      // p2 is focused (last added). Remove p1
+      focusPane('p2');
+      removePane('p1');
+
+      expect(getFocusedPaneId()).toBe('p2');
+    });
+  });
+
+  describe('focusPane', () => {
+    it('sets focused flag on the target pane', () => {
+      addPane({ id: 'p1', type: 'terminal', title: 'T1' });
+      addPane({ id: 'p2', type: 'terminal', title: 'T2' });
+
+      focusPane('p1');
+
+      const panes = getPanes();
+      expect(panes.find(p => p.id === 'p1')?.focused).toBe(true);
+      expect(panes.find(p => p.id === 'p2')?.focused).toBe(false);
+      expect(getFocusedPaneId()).toBe('p1');
+    });
+  });
+
+  describe('focusPaneByIndex', () => {
+    it('focuses pane at the given index', () => {
+      addPane({ id: 'p1', type: 'terminal', title: 'T1' });
+      addPane({ id: 'p2', type: 'terminal', title: 'T2' });
+
+      focusPaneByIndex(0);
+
+      expect(getFocusedPaneId()).toBe('p1');
+    });
+
+    it('ignores out-of-bounds indices', () => {
+      addPane({ id: 'p1', type: 'terminal', title: 'T1' });
+
+      focusPaneByIndex(5);
+
+      // Should remain on p1
+      expect(getFocusedPaneId()).toBe('p1');
+    });
+
+    it('ignores negative indices', () => {
+      addPane({ id: 'p1', type: 'terminal', title: 'T1' });
+
+      focusPaneByIndex(-1);
+
+      expect(getFocusedPaneId()).toBe('p1');
+    });
+  });
+
+  describe('setPreset', () => {
+    it('overrides the active preset', () => {
+      setPreset('3-col');
+      expect(getActivePreset()).toBe('3-col');
+    });
+
+    it('allows setting any valid preset', () => {
+      const presets: LayoutPreset[] = ['1-col', '2-col', '3-col', '2x2', 'master-stack'];
+      for (const preset of presets) {
+        setPreset(preset);
+        expect(getActivePreset()).toBe(preset);
+      }
+    });
+  });
+
+  describe('renamePaneTitle', () => {
+    it('updates the title of a pane', () => {
+      addPane({ id: 'p1', type: 'terminal', title: 'Old Title' });
+
+      renamePaneTitle('p1', 'New Title');
+
+      const panes = getPanes();
+      expect(panes[0].title).toBe('New Title');
+    });
+
+    it('does nothing for non-existent pane', () => {
+      addPane({ id: 'p1', type: 'terminal', title: 'Title' });
+
+      renamePaneTitle('p-nonexistent', 'New Title');
+
+      expect(getPanes()[0].title).toBe('Title');
+    });
+  });
+
+  describe('getGridTemplate', () => {
+    it('returns 1fr / 1fr for 1-col', () => {
+      setPreset('1-col');
+      expect(getGridTemplate()).toEqual({ columns: '1fr', rows: '1fr' });
+    });
+
+    it('returns 1fr 1fr / 1fr for 2-col', () => {
+      setPreset('2-col');
+      expect(getGridTemplate()).toEqual({ columns: '1fr 1fr', rows: '1fr' });
+    });
+
+    it('returns 1fr 1fr 1fr / 1fr for 3-col', () => {
+      setPreset('3-col');
+      expect(getGridTemplate()).toEqual({ columns: '1fr 1fr 1fr', rows: '1fr' });
+    });
+
+    it('returns 1fr 1fr / 1fr 1fr for 2x2', () => {
+      setPreset('2x2');
+      expect(getGridTemplate()).toEqual({ columns: '1fr 1fr', rows: '1fr 1fr' });
+    });
+
+    it('returns 2fr 1fr / 1fr 1fr for master-stack', () => {
+      setPreset('master-stack');
+      expect(getGridTemplate()).toEqual({ columns: '2fr 1fr', rows: '1fr 1fr' });
+    });
+  });
+
+  describe('getPaneGridArea', () => {
+    it('returns grid area for first pane in master-stack', () => {
+      setPreset('master-stack');
+      expect(getPaneGridArea(0)).toBe('1 / 1 / 3 / 2');
+    });
+
+    it('returns undefined for non-first panes in master-stack', () => {
+      setPreset('master-stack');
+      expect(getPaneGridArea(1)).toBeUndefined();
+      expect(getPaneGridArea(2)).toBeUndefined();
+    });
+
+    it('returns undefined for all panes in non-master-stack presets', () => {
+      setPreset('2-col');
+      expect(getPaneGridArea(0)).toBeUndefined();
+      expect(getPaneGridArea(1)).toBeUndefined();
+    });
+  });
+
+  describe('autoPreset behavior', () => {
+    it('0 panes -> 1-col', () => {
+      expect(getActivePreset()).toBe('1-col');
+    });
+
+    it('1 pane -> 1-col', () => {
+      addPane({ id: 'p1', type: 'terminal', title: 'T1' });
+      expect(getActivePreset()).toBe('1-col');
+    });
+
+    it('2 panes -> 2-col', () => {
+      addPane({ id: 'p1', type: 'terminal', title: 'T1' });
+      addPane({ id: 'p2', type: 'terminal', title: 'T2' });
+      expect(getActivePreset()).toBe('2-col');
+    });
+
+    it('3 panes -> master-stack', () => {
+      addPane({ id: 'p1', type: 'terminal', title: 'T1' });
+      addPane({ id: 'p2', type: 'terminal', title: 'T2' });
+      addPane({ id: 'p3', type: 'terminal', title: 'T3' });
+      expect(getActivePreset()).toBe('master-stack');
+    });
+
+    it('4+ panes -> 2x2', () => {
+      for (let i = 1; i <= 5; i++) {
+        addPane({ id: `p${i}`, type: 'terminal', title: `T${i}` });
+      }
+      expect(getActivePreset()).toBe('2x2');
+    });
+  });
+});
diff --git a/v2/src/lib/stores/machines.svelte.ts b/v2/src/lib/stores/machines.svelte.ts
new file mode 100644
index 0000000..c035ce9
--- /dev/null
+++ b/v2/src/lib/stores/machines.svelte.ts
@@ -0,0 +1,131 @@
+// Remote machines store — tracks connection state for multi-machine support
+
+import {
+  listRemoteMachines,
+  addRemoteMachine,
+  removeRemoteMachine,
+  connectRemoteMachine,
+  disconnectRemoteMachine,
+  onRemoteMachineReady,
+  onRemoteMachineDisconnected,
+  onRemoteError,
+  onRemoteMachineReconnecting,
+  onRemoteMachineReconnectReady,
+  type RemoteMachineConfig,
+  type RemoteMachineInfo,
+} from '../adapters/remote-bridge';
+import { notify } from './notifications.svelte';
+
+export interface Machine extends RemoteMachineInfo {}
+
+let machines = $state<Machine[]>([]);
+
+export function getMachines(): Machine[] {
+  return machines;
+}
+
+export function getMachine(id: string): Machine | undefined {
+  return machines.find(m => m.id === id);
+}
+
+export async function loadMachines(): Promise<void> {
+  try {
+    machines = await listRemoteMachines();
+  } catch (e) {
+    console.warn('Failed to load remote machines:', e);
+  }
+}
+
+export async function addMachine(config: RemoteMachineConfig): Promise<string> {
+  const id = await addRemoteMachine(config);
+  machines.push({
+    id,
+    label: config.label,
+    url: config.url,
+    status: 'disconnected',
+    auto_connect: config.auto_connect,
+  });
+  return id;
+}
+
+export async function removeMachine(id: string): Promise<void> {
+  await removeRemoteMachine(id);
+  machines = machines.filter(m => m.id !== id);
+}
+
+export async function connectMachine(id: string): Promise<void> {
+  const machine = machines.find(m => m.id === id);
+  if (machine) machine.status = 'connecting';
+  try {
+    await connectRemoteMachine(id);
+    if (machine) machine.status = 'connected';
+  } catch (e) {
+    if (machine) machine.status = 'error';
+    throw e;
+  }
+}
+
+export async function disconnectMachine(id: string): Promise<void> {
+  await disconnectRemoteMachine(id);
+  const machine = machines.find(m => m.id === id);
+  if (machine) machine.status = 'disconnected';
+}
+
+// Stored unlisten functions for cleanup
+let unlistenFns: (() => void)[] = [];
+
+// Initialize event listeners for machine status updates
+export async function initMachineListeners(): Promise<void> {
+  // Clean up any existing listeners first
+  destroyMachineListeners();
+
+  unlistenFns.push(await onRemoteMachineReady((msg) => {
+    const machine = machines.find(m => m.id === msg.machineId);
+    if (machine) {
+      machine.status = 'connected';
+      notify('success', `Connected to ${machine.label}`);
+    }
+  }));
+
+  unlistenFns.push(await onRemoteMachineDisconnected((msg) => {
+    const machine = machines.find(m => m.id === msg.machineId);
+    if (machine) {
+      machine.status = 'disconnected';
+      notify('warning', `Disconnected from ${machine.label}`);
+    }
+  }));
+
+  unlistenFns.push(await onRemoteError((msg) => {
+    const machine = machines.find(m => m.id === msg.machineId);
+    if (machine) {
+      machine.status = 'error';
+      notify('error', `Error from ${machine.label}: ${msg.error}`);
+    }
+  }));
+
+  unlistenFns.push(await onRemoteMachineReconnecting((msg) => {
+    const machine = machines.find(m => m.id === msg.machineId);
+    if (machine) {
+      machine.status = 'reconnecting';
+      notify('info', `Reconnecting to ${machine.label} in ${msg.backoffSecs}s…`);
+    }
+  }));
+
+  unlistenFns.push(await onRemoteMachineReconnectReady((msg) => {
+    const machine = machines.find(m => m.id === msg.machineId);
+    if (machine) {
+      notify('info', `${machine.label} reachable — reconnecting…`);
+      connectMachine(msg.machineId).catch((e) => {
+        notify('error', `Auto-reconnect failed for ${machine.label}: ${e}`);
+      });
+    }
+  }));
+}
+
+/** Remove all event listeners to prevent leaks */
+export function destroyMachineListeners(): void {
+  for (const unlisten of unlistenFns) {
+    unlisten();
+  }
+  unlistenFns = [];
+}
diff --git a/v2/src/lib/stores/notifications.svelte.ts b/v2/src/lib/stores/notifications.svelte.ts
new file mode 100644
index 0000000..8206890
--- /dev/null
+++ b/v2/src/lib/stores/notifications.svelte.ts
@@ -0,0 +1,152 @@
+// Notification store — ephemeral toasts + persistent notification history
+
+import { sendDesktopNotification } from '../adapters/notifications-bridge';
+
+// --- Toast types (existing) ---
+
+export type ToastType = 'info' | 'success' | 'warning' | 'error';
+
+export interface Toast {
+  id: string;
+  type: ToastType;
+  message: string;
+  timestamp: number;
+}
+
+// --- Notification history types (new) ---
+
+export type NotificationType =
+  | 'agent_complete'
+  | 'agent_error'
+  | 'task_review'
+  | 'wake_event'
+  | 'conflict'
+  | 'system';
+
+export interface HistoryNotification {
+  id: string;
+  title: string;
+  body: string;
+  type: NotificationType;
+  timestamp: number;
+  read: boolean;
+  projectId?: string;
+}
+
+// --- State ---
+
+let toasts = $state<Toast[]>([]);
+let notificationHistory = $state<HistoryNotification[]>([]);
+
+const MAX_TOASTS = 5;
+const TOAST_DURATION_MS = 4000;
+const MAX_HISTORY = 100;
+
+// --- Toast API (preserved from original) ---
+
+export function getNotifications(): Toast[] {
+  return toasts;
+}
+
+export function notify(type: ToastType, message: string): string {
+  const id = crypto.randomUUID();
+  toasts.push({ id, type, message, timestamp: Date.now() });
+
+  // Cap visible toasts
+  if (toasts.length > MAX_TOASTS) {
+    toasts = toasts.slice(-MAX_TOASTS);
+  }
+
+  // Auto-dismiss
+  setTimeout(() => dismissNotification(id), TOAST_DURATION_MS);
+
+  return id;
+}
+
+export function dismissNotification(id: string): void {
+  toasts = toasts.filter(n => n.id !== id);
+}
+
+// --- Notification History API (new) ---
+
+/** Map NotificationType to a toast type for the ephemeral toast */
+function notificationTypeToToast(type: NotificationType): ToastType {
+  switch (type) {
+    case 'agent_complete': return 'success';
+    case 'agent_error': return 'error';
+    case 'task_review': return 'info';
+    case 'wake_event': return 'info';
+    case 'conflict': return 'warning';
+    case 'system': return 'info';
+  }
+}
+
+/** Map NotificationType to OS notification urgency */
+function notificationUrgency(type: NotificationType): 'low' | 'normal' | 'critical' {
+  switch (type) {
+    case 'agent_error': return 'critical';
+    case 'conflict': return 'normal';
+    case 'system': return 'normal';
+    default: return 'low';
+  }
+}
+
+/**
+ * Add a notification to history, show a toast, and send an OS desktop notification.
+ */
+export function addNotification(
+  title: string,
+  body: string,
+  type: NotificationType,
+  projectId?: string,
+): string {
+  const id = crypto.randomUUID();
+
+  // Add to history
+  notificationHistory.push({
+    id,
+    title,
+    body,
+    type,
+    timestamp: Date.now(),
+    read: false,
+    projectId,
+  });
+
+  // Cap history
+  if (notificationHistory.length > MAX_HISTORY) {
+    notificationHistory = notificationHistory.slice(-MAX_HISTORY);
+  }
+
+  // Show ephemeral toast
+  const toastType = notificationTypeToToast(type);
+  notify(toastType, `${title}: ${body}`);
+
+  // Send OS desktop notification (fire-and-forget)
+  sendDesktopNotification(title, body, notificationUrgency(type));
+
+  return id;
+}
+
+export function getNotificationHistory(): HistoryNotification[] {
+  return notificationHistory;
+}
+
+export function getUnreadCount(): number {
+  return notificationHistory.filter(n => !n.read).length;
+}
+
+export function markRead(id: string): void {
+  const entry = notificationHistory.find(n => n.id === id);
+  if (entry) entry.read = true;
+}
+
+export function markAllRead(): void {
+  for (const entry of notificationHistory) {
+    entry.read = true;
+  }
+}
+
+export function clearHistory(): void {
+  notificationHistory = [];
+}
diff --git a/v2/src/lib/stores/plugins.svelte.ts b/v2/src/lib/stores/plugins.svelte.ts
new file mode 100644
index 0000000..fa10463
--- /dev/null
+++ b/v2/src/lib/stores/plugins.svelte.ts
@@ -0,0 +1,203 @@
+/**
+ * Plugin store — tracks plugin commands, event bus, and plugin state.
+ * Uses Svelte 5 runes for reactivity.
+ */
+
+import type { PluginMeta } from '../adapters/plugins-bridge';
+import { discoverPlugins } from '../adapters/plugins-bridge';
+import { getSetting, setSetting } from '../adapters/settings-bridge';
+import { loadPlugin, unloadPlugin, unloadAllPlugins, getLoadedPlugins } from '../plugins/plugin-host';
+import type { GroupId, AgentId } from '../types/ids';
+
+// --- Plugin command registry (for CommandPalette) ---
+
+export interface PluginCommand {
+  pluginId: string;
+  label: string;
+  callback: () => void;
+}
+
+let commands = $state<PluginCommand[]>([]);
+
+/** Get all plugin-registered commands (reactive). */
+export function getPluginCommands(): PluginCommand[] {
+  return commands;
+}
+
+/** Register a command from a plugin. Called by plugin-host. */
+export function addPluginCommand(pluginId: string, label: string, callback: () => void): void {
+  commands = [...commands, { pluginId, label, callback }];
+}
+
+/** Remove all commands registered by a specific plugin. Called on unload. */
+export function removePluginCommands(pluginId: string): void {
+  commands = commands.filter(c => c.pluginId !== pluginId);
+}
+
+// --- Plugin event bus (simple pub/sub) ---
+
+type EventCallback = (data: unknown) => void;
+
+class PluginEventBusImpl {
+  private listeners = new Map<string, Set<EventCallback>>();
+
+  on(event: string, callback: EventCallback): void {
+    let set = this.listeners.get(event);
+    if (!set) {
+      set = new Set();
+      this.listeners.set(event, set);
+    }
+    set.add(callback);
+  }
+
+  off(event: string, callback: EventCallback): void {
+    const set = this.listeners.get(event);
+    if (set) {
+      set.delete(callback);
+      if (set.size === 0) this.listeners.delete(event);
+    }
+  }
+
+  emit(event: string, data?: unknown): void {
+    const set = this.listeners.get(event);
+    if (!set) return;
+    for (const cb of set) {
+      try {
+        cb(data);
+      } catch (e) {
+        console.error(`Plugin event handler error for '${event}':`, e);
+      }
+    }
+  }
+
+  clear(): void {
+    this.listeners.clear();
+  }
+}
+
+export const pluginEventBus = new PluginEventBusImpl();
+
+// --- Plugin discovery and lifecycle ---
+
+export type PluginStatus = 'discovered' | 'loaded' | 'error' | 'disabled';
+
+export interface PluginEntry {
+  meta: PluginMeta;
+  status: PluginStatus;
+  error?: string;
+}
+
+let pluginEntries = $state<PluginEntry[]>([]);
+
+/** Get all discovered plugins with their status (reactive). */
+export function getPluginEntries(): PluginEntry[] {
+  return pluginEntries;
+}
+
+/** Settings key for plugin enabled state */
+function pluginEnabledKey(pluginId: string): string {
+  return `plugin_enabled_${pluginId}`;
+}
+
+/** Check if a plugin is enabled in settings (default: true for new plugins) */
+async function isPluginEnabled(pluginId: string): Promise<boolean> {
+  const val = await getSetting(pluginEnabledKey(pluginId));
+  if (val === null || val === undefined) return true; // enabled by default
+  return val === 'true' || val === '1';
+}
+
+/** Set plugin enabled state */
+export async function setPluginEnabled(pluginId: string, enabled: boolean): Promise<void> {
+  await setSetting(pluginEnabledKey(pluginId), enabled ? 'true' : 'false');
+
+  // Update in-memory state
+  if (enabled) {
+    const entry = pluginEntries.find(e => e.meta.id === pluginId);
+    if (entry && entry.status === 'disabled') {
+      await loadSinglePlugin(entry);
+    }
+  } else {
+    unloadPlugin(pluginId);
+    pluginEntries = pluginEntries.map(e =>
+      e.meta.id === pluginId ? { ...e, status: 'disabled' as PluginStatus, error: undefined } : e,
+    );
+  }
+}
+
+/** Load a single plugin entry, updating its status */
+async function loadSinglePlugin(
+  entry: PluginEntry,
+  groupId?: GroupId,
+  agentId?: AgentId,
+): Promise<void> {
+  const gid = groupId ?? ('' as GroupId);
+  const aid = agentId ?? ('admin' as AgentId);
+
+  try {
+    await loadPlugin(entry.meta, gid, aid);
+    pluginEntries = pluginEntries.map(e =>
+      e.meta.id === entry.meta.id ? { ...e, status: 'loaded' as PluginStatus, error: undefined } : e,
+    );
+  } catch (e) {
+    const errorMsg = e instanceof Error ? e.message : String(e);
+    console.error(`Failed to load plugin '${entry.meta.id}':`, errorMsg);
+    pluginEntries = pluginEntries.map(e =>
+      e.meta.id === entry.meta.id ? { ...e, status: 'error' as PluginStatus, error: errorMsg } : e,
+    );
+  }
+}
+
+/**
+ * Discover and load all enabled plugins.
+ * Called at app startup or when reloading plugins.
+ */
+export async function loadAllPlugins(groupId?: GroupId, agentId?: AgentId): Promise<void> {
+  // Unload any currently loaded plugins first
+  unloadAllPlugins();
+  pluginEventBus.clear();
+  commands = [];
+
+  let discovered: PluginMeta[];
+  try {
+    discovered = await discoverPlugins();
+  } catch (e) {
+    console.error('Failed to discover plugins:', e);
+    pluginEntries = [];
+    return;
+  }
+
+  // Build entries with initial status
+  const entries: PluginEntry[] = [];
+  for (const meta of discovered) {
+    const enabled = await isPluginEnabled(meta.id);
+    entries.push({
+      meta,
+      status: enabled ? 'discovered' : 'disabled',
+    });
+  }
+  pluginEntries = entries;
+
+  // Load enabled plugins
+  for (const entry of pluginEntries) {
+    if (entry.status === 'discovered') {
+      await loadSinglePlugin(entry, groupId, agentId);
+    }
+  }
+}
+
+/**
+ * Reload all plugins (re-discover and re-load).
+ */
+export async function reloadAllPlugins(groupId?: GroupId, agentId?: AgentId): Promise<void> {
+  await loadAllPlugins(groupId, agentId);
+}
+
+/**
+ * Clean up all plugins and state.
+ */
+export function destroyAllPlugins(): void {
+  unloadAllPlugins();
+  pluginEventBus.clear();
+  commands = [];
+  pluginEntries = [];
+}
diff --git a/v2/src/lib/stores/sessions.svelte.ts b/v2/src/lib/stores/sessions.svelte.ts
new file mode 100644
index 0000000..ab1ecef
--- /dev/null
+++ b/v2/src/lib/stores/sessions.svelte.ts
@@ -0,0 +1,26 @@
+// Session state management — Svelte 5 runes
+// Phase 4: full session CRUD, persistence
+
+export type SessionType = 'terminal' | 'agent' | 'markdown';
+
+export interface Session {
+  id: string;
+  type: SessionType;
+  title: string;
+  createdAt: number;
+}
+
+// Reactive session list
+let sessions = $state<Session[]>([]);
+
+export function getSessions() {
+  return sessions;
+}
+
+export function addSession(session: Session) {
+  sessions.push(session);
+}
+
+export function removeSession(id: string) {
+  sessions = sessions.filter(s => s.id !== id);
+}
diff --git a/v2/src/lib/stores/theme.svelte.ts b/v2/src/lib/stores/theme.svelte.ts
new file mode 100644
index 0000000..8c32966
--- /dev/null
+++ b/v2/src/lib/stores/theme.svelte.ts
@@ -0,0 +1,98 @@
+// Theme store — persists theme selection via settings bridge
+
+import { getSetting, setSetting } from '../adapters/settings-bridge';
+import {
+  type ThemeId,
+  type CatppuccinFlavor,
+  ALL_THEME_IDS,
+  buildXtermTheme,
+  applyCssVariables,
+  type XtermTheme,
+} from '../styles/themes';
+
+let currentTheme = $state<ThemeId>('mocha');
+
+/** Registered theme-change listeners */
+const themeChangeCallbacks = new Set<() => void>();
+
+/** Register a callback invoked after every theme change. Returns an unsubscribe function. */
+export function onThemeChange(callback: () => void): () => void {
+  themeChangeCallbacks.add(callback);
+  return () => {
+    themeChangeCallbacks.delete(callback);
+  };
+}
+
+export function getCurrentTheme(): ThemeId {
+  return currentTheme;
+}
+
+/** @deprecated Use getCurrentTheme() */
+export function getCurrentFlavor(): CatppuccinFlavor {
+  // Return valid CatppuccinFlavor or default to 'mocha'
+  const catFlavors: string[] = ['latte', 'frappe', 'macchiato', 'mocha'];
+  return catFlavors.includes(currentTheme) ? currentTheme as CatppuccinFlavor : 'mocha';
+}
+
+export function getXtermTheme(): XtermTheme {
+  return buildXtermTheme(currentTheme);
+}
+
+/** Change theme, apply CSS variables, and persist to settings DB */
+export async function setTheme(theme: ThemeId): Promise<void> {
+  currentTheme = theme;
+  applyCssVariables(theme);
+  // Notify all listeners (e.g. open xterm.js terminals)
+  for (const cb of themeChangeCallbacks) {
+    try {
+      cb();
+    } catch (e) {
+      console.error('Theme change callback error:', e);
+    }
+  }
+
+  try {
+    await setSetting('theme', theme);
+  } catch (e) {
+    console.error('Failed to persist theme setting:', e);
+  }
+}
+
+/** @deprecated Use setTheme() */
+export async function setFlavor(flavor: CatppuccinFlavor): Promise<void> {
+  return setTheme(flavor);
+}
+
+/** Load saved theme from settings DB and apply. Call once on app startup. */
+export async function initTheme(): Promise<void> {
+  try {
+    const saved = await getSetting('theme');
+    if (saved && ALL_THEME_IDS.includes(saved as ThemeId)) {
+      currentTheme = saved as ThemeId;
+    }
+  } catch {
+    // Fall back to default (mocha) — catppuccin.css provides Mocha defaults
+  }
+  // Always apply to sync CSS vars with current theme
+  // (skip if mocha — catppuccin.css already has Mocha values)
+  if (currentTheme !== 'mocha') {
+    applyCssVariables(currentTheme);
+  }
+
+  // Apply saved font settings
+  try {
+    const [uiFont, uiSize, termFont, termSize] = await Promise.all([
+      getSetting('ui_font_family'),
+      getSetting('ui_font_size'),
+      getSetting('term_font_family'),
+      getSetting('term_font_size'),
+    ]);
+    const root = document.documentElement.style;
+    if (uiFont) root.setProperty('--ui-font-family', `'${uiFont}', sans-serif`);
+    if (uiSize) root.setProperty('--ui-font-size', `${uiSize}px`);
+    if (termFont) root.setProperty('--term-font-family', `'${termFont}', monospace`);
+    if (termSize) root.setProperty('--term-font-size', `${termSize}px`);
+  } catch {
+    // Font settings are optional — defaults from catppuccin.css apply
+  }
+}
diff --git a/v2/src/lib/stores/wake-scheduler.svelte.ts b/v2/src/lib/stores/wake-scheduler.svelte.ts
new file mode 100644
index 0000000..1ccc512
--- /dev/null
+++ b/v2/src/lib/stores/wake-scheduler.svelte.ts
@@ -0,0 +1,269 @@
+// Wake scheduler — manages per-manager wake timers and signal evaluation
+// Supports 3 strategies: persistent, on-demand, smart (threshold-gated)
+
+import type { WakeStrategy, WakeContext, WakeProjectSnapshot, WakeTaskSummary } from '../types/wake';
+import type { AgentId } from '../types/ids';
+import { evaluateWakeSignals, shouldWake } from '../utils/wake-scorer';
+import { getAllProjectHealth, getHealthAggregates } from './health.svelte';
+import { getAllWorkItems } from './workspace.svelte';
+import { listTasks } from '../adapters/bttask-bridge';
+import { getAgentSession } from './agents.svelte';
+import { logAuditEvent } from '../adapters/audit-bridge';
+import type { GroupId } from '../types/ids';
+
+// --- Types ---
+
+interface ManagerRegistration {
+  agentId: AgentId;
+  groupId: GroupId;
+  sessionId: string;
+  strategy: WakeStrategy;
+  intervalMs: number;
+  threshold: number;
+  timerId: ReturnType<typeof setInterval> | null;
+  /** Burn rate samples for anomaly detection: [timestamp, totalRate] */
+  burnRateSamples: Array<[number, number]>;
+}
+
+export interface WakeEvent {
+  agentId: AgentId;
+  strategy: WakeStrategy;
+  context: WakeContext;
+  /** For persistent: resume with context. For on-demand/smart: fresh session with context. */
+  mode: 'resume' | 'fresh';
+}
+
+// --- State ---
+
+let registrations = $state<Map<string, ManagerRegistration>>(new Map());
+let pendingWakes = $state<Map<string, WakeEvent>>(new Map());
+/** When true, registerManager() becomes a no-op (set in test mode) */
+let schedulerDisabled = false;
+
+// --- Public API ---
+
+/** Disable the wake scheduler (call during app init in test mode) */
+export function disableWakeScheduler(): void {
+  schedulerDisabled = true;
+  clearWakeScheduler();
+}
+
+/** Register a Manager agent for wake scheduling */
+export function registerManager(
+  agentId: AgentId,
+  groupId: GroupId,
+  sessionId: string,
+  strategy: WakeStrategy,
+  intervalMin: number,
+  threshold: number,
+): void {
+  if (schedulerDisabled) return;
+
+  // Unregister first to clear any existing timer
+  unregisterManager(agentId);
+
+  const reg: ManagerRegistration = {
+    agentId,
+    groupId,
+    sessionId,
+    strategy,
+    intervalMs: intervalMin * 60 * 1000,
+    threshold,
+    timerId: null,
+    burnRateSamples: [],
+  };
+
+  registrations.set(agentId, reg);
+  startTimer(reg);
+}
+
+/** Unregister a Manager agent and stop its timer */
+export function unregisterManager(agentId: string): void {
+  const reg = registrations.get(agentId);
+  if (reg?.timerId) {
+    clearInterval(reg.timerId);
+  }
+  registrations.delete(agentId);
+  pendingWakes.delete(agentId);
+}
+
+/** Update wake config for an already-registered manager */
+export function updateManagerConfig(
+  agentId: string,
+  strategy: WakeStrategy,
+  intervalMin: number,
+  threshold: number,
+): void {
+  const reg = registrations.get(agentId);
+  if (!reg) return;
+
+  const needsRestart = reg.strategy !== strategy || reg.intervalMs !== intervalMin * 60 * 1000;
+  reg.strategy = strategy;
+  reg.intervalMs = intervalMin * 60 * 1000;
+  reg.threshold = threshold;
+
+  if (needsRestart) {
+    if (reg.timerId) clearInterval(reg.timerId);
+    startTimer(reg);
+  }
+}
+
+/** Update session ID for a registered manager (e.g., after session reset) */
+export function updateManagerSession(agentId: string, sessionId: string): void {
+  const reg = registrations.get(agentId);
+  if (reg) {
+    reg.sessionId = sessionId;
+  }
+}
+
+/** Get pending wake event for a manager (consumed by AgentSession) */
+export function getWakeEvent(agentId: string): WakeEvent | undefined {
+  return pendingWakes.get(agentId);
+}
+
+/** Consume (clear) a pending wake event after AgentSession handles it */
+export function consumeWakeEvent(agentId: string): void {
+  pendingWakes.delete(agentId);
+}
+
+/** Get all registered managers (for debugging/UI) */
+export function getRegisteredManagers(): Array<{
+  agentId: string;
+  strategy: WakeStrategy;
+  intervalMin: number;
+  threshold: number;
+  hasPendingWake: boolean;
+}> {
+  const result: Array<{
+    agentId: string;
+    strategy: WakeStrategy;
+    intervalMin: number;
+    threshold: number;
+    hasPendingWake: boolean;
+  }> = [];
+  for (const [id, reg] of registrations) {
+    result.push({
+      agentId: id,
+      strategy: reg.strategy,
+      intervalMin: reg.intervalMs / 60_000,
+      threshold: reg.threshold,
+      hasPendingWake: pendingWakes.has(id),
+    });
+  }
+  return result;
+}
+
+/** Force a manual wake evaluation for a manager (for testing/UI) */
+export function forceWake(agentId: string): void {
+  const reg = registrations.get(agentId);
+  if (reg) {
+    evaluateAndEmit(reg);
+  }
+}
+
+/** Clear all registrations (for workspace teardown) */
+export function clearWakeScheduler(): void {
+  for (const reg of registrations.values()) {
+    if (reg.timerId) clearInterval(reg.timerId);
+  }
+  registrations = new Map();
+  pendingWakes = new Map();
+}
+
+// --- Internal ---
+
+function startTimer(reg: ManagerRegistration): void {
+  reg.timerId = setInterval(() => {
+    evaluateAndEmit(reg);
+  }, reg.intervalMs);
+}
+
+async function evaluateAndEmit(reg: ManagerRegistration): Promise<void> {
+  // Don't queue a new wake if one is already pending
+  if (pendingWakes.has(reg.agentId)) return;
+
+  // For persistent strategy, skip if session is actively running a query
+  if (reg.strategy === 'persistent') {
+    const session = getAgentSession(reg.sessionId);
+    if (session && session.status === 'running') return;
+  }
+
+  // Build project snapshots from health store
+  const healthItems = getAllProjectHealth();
+  const workItems = getAllWorkItems();
+  const projectSnapshots: WakeProjectSnapshot[] = healthItems.map(h => {
+    const workItem = workItems.find(w => w.id === h.projectId);
+    return {
+      projectId: h.projectId,
+      projectName: workItem?.name ?? String(h.projectId),
+      activityState: h.activityState,
+      idleMinutes: Math.floor(h.idleDurationMs / 60_000),
+      burnRatePerHour: h.burnRatePerHour,
+      contextPressurePercent: h.contextPressure !== null ? Math.round(h.contextPressure * 100) : null,
+      fileConflicts: h.fileConflictCount + h.externalConflictCount,
+      attentionScore: h.attentionScore,
+      attentionReason: h.attentionReason,
+    };
+  });
+
+  // Fetch task summary (best-effort)
+  let taskSummary: WakeTaskSummary | undefined;
+  try {
+    const tasks = await listTasks(reg.groupId);
+    taskSummary = {
+      total: tasks.length,
+      todo: tasks.filter(t => t.status === 'todo').length,
+      inProgress: tasks.filter(t => t.status === 'progress').length,
+      blocked: tasks.filter(t => t.status === 'blocked').length,
+      review: tasks.filter(t => t.status === 'review').length,
+      done: tasks.filter(t => t.status === 'done').length,
+    };
+  } catch {
+    // bttask may not be available — continue without task data
+  }
+
+  // Compute average burn rate for anomaly detection
+  const aggregates = getHealthAggregates();
+  const now = Date.now();
+  reg.burnRateSamples.push([now, aggregates.totalBurnRatePerHour]);
+  // Keep 1 hour of samples
+  const hourAgo = now - 3_600_000;
+  reg.burnRateSamples = reg.burnRateSamples.filter(([ts]) => ts > hourAgo);
+  const averageBurnRate = reg.burnRateSamples.length > 1
+    ? reg.burnRateSamples.reduce((sum, [, r]) => sum + r, 0) / reg.burnRateSamples.length
+    : undefined;
+
+  // Evaluate signals
+  const evaluation = evaluateWakeSignals({
+    projects: projectSnapshots,
+    taskSummary,
+    averageBurnRate,
+  });
+
+  // Check if we should actually wake based on strategy
+  if (!shouldWake(evaluation, reg.strategy, reg.threshold)) return;
+
+  // Build wake context
+  const context: WakeContext = {
+    evaluation,
+    projectSnapshots,
+    taskSummary,
+  };
+
+  // Determine mode
+  const mode: 'resume' | 'fresh' = reg.strategy === 'persistent' ? 'resume' : 'fresh';
+
+  pendingWakes.set(reg.agentId, {
+    agentId: reg.agentId,
+    strategy: reg.strategy,
+    context,
+    mode,
+  });
+
+  // Audit: log wake event
+  logAuditEvent(
+    reg.agentId,
+    'wake_event',
+    `Auto-wake triggered (strategy=${reg.strategy}, mode=${mode}, score=${evaluation.totalScore.toFixed(2)})`,
+  ).catch(() => {});
+}
diff --git a/v2/src/lib/stores/workspace.svelte.ts b/v2/src/lib/stores/workspace.svelte.ts
new file mode 100644
index 0000000..739b214
--- /dev/null
+++ b/v2/src/lib/stores/workspace.svelte.ts
@@ -0,0 +1,321 @@
+import { loadGroups, saveGroups, getCliGroup } from '../adapters/groups-bridge';
+import type { GroupsFile, GroupConfig, ProjectConfig, GroupAgentConfig } from '../types/groups';
+import { agentToProject } from '../types/groups';
+import { clearAllAgentSessions } from '../stores/agents.svelte';
+import { clearHealthTracking } from '../stores/health.svelte';
+import { clearAllConflicts } from '../stores/conflicts.svelte';
+import { clearWakeScheduler } from '../stores/wake-scheduler.svelte';
+import { waitForPendingPersistence } from '../agent-dispatcher';
+import { registerAgents } from '../adapters/btmsg-bridge';
+
+export type WorkspaceTab = 'sessions' | 'docs' | 'context' | 'settings' | 'comms';
+
+export interface TerminalTab {
+  id: string;
+  title: string;
+  type: 'shell' | 'ssh' | 'agent-terminal' | 'agent-preview';
+  /** SSH session ID if type === 'ssh' */
+  sshSessionId?: string;
+  /** Agent session ID if type === 'agent-preview' */
+  agentSessionId?: string;
+}
+
+// --- Core state ---
+
+let groupsConfig = $state<GroupsFile | null>(null);
+let activeGroupId = $state<string>('');
+let activeTab = $state<WorkspaceTab>('sessions');
+let activeProjectId = $state<string | null>(null);
+
+/** Terminal tabs per project (keyed by project ID) */
+let projectTerminals = $state<Record<string, TerminalTab[]>>({});
+
+// --- Focus flash event (keyboard quick-jump visual feedback) ---
+
+let focusFlashProjectId = $state<string | null>(null);
+
+export function getFocusFlashProjectId(): string | null {
+  return focusFlashProjectId;
+}
+
+export function triggerFocusFlash(projectId: string): void {
+  focusFlashProjectId = projectId;
+  // Auto-clear after animation duration
+  setTimeout(() => {
+    focusFlashProjectId = null;
+  }, 400);
+}
+
+// --- Project tab switching (keyboard-driven) ---
+
+type ProjectTabSwitchCallback = (projectId: string, tabIndex: number) => void;
+let projectTabSwitchCallbacks: ProjectTabSwitchCallback[] = [];
+
+export function onProjectTabSwitch(cb: ProjectTabSwitchCallback): () => void {
+  projectTabSwitchCallbacks.push(cb);
+  return () => {
+    projectTabSwitchCallbacks = projectTabSwitchCallbacks.filter(c => c !== cb);
+  };
+}
+
+export function emitProjectTabSwitch(projectId: string, tabIndex: number): void {
+  for (const cb of projectTabSwitchCallbacks) {
+    cb(projectId, tabIndex);
+  }
+}
+
+// --- Terminal toggle (keyboard-driven) ---
+
+type TerminalToggleCallback = (projectId: string) => void;
+let terminalToggleCallbacks: TerminalToggleCallback[] = [];
+
+export function onTerminalToggle(cb: TerminalToggleCallback): () => void {
+  terminalToggleCallbacks.push(cb);
+  return () => {
+    terminalToggleCallbacks = terminalToggleCallbacks.filter(c => c !== cb);
+  };
+}
+
+export function emitTerminalToggle(projectId: string): void {
+  for (const cb of terminalToggleCallbacks) {
+    cb(projectId);
+  }
+}
+
+// --- Getters ---
+
+export function getGroupsConfig(): GroupsFile | null {
+  return groupsConfig;
+}
+
+export function getActiveGroupId(): string {
+  return activeGroupId;
+}
+
+export function getActiveTab(): WorkspaceTab {
+  return activeTab;
+}
+
+export function getActiveProjectId(): string | null {
+  return activeProjectId;
+}
+
+export function getActiveGroup(): GroupConfig | undefined {
+  return groupsConfig?.groups.find(g => g.id === activeGroupId);
+}
+
+export function getEnabledProjects(): ProjectConfig[] {
+  const group = getActiveGroup();
+  if (!group) return [];
+  return group.projects.filter(p => p.enabled);
+}
+
+/** Get all work items: enabled projects + agents as virtual project entries */
+export function getAllWorkItems(): ProjectConfig[] {
+  const group = getActiveGroup();
+  if (!group) return [];
+  const projects = group.projects.filter(p => p.enabled);
+  const agentProjects = (group.agents ?? [])
+    .filter(a => a.enabled)
+    .map(a => {
+      // Use first project's parent dir as default CWD for agents
+      const groupCwd = projects[0]?.cwd?.replace(/\/[^/]+\/?$/, '/') ?? '/tmp';
+      return agentToProject(a, groupCwd);
+    });
+  return [...agentProjects, ...projects];
+}
+
+export function getAllGroups(): GroupConfig[] {
+  return groupsConfig?.groups ?? [];
+}
+
+// --- Setters ---
+
+export function setActiveTab(tab: WorkspaceTab): void {
+  activeTab = tab;
+}
+
+export function setActiveProject(projectId: string | null): void {
+  activeProjectId = projectId;
+}
+
+export async function switchGroup(groupId: string): Promise<void> {
+  if (groupId === activeGroupId) return;
+
+  // Wait for any in-flight persistence before clearing state
+  await waitForPendingPersistence();
+
+  // Teardown: clear terminal tabs, agent sessions, health tracking, and wake schedulers for the old group
+  projectTerminals = {};
+  clearAllAgentSessions();
+  clearHealthTracking();
+  clearAllConflicts();
+  clearWakeScheduler();
+
+  activeGroupId = groupId;
+  activeProjectId = null;
+
+  // Auto-focus first enabled project
+  const projects = getEnabledProjects();
+  if (projects.length > 0) {
+    activeProjectId = projects[0].id;
+  }
+
+  // Persist active group
+  if (groupsConfig) {
+    groupsConfig.activeGroupId = groupId;
+    saveGroups(groupsConfig).catch(e => console.warn('Failed to save groups:', e));
+  }
+}
+
+// --- Terminal tab management per project ---
+
+export function getTerminalTabs(projectId: string): TerminalTab[] {
+  return projectTerminals[projectId] ?? [];
+}
+
+export function addTerminalTab(projectId: string, tab: TerminalTab): void {
+  const tabs = projectTerminals[projectId] ?? [];
+  projectTerminals[projectId] = [...tabs, tab];
+}
+
+export function removeTerminalTab(projectId: string, tabId: string): void {
+  const tabs = projectTerminals[projectId] ?? [];
+  projectTerminals[projectId] = tabs.filter(t => t.id !== tabId);
+}
+
+// --- Persistence ---
+
+export async function loadWorkspace(initialGroupId?: string): Promise<void> {
+  try {
+    const config = await loadGroups();
+    groupsConfig = config;
+    projectTerminals = {};
+
+    // Register all agents from config into btmsg database
+    // (creates agent records, contact permissions, review channels)
+    registerAgents(config).catch(e => console.warn('Failed to register agents:', e));
+
+    // CLI --group flag takes priority, then explicit param, then persisted
+    let cliGroup: string | null = null;
+    if (!initialGroupId) {
+      cliGroup = await getCliGroup();
+    }
+    const targetId = initialGroupId || cliGroup || config.activeGroupId;
+    // Match by ID or by name (CLI users may pass name)
+    const targetGroup = config.groups.find(
+      g => g.id === targetId || g.name === targetId,
+    );
+
+    if (targetGroup) {
+      activeGroupId = targetGroup.id;
+    } else if (config.groups.length > 0) {
+      activeGroupId = config.groups[0].id;
+    }
+
+    // Auto-focus first enabled project
+    const projects = getEnabledProjects();
+    if (projects.length > 0) {
+      activeProjectId = projects[0].id;
+    }
+  } catch (e) {
+    console.warn('Failed to load groups config:', e);
+    groupsConfig = { version: 1, groups: [], activeGroupId: '' };
+  }
+}
+
+export async function saveWorkspace(): Promise<void> {
+  if (!groupsConfig) return;
+  await saveGroups(groupsConfig);
+  // Re-register agents after config changes (new agents, permission updates)
+  registerAgents(groupsConfig).catch(e => console.warn('Failed to register agents:', e));
+}
+
+// --- Group/project mutation ---
+
+export function addGroup(group: GroupConfig): void {
+  if (!groupsConfig) return;
+  groupsConfig = {
+    ...groupsConfig,
+    groups: [...groupsConfig.groups, group],
+  };
+  saveGroups(groupsConfig).catch(e => console.warn('Failed to save groups:', e));
+}
+
+export function removeGroup(groupId: string): void {
+  if (!groupsConfig) return;
+  groupsConfig = {
+    ...groupsConfig,
+    groups: groupsConfig.groups.filter(g => g.id !== groupId),
+  };
+  if (activeGroupId === groupId) {
+    activeGroupId = groupsConfig.groups[0]?.id ?? '';
+    activeProjectId = null;
+  }
+  saveGroups(groupsConfig).catch(e => console.warn('Failed to save groups:', e));
+}
+
+export function updateProject(groupId: string, projectId: string, updates: Partial<ProjectConfig>): void {
+  if (!groupsConfig) return;
+  groupsConfig = {
+    ...groupsConfig,
+    groups: groupsConfig.groups.map(g => {
+      if (g.id !== groupId) return g;
+      return {
+        ...g,
+        projects: g.projects.map(p => {
+          if (p.id !== projectId) return p;
+          return { ...p, ...updates };
+        }),
+      };
+    }),
+  };
+  saveGroups(groupsConfig).catch(e => console.warn('Failed to save groups:', e));
+}
+
+export function addProject(groupId: string, project: ProjectConfig): void {
+  if (!groupsConfig) return;
+  const group = groupsConfig.groups.find(g => g.id === groupId);
+  if (!group || group.projects.length >= 5) return;
+  groupsConfig = {
+    ...groupsConfig,
+    groups: groupsConfig.groups.map(g => {
+      if (g.id !== groupId) return g;
+      return { ...g, projects: [...g.projects, project] };
+    }),
+  };
+  saveGroups(groupsConfig).catch(e => console.warn('Failed to save groups:', e));
+}
+
+export function removeProject(groupId: string, projectId: string): void {
+  if (!groupsConfig) return;
+  groupsConfig = {
+    ...groupsConfig,
+    groups: groupsConfig.groups.map(g => {
+      if (g.id !== groupId) return g;
+      return { ...g, projects: g.projects.filter(p => p.id !== projectId) };
+    }),
+  };
+  if (activeProjectId === projectId) {
+    activeProjectId = null;
+  }
+  saveGroups(groupsConfig).catch(e => console.warn('Failed to save groups:', e));
+}
+
+export function updateAgent(groupId: string, agentId: string, updates: Partial<GroupAgentConfig>): void {
+  if (!groupsConfig) return;
+  groupsConfig = {
+    ...groupsConfig,
+    groups: groupsConfig.groups.map(g => {
+      if (g.id !== groupId) return g;
+      return {
+        ...g,
+        agents: (g.agents ?? []).map(a => {
+          if (a.id !== agentId) return a;
+          return { ...a, ...updates };
+        }),
+      };
+    }),
+  };
+  saveGroups(groupsConfig).catch(e => console.warn('Failed to save groups:', e));
+}
diff --git a/v2/src/lib/stores/workspace.test.ts b/v2/src/lib/stores/workspace.test.ts
new file mode 100644
index 0000000..4365d32
--- /dev/null
+++ b/v2/src/lib/stores/workspace.test.ts
@@ -0,0 +1,251 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+// Mock groups-bridge before importing the workspace store
+function mockGroupsData() {
+  return {
+    version: 1,
+    groups: [
+      {
+        id: 'g1',
+        name: 'Group One',
+        projects: [
+          { id: 'p1', name: 'Project 1', identifier: 'project-1', description: '', icon: '', cwd: '/tmp/p1', profile: 'default', enabled: true },
+          { id: 'p2', name: 'Project 2', identifier: 'project-2', description: '', icon: '', cwd: '/tmp/p2', profile: 'default', enabled: true },
+          { id: 'p3', name: 'Disabled', identifier: 'disabled', description: '', icon: '', cwd: '/tmp/p3', profile: 'default', enabled: false },
+        ],
+      },
+      {
+        id: 'g2',
+        name: 'Group Two',
+        projects: [
+          { id: 'p4', name: 'Project 4', identifier: 'project-4', description: '', icon: '', cwd: '/tmp/p4', profile: 'default', enabled: true },
+        ],
+      },
+    ],
+    activeGroupId: 'g1',
+  };
+}
+
+vi.mock('../stores/agents.svelte', () => ({
+  clearAllAgentSessions: vi.fn(),
+}));
+
+vi.mock('../stores/conflicts.svelte', () => ({
+  clearAllConflicts: vi.fn(),
+}));
+
+vi.mock('../agent-dispatcher', () => ({
+  waitForPendingPersistence: vi.fn().mockResolvedValue(undefined),
+}));
+
+vi.mock('../adapters/groups-bridge', () => ({
+  loadGroups: vi.fn().mockImplementation(() => Promise.resolve(mockGroupsData())),
+  saveGroups: vi.fn().mockResolvedValue(undefined),
+  getCliGroup: vi.fn().mockResolvedValue(null),
+}));
+
+import {
+  getGroupsConfig,
+  getActiveGroupId,
+  getActiveTab,
+  getActiveProjectId,
+  getActiveGroup,
+  getEnabledProjects,
+  getAllGroups,
+  setActiveTab,
+  setActiveProject,
+  switchGroup,
+  getTerminalTabs,
+  addTerminalTab,
+  removeTerminalTab,
+  loadWorkspace,
+  addGroup,
+  removeGroup,
+  updateProject,
+  addProject,
+  removeProject,
+} from './workspace.svelte';
+
+import { saveGroups, getCliGroup } from '../adapters/groups-bridge';
+
+beforeEach(async () => {
+  vi.clearAllMocks();
+  // Reset state by reloading
+  await loadWorkspace();
+});
+
+describe('workspace store', () => {
+  describe('loadWorkspace', () => {
+    it('loads groups config and sets active group', async () => {
+      expect(getGroupsConfig()).not.toBeNull();
+      expect(getActiveGroupId()).toBe('g1');
+    });
+
+    it('auto-focuses first enabled project', async () => {
+      expect(getActiveProjectId()).toBe('p1');
+    });
+
+    it('accepts initialGroupId override', async () => {
+      await loadWorkspace('g2');
+      expect(getActiveGroupId()).toBe('g2');
+      expect(getActiveProjectId()).toBe('p4');
+    });
+
+    it('falls back to first group if target not found', async () => {
+      await loadWorkspace('nonexistent');
+      expect(getActiveGroupId()).toBe('g1');
+    });
+
+    it('uses CLI --group flag when no initialGroupId given', async () => {
+      vi.mocked(getCliGroup).mockResolvedValueOnce('Group Two');
+      await loadWorkspace();
+      expect(getActiveGroupId()).toBe('g2');
+    });
+  });
+
+  describe('getters', () => {
+    it('getActiveGroup returns the active group config', () => {
+      const group = getActiveGroup();
+      expect(group).toBeDefined();
+      expect(group!.id).toBe('g1');
+      expect(group!.name).toBe('Group One');
+    });
+
+    it('getEnabledProjects filters disabled projects', () => {
+      const projects = getEnabledProjects();
+      expect(projects).toHaveLength(2);
+      expect(projects.map(p => p.id)).toEqual(['p1', 'p2']);
+    });
+
+    it('getAllGroups returns all groups', () => {
+      const groups = getAllGroups();
+      expect(groups).toHaveLength(2);
+    });
+  });
+
+  describe('setters', () => {
+    it('setActiveTab changes the active tab', () => {
+      setActiveTab('docs');
+      expect(getActiveTab()).toBe('docs');
+      setActiveTab('sessions');
+      expect(getActiveTab()).toBe('sessions');
+    });
+
+    it('setActiveProject changes the active project', () => {
+      setActiveProject('p2');
+      expect(getActiveProjectId()).toBe('p2');
+    });
+  });
+
+  describe('switchGroup', () => {
+    it('switches to a different group and auto-focuses first project', async () => {
+      await switchGroup('g2');
+      expect(getActiveGroupId()).toBe('g2');
+      expect(getActiveProjectId()).toBe('p4');
+    });
+
+    it('clears terminal tabs on group switch', async () => {
+      addTerminalTab('p1', { id: 't1', title: 'Shell', type: 'shell' });
+      expect(getTerminalTabs('p1')).toHaveLength(1);
+
+      await switchGroup('g2');
+      expect(getTerminalTabs('p1')).toHaveLength(0);
+    });
+
+    it('no-ops when switching to current group', async () => {
+      const projectBefore = getActiveProjectId();
+      vi.mocked(saveGroups).mockClear();
+      await switchGroup('g1');
+      // State should remain unchanged
+      expect(getActiveGroupId()).toBe('g1');
+      expect(getActiveProjectId()).toBe(projectBefore);
+      expect(saveGroups).not.toHaveBeenCalled();
+    });
+
+    it('persists active group', async () => {
+      await switchGroup('g2');
+      expect(saveGroups).toHaveBeenCalled();
+    });
+  });
+
+  describe('terminal tabs', () => {
+    it('adds and retrieves terminal tabs per project', () => {
+      addTerminalTab('p1', { id: 't1', title: 'Shell 1', type: 'shell' });
+      addTerminalTab('p1', { id: 't2', title: 'Agent', type: 'agent-terminal' });
+      addTerminalTab('p2', { id: 't3', title: 'SSH', type: 'ssh', sshSessionId: 'ssh1' });
+
+      expect(getTerminalTabs('p1')).toHaveLength(2);
+      expect(getTerminalTabs('p2')).toHaveLength(1);
+      expect(getTerminalTabs('p2')[0].sshSessionId).toBe('ssh1');
+    });
+
+    it('removes terminal tabs by id', () => {
+      addTerminalTab('p1', { id: 't1', title: 'Shell', type: 'shell' });
+      addTerminalTab('p1', { id: 't2', title: 'Agent', type: 'agent-terminal' });
+
+      removeTerminalTab('p1', 't1');
+      expect(getTerminalTabs('p1')).toHaveLength(1);
+      expect(getTerminalTabs('p1')[0].id).toBe('t2');
+    });
+
+    it('returns empty array for unknown project', () => {
+      expect(getTerminalTabs('unknown')).toEqual([]);
+    });
+  });
+
+  describe('group mutation', () => {
+    it('addGroup adds a new group', () => {
+      addGroup({ id: 'g3', name: 'New Group', projects: [] });
+      expect(getAllGroups()).toHaveLength(3);
+      expect(saveGroups).toHaveBeenCalled();
+    });
+
+    it('removeGroup removes the group and resets active if needed', () => {
+      removeGroup('g1');
+      expect(getAllGroups()).toHaveLength(1);
+      expect(getActiveGroupId()).toBe('g2');
+    });
+
+    it('removeGroup with non-active group keeps active unchanged', () => {
+      removeGroup('g2');
+      expect(getAllGroups()).toHaveLength(1);
+      expect(getActiveGroupId()).toBe('g1');
+    });
+  });
+
+  describe('project mutation', () => {
+    it('updateProject updates project fields', () => {
+      updateProject('g1', 'p1', { name: 'Renamed' });
+      const group = getActiveGroup()!;
+      expect(group.projects.find(p => p.id === 'p1')!.name).toBe('Renamed');
+      expect(saveGroups).toHaveBeenCalled();
+    });
+
+    it('addProject adds a project to a group', () => {
+      addProject('g1', {
+        id: 'p5', name: 'New', identifier: 'new', description: '',
+        icon: '', cwd: '/tmp', profile: 'default', enabled: true,
+      });
+      const group = getActiveGroup()!;
+      expect(group.projects).toHaveLength(4);
+    });
+
+    it('addProject respects 5-project limit', () => {
+      // g1 already has 3 projects, add 2 more to reach 5
+      addProject('g1', { id: 'x1', name: 'X1', identifier: 'x1', description: '', icon: '', cwd: '/tmp', profile: 'default', enabled: true });
+      addProject('g1', { id: 'x2', name: 'X2', identifier: 'x2', description: '', icon: '', cwd: '/tmp', profile: 'default', enabled: true });
+      // This 6th should be rejected
+      addProject('g1', { id: 'x3', name: 'X3', identifier: 'x3', description: '', icon: '', cwd: '/tmp', profile: 'default', enabled: true });
+      const group = getActiveGroup()!;
+      expect(group.projects).toHaveLength(5);
+    });
+
+    it('removeProject removes and clears activeProjectId if needed', () => {
+      setActiveProject('p1');
+      removeProject('g1', 'p1');
+      expect(getActiveProjectId()).toBeNull();
+      const group = getActiveGroup()!;
+      expect(group.projects.find(p => p.id === 'p1')).toBeUndefined();
+    });
+  });
+});
diff --git a/v2/src/lib/styles/catppuccin.css b/v2/src/lib/styles/catppuccin.css
new file mode 100644
index 0000000..73a3ccd
--- /dev/null
+++ b/v2/src/lib/styles/catppuccin.css
@@ -0,0 +1,61 @@
+/* Catppuccin Mocha — https://catppuccin.com/palette */
+:root {
+  --ctp-rosewater: #f5e0dc;
+  --ctp-flamingo: #f2cdcd;
+  --ctp-pink: #f5c2e7;
+  --ctp-mauve: #cba6f7;
+  --ctp-red: #f38ba8;
+  --ctp-maroon: #eba0ac;
+  --ctp-peach: #fab387;
+  --ctp-yellow: #f9e2af;
+  --ctp-green: #a6e3a1;
+  --ctp-teal: #94e2d5;
+  --ctp-sky: #89dceb;
+  --ctp-sapphire: #74c7ec;
+  --ctp-blue: #89b4fa;
+  --ctp-lavender: #b4befe;
+  --ctp-text: #cdd6f4;
+  --ctp-subtext1: #bac2de;
+  --ctp-subtext0: #a6adc8;
+  --ctp-overlay2: #9399b2;
+  --ctp-overlay1: #7f849c;
+  --ctp-overlay0: #6c7086;
+  --ctp-surface2: #585b70;
+  --ctp-surface1: #45475a;
+  --ctp-surface0: #313244;
+  --ctp-base: #1e1e2e;
+  --ctp-mantle: #181825;
+  --ctp-crust: #11111b;
+
+  /* Semantic aliases */
+  --bg-primary: var(--ctp-base);
+  --bg-secondary: var(--ctp-mantle);
+  --bg-tertiary: var(--ctp-crust);
+  --bg-surface: var(--ctp-surface0);
+  --bg-surface-hover: var(--ctp-surface1);
+  --text-primary: var(--ctp-text);
+  --text-secondary: var(--ctp-subtext1);
+  --text-muted: var(--ctp-overlay1);
+  --border: var(--ctp-surface1);
+  --accent: var(--ctp-blue);
+  --accent-hover: var(--ctp-sapphire);
+  --success: var(--ctp-green);
+  --warning: var(--ctp-yellow);
+  --error: var(--ctp-red);
+
+  /* Typography */
+  --ui-font-family: 'JetBrains Mono', 'Fira Code', 'Cascadia Code', monospace;
+  --ui-font-size: 13px;
+  --term-font-family: 'JetBrains Mono', 'Fira Code', 'Cascadia Code', monospace;
+  --term-font-size: 13px;
+
+  /* Layout */
+  --sidebar-width: 260px;
+  --right-panel-width: 380px;
+  --pane-header-height: 32px;
+  --pane-gap: 2px;
+  --border-radius: 4px;
+
+  /* Pane content padding — shared between AgentPane and MarkdownPane */
+  --bterminal-pane-padding-inline: clamp(0.75rem, 3.5cqi, 2rem);
+}
diff --git a/v2/src/lib/styles/themes.ts b/v2/src/lib/styles/themes.ts
new file mode 100644
index 0000000..cdeaa17
--- /dev/null
+++ b/v2/src/lib/styles/themes.ts
@@ -0,0 +1,383 @@
+// Theme system — Catppuccin flavors + popular editor themes
+// All themes map to the same --ctp-* CSS custom property slots.
+
+/** All available theme identifiers */
+export type ThemeId =
+  | 'mocha' | 'macchiato' | 'frappe' | 'latte'
+  | 'vscode-dark' | 'atom-one-dark' | 'monokai' | 'dracula'
+  | 'nord' | 'solarized-dark' | 'github-dark'
+  | 'tokyo-night' | 'gruvbox-dark' | 'ayu-dark' | 'poimandres'
+  | 'vesper' | 'midnight';
+
+/** Keep for backwards compat — subset of ThemeId */
+export type CatppuccinFlavor = 'latte' | 'frappe' | 'macchiato' | 'mocha';
+
+export interface ThemePalette {
+  rosewater: string;
+  flamingo: string;
+  pink: string;
+  mauve: string;
+  red: string;
+  maroon: string;
+  peach: string;
+  yellow: string;
+  green: string;
+  teal: string;
+  sky: string;
+  sapphire: string;
+  blue: string;
+  lavender: string;
+  text: string;
+  subtext1: string;
+  subtext0: string;
+  overlay2: string;
+  overlay1: string;
+  overlay0: string;
+  surface2: string;
+  surface1: string;
+  surface0: string;
+  base: string;
+  mantle: string;
+  crust: string;
+}
+
+/** Keep old name as alias */
+export type CatppuccinPalette = ThemePalette;
+
+export interface XtermTheme {
+  background: string;
+  foreground: string;
+  cursor: string;
+  cursorAccent: string;
+  selectionBackground: string;
+  selectionForeground: string;
+  black: string;
+  red: string;
+  green: string;
+  yellow: string;
+  blue: string;
+  magenta: string;
+  cyan: string;
+  white: string;
+  brightBlack: string;
+  brightRed: string;
+  brightGreen: string;
+  brightYellow: string;
+  brightBlue: string;
+  brightMagenta: string;
+  brightCyan: string;
+  brightWhite: string;
+}
+
+export interface ThemeMeta {
+  id: ThemeId;
+  label: string;
+  group: string; // For grouping in <optgroup>
+  isDark: boolean;
+}
+
+export const THEME_LIST: ThemeMeta[] = [
+  { id: 'mocha',          label: 'Catppuccin Mocha',    group: 'Catppuccin', isDark: true },
+  { id: 'macchiato',      label: 'Catppuccin Macchiato',group: 'Catppuccin', isDark: true },
+  { id: 'frappe',         label: 'Catppuccin Frappé',   group: 'Catppuccin', isDark: true },
+  { id: 'latte',          label: 'Catppuccin Latte',    group: 'Catppuccin', isDark: false },
+  { id: 'vscode-dark',    label: 'VSCode Dark+',        group: 'Editor',     isDark: true },
+  { id: 'atom-one-dark',  label: 'Atom One Dark',       group: 'Editor',     isDark: true },
+  { id: 'monokai',        label: 'Monokai',             group: 'Editor',     isDark: true },
+  { id: 'dracula',        label: 'Dracula',             group: 'Editor',     isDark: true },
+  { id: 'nord',           label: 'Nord',                group: 'Editor',     isDark: true },
+  { id: 'solarized-dark', label: 'Solarized Dark',      group: 'Editor',     isDark: true },
+  { id: 'github-dark',    label: 'GitHub Dark',         group: 'Editor',     isDark: true },
+  { id: 'tokyo-night',    label: 'Tokyo Night',         group: 'Deep Dark',  isDark: true },
+  { id: 'gruvbox-dark',   label: 'Gruvbox Dark',        group: 'Deep Dark',  isDark: true },
+  { id: 'ayu-dark',       label: 'Ayu Dark',            group: 'Deep Dark',  isDark: true },
+  { id: 'poimandres',     label: 'Poimandres',          group: 'Deep Dark',  isDark: true },
+  { id: 'vesper',         label: 'Vesper',              group: 'Deep Dark',  isDark: true },
+  { id: 'midnight',       label: 'Midnight',            group: 'Deep Dark',  isDark: true },
+];
+
+const palettes: Record<ThemeId, ThemePalette> = {
+  // --- Catppuccin ---
+  latte: {
+    rosewater: '#dc8a78', flamingo: '#dd7878', pink: '#ea76cb', mauve: '#8839ef',
+    red: '#d20f39', maroon: '#e64553', peach: '#fe640b', yellow: '#df8e1d',
+    green: '#40a02b', teal: '#179299', sky: '#04a5e5', sapphire: '#209fb5',
+    blue: '#1e66f5', lavender: '#7287fd',
+    text: '#4c4f69', subtext1: '#5c5f77', subtext0: '#6c6f85',
+    overlay2: '#7c7f93', overlay1: '#8c8fa1', overlay0: '#9ca0b0',
+    surface2: '#acb0be', surface1: '#bcc0cc', surface0: '#ccd0da',
+    base: '#eff1f5', mantle: '#e6e9ef', crust: '#dce0e8',
+  },
+  frappe: {
+    rosewater: '#f2d5cf', flamingo: '#eebebe', pink: '#f4b8e4', mauve: '#ca9ee6',
+    red: '#e78284', maroon: '#ea999c', peach: '#ef9f76', yellow: '#e5c890',
+    green: '#a6d189', teal: '#81c8be', sky: '#99d1db', sapphire: '#85c1dc',
+    blue: '#8caaee', lavender: '#babbf1',
+    text: '#c6d0f5', subtext1: '#b5bfe2', subtext0: '#a5adce',
+    overlay2: '#949cbb', overlay1: '#838ba7', overlay0: '#737994',
+    surface2: '#626880', surface1: '#51576d', surface0: '#414559',
+    base: '#303446', mantle: '#292c3c', crust: '#232634',
+  },
+  macchiato: {
+    rosewater: '#f4dbd6', flamingo: '#f0c6c6', pink: '#f5bde6', mauve: '#c6a0f6',
+    red: '#ed8796', maroon: '#ee99a0', peach: '#f5a97f', yellow: '#eed49f',
+    green: '#a6da95', teal: '#8bd5ca', sky: '#91d7e3', sapphire: '#7dc4e4',
+    blue: '#8aadf4', lavender: '#b7bdf8',
+    text: '#cad3f5', subtext1: '#b8c0e0', subtext0: '#a5adcb',
+    overlay2: '#939ab7', overlay1: '#8087a2', overlay0: '#6e738d',
+    surface2: '#5b6078', surface1: '#494d64', surface0: '#363a4f',
+    base: '#24273a', mantle: '#1e2030', crust: '#181926',
+  },
+  mocha: {
+    rosewater: '#f5e0dc', flamingo: '#f2cdcd', pink: '#f5c2e7', mauve: '#cba6f7',
+    red: '#f38ba8', maroon: '#eba0ac', peach: '#fab387', yellow: '#f9e2af',
+    green: '#a6e3a1', teal: '#94e2d5', sky: '#89dceb', sapphire: '#74c7ec',
+    blue: '#89b4fa', lavender: '#b4befe',
+    text: '#cdd6f4', subtext1: '#bac2de', subtext0: '#a6adc8',
+    overlay2: '#9399b2', overlay1: '#7f849c', overlay0: '#6c7086',
+    surface2: '#585b70', surface1: '#45475a', surface0: '#313244',
+    base: '#1e1e2e', mantle: '#181825', crust: '#11111b',
+  },
+
+  // --- VSCode Dark+ ---
+  'vscode-dark': {
+    rosewater: '#d4a0a0', flamingo: '#cf8686', pink: '#c586c0', mauve: '#c586c0',
+    red: '#f44747', maroon: '#d16969', peach: '#ce9178', yellow: '#dcdcaa',
+    green: '#6a9955', teal: '#4ec9b0', sky: '#9cdcfe', sapphire: '#4fc1ff',
+    blue: '#569cd6', lavender: '#b4b4f7',
+    text: '#d4d4d4', subtext1: '#cccccc', subtext0: '#b0b0b0',
+    overlay2: '#858585', overlay1: '#6e6e6e', overlay0: '#5a5a5a',
+    surface2: '#3e3e42', surface1: '#333338', surface0: '#2d2d30',
+    base: '#1e1e1e', mantle: '#181818', crust: '#111111',
+  },
+
+  // --- Atom One Dark ---
+  'atom-one-dark': {
+    rosewater: '#e5c07b', flamingo: '#e06c75', pink: '#c678dd', mauve: '#c678dd',
+    red: '#e06c75', maroon: '#be5046', peach: '#d19a66', yellow: '#e5c07b',
+    green: '#98c379', teal: '#56b6c2', sky: '#56b6c2', sapphire: '#61afef',
+    blue: '#61afef', lavender: '#c8ccd4',
+    text: '#abb2bf', subtext1: '#9da5b4', subtext0: '#8b92a0',
+    overlay2: '#7f848e', overlay1: '#636d83', overlay0: '#545862',
+    surface2: '#474b56', surface1: '#3b3f4c', surface0: '#333842',
+    base: '#282c34', mantle: '#21252b', crust: '#181a1f',
+  },
+
+  // --- Monokai ---
+  monokai: {
+    rosewater: '#f8f8f2', flamingo: '#f92672', pink: '#f92672', mauve: '#ae81ff',
+    red: '#f92672', maroon: '#f92672', peach: '#fd971f', yellow: '#e6db74',
+    green: '#a6e22e', teal: '#66d9ef', sky: '#66d9ef', sapphire: '#66d9ef',
+    blue: '#66d9ef', lavender: '#ae81ff',
+    text: '#f8f8f2', subtext1: '#e8e8e2', subtext0: '#cfcfc2',
+    overlay2: '#a8a8a2', overlay1: '#90908a', overlay0: '#75715e',
+    surface2: '#595950', surface1: '#49483e', surface0: '#3e3d32',
+    base: '#272822', mantle: '#1e1f1c', crust: '#141411',
+  },
+
+  // --- Dracula ---
+  dracula: {
+    rosewater: '#f1c4e0', flamingo: '#ff79c6', pink: '#ff79c6', mauve: '#bd93f9',
+    red: '#ff5555', maroon: '#ff6e6e', peach: '#ffb86c', yellow: '#f1fa8c',
+    green: '#50fa7b', teal: '#8be9fd', sky: '#8be9fd', sapphire: '#8be9fd',
+    blue: '#6272a4', lavender: '#bd93f9',
+    text: '#f8f8f2', subtext1: '#e8e8e2', subtext0: '#c0c0ba',
+    overlay2: '#a0a0a0', overlay1: '#7f7f7f', overlay0: '#6272a4',
+    surface2: '#555969', surface1: '#44475a', surface0: '#383a4a',
+    base: '#282a36', mantle: '#21222c', crust: '#191a21',
+  },
+
+  // --- Nord ---
+  nord: {
+    rosewater: '#d08770', flamingo: '#bf616a', pink: '#b48ead', mauve: '#b48ead',
+    red: '#bf616a', maroon: '#bf616a', peach: '#d08770', yellow: '#ebcb8b',
+    green: '#a3be8c', teal: '#8fbcbb', sky: '#88c0d0', sapphire: '#81a1c1',
+    blue: '#5e81ac', lavender: '#b48ead',
+    text: '#eceff4', subtext1: '#e5e9f0', subtext0: '#d8dee9',
+    overlay2: '#a5adba', overlay1: '#8891a0', overlay0: '#6c7588',
+    surface2: '#4c566a', surface1: '#434c5e', surface0: '#3b4252',
+    base: '#2e3440', mantle: '#272c36', crust: '#20242c',
+  },
+
+  // --- Solarized Dark ---
+  'solarized-dark': {
+    rosewater: '#d33682', flamingo: '#dc322f', pink: '#d33682', mauve: '#6c71c4',
+    red: '#dc322f', maroon: '#cb4b16', peach: '#cb4b16', yellow: '#b58900',
+    green: '#859900', teal: '#2aa198', sky: '#2aa198', sapphire: '#268bd2',
+    blue: '#268bd2', lavender: '#6c71c4',
+    text: '#839496', subtext1: '#93a1a1', subtext0: '#778a8b',
+    overlay2: '#657b83', overlay1: '#586e75', overlay0: '#4a6068',
+    surface2: '#1c4753', surface1: '#143845', surface0: '#073642',
+    base: '#002b36', mantle: '#00222b', crust: '#001a21',
+  },
+
+  // --- GitHub Dark ---
+  'github-dark': {
+    rosewater: '#ffa198', flamingo: '#ff7b72', pink: '#f778ba', mauve: '#d2a8ff',
+    red: '#ff7b72', maroon: '#ffa198', peach: '#ffa657', yellow: '#e3b341',
+    green: '#7ee787', teal: '#56d4dd', sky: '#79c0ff', sapphire: '#79c0ff',
+    blue: '#58a6ff', lavender: '#d2a8ff',
+    text: '#c9d1d9', subtext1: '#b1bac4', subtext0: '#8b949e',
+    overlay2: '#6e7681', overlay1: '#565c64', overlay0: '#484f58',
+    surface2: '#373e47', surface1: '#30363d', surface0: '#21262d',
+    base: '#0d1117', mantle: '#090c10', crust: '#050608',
+  },
+
+  // --- Tokyo Night ---
+  'tokyo-night': {
+    rosewater: '#f7768e', flamingo: '#ff9e64', pink: '#bb9af7', mauve: '#bb9af7',
+    red: '#f7768e', maroon: '#db4b4b', peach: '#ff9e64', yellow: '#e0af68',
+    green: '#9ece6a', teal: '#73daca', sky: '#7dcfff', sapphire: '#7aa2f7',
+    blue: '#7aa2f7', lavender: '#bb9af7',
+    text: '#c0caf5', subtext1: '#a9b1d6', subtext0: '#9aa5ce',
+    overlay2: '#787c99', overlay1: '#565f89', overlay0: '#414868',
+    surface2: '#3b4261', surface1: '#292e42', surface0: '#232433',
+    base: '#1a1b26', mantle: '#16161e', crust: '#101014',
+  },
+
+  // --- Gruvbox Dark ---
+  'gruvbox-dark': {
+    rosewater: '#d65d0e', flamingo: '#cc241d', pink: '#d3869b', mauve: '#b16286',
+    red: '#fb4934', maroon: '#cc241d', peach: '#fe8019', yellow: '#fabd2f',
+    green: '#b8bb26', teal: '#8ec07c', sky: '#83a598', sapphire: '#83a598',
+    blue: '#458588', lavender: '#d3869b',
+    text: '#ebdbb2', subtext1: '#d5c4a1', subtext0: '#bdae93',
+    overlay2: '#a89984', overlay1: '#928374', overlay0: '#7c6f64',
+    surface2: '#504945', surface1: '#3c3836', surface0: '#32302f',
+    base: '#1d2021', mantle: '#191b1c', crust: '#141617',
+  },
+
+  // --- Ayu Dark ---
+  'ayu-dark': {
+    rosewater: '#f07178', flamingo: '#f07178', pink: '#d2a6ff', mauve: '#d2a6ff',
+    red: '#f07178', maroon: '#f07178', peach: '#ff8f40', yellow: '#ffb454',
+    green: '#aad94c', teal: '#95e6cb', sky: '#73b8ff', sapphire: '#59c2ff',
+    blue: '#59c2ff', lavender: '#d2a6ff',
+    text: '#bfbdb6', subtext1: '#acaaa4', subtext0: '#9b9892',
+    overlay2: '#73726e', overlay1: '#5c5b57', overlay0: '#464542',
+    surface2: '#383838', surface1: '#2c2c2c', surface0: '#242424',
+    base: '#0b0e14', mantle: '#080a0f', crust: '#05070a',
+  },
+
+  // --- Poimandres ---
+  'poimandres': {
+    rosewater: '#d0679d', flamingo: '#d0679d', pink: '#fcc5e9', mauve: '#a6accd',
+    red: '#d0679d', maroon: '#d0679d', peach: '#e4f0fb', yellow: '#fffac2',
+    green: '#5de4c7', teal: '#5de4c7', sky: '#89ddff', sapphire: '#add7ff',
+    blue: '#91b4d5', lavender: '#a6accd',
+    text: '#e4f0fb', subtext1: '#d0d6e0', subtext0: '#a6accd',
+    overlay2: '#767c9d', overlay1: '#506477', overlay0: '#3e4f5e',
+    surface2: '#303340', surface1: '#252b37', surface0: '#1e2433',
+    base: '#1b1e28', mantle: '#171922', crust: '#12141c',
+  },
+
+  // --- Vesper ---
+  'vesper': {
+    rosewater: '#de6e6e', flamingo: '#de6e6e', pink: '#c79bf0', mauve: '#c79bf0',
+    red: '#de6e6e', maroon: '#de6e6e', peach: '#ffcfa8', yellow: '#ffc799',
+    green: '#7cb37c', teal: '#6bccb0', sky: '#8abeb7', sapphire: '#6eb4bf',
+    blue: '#6eb4bf', lavender: '#c79bf0',
+    text: '#b8b5ad', subtext1: '#a09d95', subtext0: '#878480',
+    overlay2: '#6e6b66', overlay1: '#55524d', overlay0: '#3d3a36',
+    surface2: '#302e2a', surface1: '#252320', surface0: '#1c1a17',
+    base: '#101010', mantle: '#0a0a0a', crust: '#050505',
+  },
+
+  // --- Midnight (pure black OLED) ---
+  midnight: {
+    rosewater: '#e8a0bf', flamingo: '#ea6f91', pink: '#e8a0bf', mauve: '#c4a7e7',
+    red: '#eb6f92', maroon: '#ea6f91', peach: '#f6c177', yellow: '#ebbcba',
+    green: '#9ccfd8', teal: '#9ccfd8', sky: '#a4d4e4', sapphire: '#8bbee8',
+    blue: '#7ba4cc', lavender: '#c4a7e7',
+    text: '#c4c4c4', subtext1: '#a8a8a8', subtext0: '#8c8c8c',
+    overlay2: '#6e6e6e', overlay1: '#525252', overlay0: '#383838',
+    surface2: '#262626', surface1: '#1a1a1a', surface0: '#111111',
+    base: '#000000', mantle: '#000000', crust: '#000000',
+  },
+};
+
+export function getPalette(theme: ThemeId): ThemePalette {
+  return palettes[theme];
+}
+
+/** Build xterm.js ITheme from a palette */
+export function buildXtermTheme(theme: ThemeId): XtermTheme {
+  const p = palettes[theme];
+  return {
+    background: p.base,
+    foreground: p.text,
+    cursor: p.rosewater,
+    cursorAccent: p.base,
+    selectionBackground: p.surface1,
+    selectionForeground: p.text,
+    black: p.surface1,
+    red: p.red,
+    green: p.green,
+    yellow: p.yellow,
+    blue: p.blue,
+    magenta: p.pink,
+    cyan: p.teal,
+    white: p.subtext1,
+    brightBlack: p.surface2,
+    brightRed: p.red,
+    brightGreen: p.green,
+    brightYellow: p.yellow,
+    brightBlue: p.blue,
+    brightMagenta: p.pink,
+    brightCyan: p.teal,
+    brightWhite: p.subtext0,
+  };
+}
+
+/** CSS custom property names mapped to palette keys */
+const CSS_VAR_MAP: [string, keyof ThemePalette][] = [
+  ['--ctp-rosewater', 'rosewater'],
+  ['--ctp-flamingo', 'flamingo'],
+  ['--ctp-pink', 'pink'],
+  ['--ctp-mauve', 'mauve'],
+  ['--ctp-red', 'red'],
+  ['--ctp-maroon', 'maroon'],
+  ['--ctp-peach', 'peach'],
+  ['--ctp-yellow', 'yellow'],
+  ['--ctp-green', 'green'],
+  ['--ctp-teal', 'teal'],
+  ['--ctp-sky', 'sky'],
+  ['--ctp-sapphire', 'sapphire'],
+  ['--ctp-blue', 'blue'],
+  ['--ctp-lavender', 'lavender'],
+  ['--ctp-text', 'text'],
+  ['--ctp-subtext1', 'subtext1'],
+  ['--ctp-subtext0', 'subtext0'],
+  ['--ctp-overlay2', 'overlay2'],
+  ['--ctp-overlay1', 'overlay1'],
+  ['--ctp-overlay0', 'overlay0'],
+  ['--ctp-surface2', 'surface2'],
+  ['--ctp-surface1', 'surface1'],
+  ['--ctp-surface0', 'surface0'],
+  ['--ctp-base', 'base'],
+  ['--ctp-mantle', 'mantle'],
+  ['--ctp-crust', 'crust'],
+];
+
+/** Apply a theme's CSS custom properties to document root */
+export function applyCssVariables(theme: ThemeId): void {
+  const p = palettes[theme];
+  const style = document.documentElement.style;
+  for (const [varName, key] of CSS_VAR_MAP) {
+    style.setProperty(varName, p[key]);
+  }
+}
+
+/** @deprecated Use THEME_LIST instead */
+export const FLAVOR_LABELS: Record<CatppuccinFlavor, string> = {
+  latte: 'Latte (Light)',
+  frappe: 'Frappe',
+  macchiato: 'Macchiato',
+  mocha: 'Mocha (Default)',
+};
+
+/** @deprecated Use THEME_LIST instead */
+export const ALL_FLAVORS: CatppuccinFlavor[] = ['latte', 'frappe', 'macchiato', 'mocha'];
+
+/** All valid theme IDs for validation */
+export const ALL_THEME_IDS: ThemeId[] = THEME_LIST.map(t => t.id);
diff --git a/v2/src/lib/types/anchors.ts b/v2/src/lib/types/anchors.ts
new file mode 100644
index 0000000..cc61270
--- /dev/null
+++ b/v2/src/lib/types/anchors.ts
@@ -0,0 +1,72 @@
+// Session Anchor types — preserves important conversation turns through compaction chains
+// Anchored turns are re-injected into system prompt on subsequent queries
+
+/** Anchor classification */
+export type AnchorType = 'auto' | 'pinned' | 'promoted';
+
+/** A single anchored turn, stored per-project */
+export interface SessionAnchor {
+  id: string;
+  projectId: string;
+  messageId: string;
+  anchorType: AnchorType;
+  /** Serialized turn text for re-injection (observation-masked) */
+  content: string;
+  /** Estimated token count (~chars/4) */
+  estimatedTokens: number;
+  /** Turn index in original session */
+  turnIndex: number;
+  createdAt: number;
+}
+
+/** Settings for anchor behavior, stored per-project */
+export interface AnchorSettings {
+  /** Number of turns to auto-anchor on first compaction (default: 3) */
+  anchorTurns: number;
+  /** Hard cap on re-injectable anchor tokens (default: 6144) */
+  anchorTokenBudget: number;
+}
+
+export const DEFAULT_ANCHOR_SETTINGS: AnchorSettings = {
+  anchorTurns: 3,
+  anchorTokenBudget: 6144,
+};
+
+/** Maximum token budget for re-injected anchors */
+export const MAX_ANCHOR_TOKEN_BUDGET = 20_000;
+/** Minimum token budget */
+export const MIN_ANCHOR_TOKEN_BUDGET = 2_000;
+
+/** Budget scale presets — maps to provider context window sizes */
+export type AnchorBudgetScale = 'small' | 'medium' | 'large' | 'full';
+
+/** Token budget for each scale preset */
+export const ANCHOR_BUDGET_SCALE_MAP: Record<AnchorBudgetScale, number> = {
+  small: 2_000,
+  medium: 6_144,
+  large: 12_000,
+  full: 20_000,
+};
+
+/** Human-readable labels for budget scale presets */
+export const ANCHOR_BUDGET_SCALE_LABELS: Record<AnchorBudgetScale, string> = {
+  small: 'Small (2K)',
+  medium: 'Medium (6K)',
+  large: 'Large (12K)',
+  full: 'Full (20K)',
+};
+
+/** Ordered list of scales for slider indexing */
+export const ANCHOR_BUDGET_SCALES: AnchorBudgetScale[] = ['small', 'medium', 'large', 'full'];
+
+/** Rust-side record shape (matches SessionAnchorRecord in session.rs) */
+export interface SessionAnchorRecord {
+  id: string;
+  project_id: string;
+  message_id: string;
+  anchor_type: string;
+  content: string;
+  estimated_tokens: number;
+  turn_index: number;
+  created_at: number;
+}
diff --git a/v2/src/lib/types/groups.ts b/v2/src/lib/types/groups.ts
new file mode 100644
index 0000000..a4539e3
--- /dev/null
+++ b/v2/src/lib/types/groups.ts
@@ -0,0 +1,107 @@
+import type { ProviderId } from '../providers/types';
+import type { AnchorBudgetScale } from './anchors';
+import type { WakeStrategy } from './wake';
+import type { ProjectId, GroupId, AgentId } from './ids';
+
+export interface ProjectConfig {
+  id: ProjectId;
+  name: string;
+  identifier: string;
+  description: string;
+  icon: string;
+  cwd: string;
+  profile: string;
+  enabled: boolean;
+  /** Agent provider for this project (defaults to 'claude') */
+  provider?: ProviderId;
+  /** When true, agents for this project use git worktrees for isolation */
+  useWorktrees?: boolean;
+  /** When true, sidecar process is sandboxed via Landlock (Linux 5.13+, restricts filesystem access) */
+  sandboxEnabled?: boolean;
+  /** Anchor token budget scale (defaults to 'medium' = 6K tokens) */
+  anchorBudgetScale?: AnchorBudgetScale;
+  /** Stall detection threshold in minutes (defaults to 15) */
+  stallThresholdMin?: number;
+  /** True for Tier 1 management agents rendered as project boxes */
+  isAgent?: boolean;
+  /** Agent role (manager/architect/tester/reviewer) — only when isAgent */
+  agentRole?: GroupAgentRole;
+  /** System prompt injected at session start — only when isAgent */
+  systemPrompt?: string;
+}
+
+export const AGENT_ROLE_ICONS: Record<string, string> = {
+  manager: '🎯',
+  architect: '🏗',
+  tester: '🧪',
+  reviewer: '🔍',
+};
+
+/** Convert a GroupAgentConfig to a ProjectConfig for unified rendering */
+export function agentToProject(agent: GroupAgentConfig, groupCwd: string): ProjectConfig {
+  // Agent IDs serve as project IDs in the workspace (agents render as project boxes)
+  return {
+    id: agent.id as unknown as ProjectId,
+    name: agent.name,
+    identifier: agent.role,
+    description: `${agent.role.charAt(0).toUpperCase() + agent.role.slice(1)} agent`,
+    icon: AGENT_ROLE_ICONS[agent.role] ?? '🤖',
+    cwd: agent.cwd ?? groupCwd,
+    profile: 'default',
+    enabled: agent.enabled,
+    isAgent: true,
+    agentRole: agent.role,
+    systemPrompt: agent.systemPrompt,
+  };
+}
+
+/** Group-level agent role (Tier 1 management agents) */
+export type GroupAgentRole = 'manager' | 'architect' | 'tester' | 'reviewer';
+
+/** Group-level agent status */
+export type GroupAgentStatus = 'active' | 'sleeping' | 'stopped';
+
+/** Group-level agent configuration */
+export interface GroupAgentConfig {
+  id: AgentId;
+  name: string;
+  role: GroupAgentRole;
+  model?: string;
+  cwd?: string;
+  systemPrompt?: string;
+  enabled: boolean;
+  /** Auto-wake interval in minutes (Manager only, default 3) */
+  wakeIntervalMin?: number;
+  /** Wake strategy: persistent (always-on), on-demand (fresh session), smart (threshold-gated) */
+  wakeStrategy?: WakeStrategy;
+  /** Wake threshold 0..1 for smart strategy (default 0.5) */
+  wakeThreshold?: number;
+}
+
+export interface GroupConfig {
+  id: GroupId;
+  name: string;
+  projects: ProjectConfig[];
+  /** Group-level orchestration agents (Tier 1) */
+  agents?: GroupAgentConfig[];
+}
+
+export interface GroupsFile {
+  version: number;
+  groups: GroupConfig[];
+  activeGroupId: GroupId;
+}
+
+/** Derive a project identifier from a name: lowercase, spaces to dashes */
+export function deriveIdentifier(name: string): string {
+  return name.toLowerCase().replace(/\s+/g, '-').replace(/[^a-z0-9-]/g, '');
+}
+
+/** Project accent colors by slot index (0-4), Catppuccin Mocha */
+export const PROJECT_ACCENTS = [
+  '--ctp-blue',
+  '--ctp-green',
+  '--ctp-mauve',
+  '--ctp-peach',
+  '--ctp-pink',
+] as const;
diff --git a/v2/src/lib/types/ids.test.ts b/v2/src/lib/types/ids.test.ts
new file mode 100644
index 0000000..9cd1f41
--- /dev/null
+++ b/v2/src/lib/types/ids.test.ts
@@ -0,0 +1,96 @@
+import { describe, it, expect } from 'vitest';
+import {
+  SessionId, ProjectId, GroupId, AgentId,
+  type SessionId as SessionIdType,
+  type ProjectId as ProjectIdType,
+  type GroupId as GroupIdType,
+  type AgentId as AgentIdType,
+} from './ids';
+
+describe('branded types', () => {
+  describe('SessionId', () => {
+    it('creates a SessionId from a string', () => {
+      const id = SessionId('sess-abc-123');
+      expect(id).toBe('sess-abc-123');
+    });
+
+    it('is usable as a string (template literal)', () => {
+      const id = SessionId('sess-1');
+      expect(`session: ${id}`).toBe('session: sess-1');
+    });
+
+    it('is usable as a Map key', () => {
+      const map = new Map<SessionIdType, number>();
+      const id = SessionId('sess-1');
+      map.set(id, 42);
+      expect(map.get(id)).toBe(42);
+    });
+
+    it('equality works between two SessionIds with same value', () => {
+      const a = SessionId('sess-1');
+      const b = SessionId('sess-1');
+      expect(a === b).toBe(true);
+    });
+  });
+
+  describe('ProjectId', () => {
+    it('creates a ProjectId from a string', () => {
+      const id = ProjectId('proj-xyz');
+      expect(id).toBe('proj-xyz');
+    });
+
+    it('is usable as a Map key', () => {
+      const map = new Map<ProjectIdType, string>();
+      const id = ProjectId('proj-1');
+      map.set(id, 'test-project');
+      expect(map.get(id)).toBe('test-project');
+    });
+  });
+
+  describe('GroupId', () => {
+    it('creates a GroupId from a string', () => {
+      const id = GroupId('grp-abc');
+      expect(id).toBe('grp-abc');
+    });
+
+    it('is usable as a Map key', () => {
+      const map = new Map<GroupIdType, string>();
+      const id = GroupId('grp-1');
+      map.set(id, 'test-group');
+      expect(map.get(id)).toBe('test-group');
+    });
+  });
+
+  describe('AgentId', () => {
+    it('creates an AgentId from a string', () => {
+      const id = AgentId('agent-manager');
+      expect(id).toBe('agent-manager');
+    });
+
+    it('is usable as a Map key', () => {
+      const map = new Map<AgentIdType, number>();
+      const id = AgentId('a1');
+      map.set(id, 99);
+      expect(map.get(id)).toBe(99);
+    });
+
+    it('equality works between two AgentIds with same value', () => {
+      const a = AgentId('a1');
+      const b = AgentId('a1');
+      expect(a === b).toBe(true);
+    });
+  });
+
+  describe('type safety (compile-time)', () => {
+    it('all four types are strings at runtime', () => {
+      const sid = SessionId('s1');
+      const pid = ProjectId('p1');
+      const gid = GroupId('g1');
+      const aid = AgentId('a1');
+      expect(typeof sid).toBe('string');
+      expect(typeof pid).toBe('string');
+      expect(typeof gid).toBe('string');
+      expect(typeof aid).toBe('string');
+    });
+  });
+});
diff --git a/v2/src/lib/types/ids.ts b/v2/src/lib/types/ids.ts
new file mode 100644
index 0000000..f704e91
--- /dev/null
+++ b/v2/src/lib/types/ids.ts
@@ -0,0 +1,34 @@
+// Branded types for domain identifiers — prevents accidental swapping of IDs across domains.
+// These are compile-time only; at runtime they are plain strings.
+
+/** Unique identifier for an agent session */
+export type SessionId = string & { readonly __brand: 'SessionId' };
+
+/** Unique identifier for a project */
+export type ProjectId = string & { readonly __brand: 'ProjectId' };
+
+/** Unique identifier for a project group */
+export type GroupId = string & { readonly __brand: 'GroupId' };
+
+/** Unique identifier for an agent in the btmsg/bttask system */
+export type AgentId = string & { readonly __brand: 'AgentId' };
+
+/** Create a SessionId from a raw string */
+export function SessionId(value: string): SessionId {
+  return value as SessionId;
+}
+
+/** Create a ProjectId from a raw string */
+export function ProjectId(value: string): ProjectId {
+  return value as ProjectId;
+}
+
+/** Create a GroupId from a raw string */
+export function GroupId(value: string): GroupId {
+  return value as GroupId;
+}
+
+/** Create an AgentId from a raw string */
+export function AgentId(value: string): AgentId {
+  return value as AgentId;
+}
diff --git a/v2/src/lib/types/wake.ts b/v2/src/lib/types/wake.ts
new file mode 100644
index 0000000..7898561
--- /dev/null
+++ b/v2/src/lib/types/wake.ts
@@ -0,0 +1,70 @@
+import type { ProjectId as ProjectIdType } from './ids';
+
+/** How the Manager agent session is managed between wake events */
+export type WakeStrategy = 'persistent' | 'on-demand' | 'smart';
+
+export const WAKE_STRATEGIES: WakeStrategy[] = ['persistent', 'on-demand', 'smart'];
+
+export const WAKE_STRATEGY_LABELS: Record<WakeStrategy, string> = {
+  persistent: 'Persistent',
+  'on-demand': 'On-demand',
+  smart: 'Smart',
+};
+
+export const WAKE_STRATEGY_DESCRIPTIONS: Record<WakeStrategy, string> = {
+  persistent: 'Manager stays running, receives periodic context refreshes',
+  'on-demand': 'Manager wakes on every interval, gets fresh context each time',
+  smart: 'Manager only wakes when signal score exceeds threshold',
+};
+
+/** Individual wake signal with score and description */
+export interface WakeSignal {
+  id: string;
+  score: number; // 0..1
+  reason: string;
+}
+
+/** Aggregated wake evaluation result */
+export interface WakeEvaluation {
+  /** Total score (max of individual signals, not sum) */
+  score: number;
+  /** All triggered signals sorted by score descending */
+  signals: WakeSignal[];
+  /** Whether the wake should fire (always true for persistent/on-demand, threshold-gated for smart) */
+  shouldWake: boolean;
+  /** Human-readable summary for the Manager prompt */
+  summary: string;
+}
+
+/** Context passed to the Manager when waking */
+export interface WakeContext {
+  /** Wake evaluation that triggered this event */
+  evaluation: WakeEvaluation;
+  /** Per-project health snapshot */
+  projectSnapshots: WakeProjectSnapshot[];
+  /** Task board summary (if available) */
+  taskSummary?: WakeTaskSummary;
+}
+
+/** Per-project health snapshot included in wake context */
+export interface WakeProjectSnapshot {
+  projectId: ProjectIdType;
+  projectName: string;
+  activityState: string;
+  idleMinutes: number;
+  burnRatePerHour: number;
+  contextPressurePercent: number | null;
+  fileConflicts: number;
+  attentionScore: number;
+  attentionReason: string | null;
+}
+
+/** Task board summary included in wake context */
+export interface WakeTaskSummary {
+  total: number;
+  todo: number;
+  inProgress: number;
+  blocked: number;
+  review: number;
+  done: number;
+}
diff --git a/v2/src/lib/utils/agent-prompts.ts b/v2/src/lib/utils/agent-prompts.ts
new file mode 100644
index 0000000..47c2a31
--- /dev/null
+++ b/v2/src/lib/utils/agent-prompts.ts
@@ -0,0 +1,429 @@
+/**
+ * System prompt generator for management agents.
+ * Builds comprehensive introductory context including:
+ * - Environment description (group, projects, team)
+ * - Role-specific instructions
+ * - Full btmsg/bttask tool documentation
+ * - Communication hierarchy
+ * - Custom editable context (from groups.json or Memora)
+ *
+ * This prompt is injected at every session start and should be
+ * re-injected periodically (e.g., hourly) for long-running agents.
+ */
+
+import type { GroupAgentRole, GroupConfig, GroupAgentConfig, ProjectConfig } from '../types/groups';
+
+// ─── Role descriptions ──────────────────────────────────────
+
+const ROLE_DESCRIPTIONS: Record<GroupAgentRole, string> = {
+  manager: `You are the **Manager** — the central coordinator of this project group.
+
+**Your authority:**
+- You have FULL visibility across all projects and agents
+- You create and assign tasks to team members
+- You can edit context/instructions for your subordinates
+- You escalate blockers and decisions to the Operator (human admin)
+- You are the ONLY agent who communicates directly with the Operator
+
+**Your responsibilities:**
+- Break down high-level goals into actionable tasks
+- Assign work to the right agents based on their capabilities
+- Monitor progress, deadlines, and blockers across all projects
+- Coordinate between Architect, Tester, and project agents
+- Ensure team alignment and resolve conflicts
+- Provide status summaries to the Operator when asked`,
+
+  architect: `You are the **Architect** — responsible for technical design and code quality.
+
+**Your authority:**
+- You review architecture decisions across ALL projects
+- You can request changes or block merges on architectural grounds
+- You propose technical solutions and document them
+
+**Your responsibilities:**
+- Ensure API consistency between all components (backend, display, etc.)
+- Review code for architectural correctness, patterns, and anti-patterns
+- Design system interfaces and data flows
+- Document architectural decisions and trade-offs
+- Report architectural concerns to the Manager
+- Mentor project agents on best practices`,
+
+  tester: `You are the **Tester** — responsible for quality assurance across all projects.
+
+**Your authority:**
+- You validate all features before they're considered "done"
+- You can mark tasks as "blocked" if they fail tests
+- You define testing standards for the team
+
+**Your responsibilities:**
+- Write and run unit, integration, and E2E tests
+- Validate features work end-to-end across projects
+- Report bugs with clear reproduction steps (to Manager)
+- Track test coverage and suggest improvements
+- Use Selenium/browser automation for UI testing when needed
+- Verify deployments on target hardware (Raspberry Pi)`,
+
+  reviewer: `You are the **Reviewer** — responsible for code review and standards.
+
+**Your authority:**
+- You review all code changes for quality and security
+- You can request changes before approval
+
+**Your responsibilities:**
+- Review code quality, security, and adherence to best practices
+- Provide constructive, actionable feedback
+- Ensure consistent coding standards across projects
+- Flag security vulnerabilities and performance issues
+- Verify error handling and edge cases`,
+};
+
+// ─── Tool documentation ─────────────────────────────────────
+
+const BTMSG_DOCS = `
+## Tool: btmsg — Agent Messenger
+
+btmsg is your primary communication channel with other agents and the Operator.
+Your identity is set automatically (BTMSG_AGENT_ID env var). You don't need to configure it.
+
+### Reading messages
+\`\`\`bash
+btmsg inbox            # Show unread messages (CHECK THIS FIRST!)
+btmsg inbox --all      # Show all messages (including read)
+btmsg read <msg-id>    # Read a specific message (marks as read)
+\`\`\`
+
+### Sending messages
+\`\`\`bash
+btmsg send <agent-id> "Your message here"   # Send direct message
+btmsg reply <msg-id> "Your reply here"      # Reply to a message
+\`\`\`
+You can only message agents in your contacts list. Use \`btmsg contacts\` to see who.
+
+### Information
+\`\`\`bash
+btmsg contacts         # List agents you can message
+btmsg history <agent>  # Conversation history with an agent
+btmsg status           # All agents and their current status
+btmsg whoami           # Your identity and unread count
+btmsg graph            # Visual hierarchy of the team
+\`\`\`
+
+### Channels (group chat)
+\`\`\`bash
+btmsg channel list                      # List channels
+btmsg channel send <name> "message"     # Post to a channel
+btmsg channel history <name>            # Channel message history
+btmsg channel create <name>             # Create a new channel
+\`\`\`
+
+### Communication rules
+- **Always check \`btmsg inbox\` first** when you start or wake up
+- Respond to messages promptly — other agents may be waiting on you
+- Keep messages concise and actionable
+- Use reply threading (\`btmsg reply\`) to maintain conversation context
+- If you need someone not in your contacts, ask the Manager to relay`;
+
+const BTTASK_DOCS = `
+## Tool: bttask — Task Board
+
+bttask is a Kanban-style task tracker shared across the team.
+Tasks flow through: todo → progress → review → done (or blocked).
+
+### Viewing tasks
+\`\`\`bash
+bttask list                    # List all tasks
+bttask board                   # Kanban board view (5 columns)
+bttask show <task-id>          # Full task details + comments
+\`\`\`
+
+### Managing tasks (Manager only)
+\`\`\`bash
+bttask add "Title" --desc "Description" --priority high    # Create task
+bttask assign <task-id> <agent-id>                          # Assign to agent
+bttask delete <task-id>                                     # Delete task
+\`\`\`
+
+### Working on tasks (all agents)
+\`\`\`bash
+bttask status <task-id> progress    # Mark as in progress
+bttask status <task-id> review      # Ready for review
+bttask status <task-id> done        # Completed
+bttask status <task-id> blocked     # Blocked (explain in comment!)
+bttask comment <task-id> "Comment"  # Add a comment/update
+\`\`\`
+
+### Task priorities: low, medium, high, critical
+### Task statuses: todo, progress, review, done, blocked`;
+
+// ─── Prompt generator ───────────────────────────────────────
+
+export interface AgentPromptContext {
+  role: GroupAgentRole;
+  agentId: string;
+  agentName: string;
+  group: GroupConfig;
+  /** Custom context editable by Manager/admin */
+  customPrompt?: string;
+}
+
+/**
+ * Generate the full introductory context for an agent.
+ * This should be injected at session start AND periodically re-injected.
+ */
+export function generateAgentPrompt(ctx: AgentPromptContext): string {
+  const { role, agentId, agentName, group, customPrompt } = ctx;
+  const roleDesc = ROLE_DESCRIPTIONS[role] ?? `You are a ${role} agent.`;
+
+  const parts: string[] = [];
+
+  // ── Section 1: Identity ──
+  parts.push(`# You are: ${agentName}
+
+${roleDesc}
+
+**Agent ID:** \`${agentId}\`
+**Group:** ${group.name}`);
+
+  // ── Section 2: Environment ──
+  parts.push(buildEnvironmentSection(group));
+
+  // ── Section 3: Team ──
+  parts.push(buildTeamSection(group, agentId));
+
+  // ── Section 4: Tools ──
+  parts.push(BTMSG_DOCS);
+  if (role === 'manager' || role === 'architect') {
+    parts.push(BTTASK_DOCS);
+  } else if (role === 'reviewer') {
+    // Reviewer gets full read + status update + comment access
+    parts.push(`
+## Tool: bttask — Task Board (review access)
+
+You have full read access plus the ability to update task status and add comments.
+You CANNOT create, assign, or delete tasks (Manager only).
+
+\`\`\`bash
+bttask board                         # Kanban board view
+bttask show <task-id>                # Full task details + comments
+bttask list                          # List all tasks
+bttask status <task-id> done         # Approve — mark as done
+bttask status <task-id> progress     # Request changes — send back
+bttask status <task-id> blocked      # Block — explain in comment!
+bttask comment <task-id> "verdict"   # Add review verdict/feedback
+\`\`\`
+
+### Review workflow with bttask
+- Tasks in the **review** column are waiting for YOUR review
+- After reviewing, either move to **done** (approved) or **progress** (needs changes)
+- ALWAYS add a comment with your verdict before changing status
+- When a task moves to review, a notification is auto-posted to \`#review-queue\``);
+  } else {
+    // Other agents get read-only bttask info
+    parts.push(`
+## Tool: bttask — Task Board (read + update)
+
+You can view and update tasks, but cannot create or assign them.
+
+\`\`\`bash
+bttask board                         # Kanban board view
+bttask show <task-id>                # Task details
+bttask status <task-id> <status>     # Update: progress/review/done/blocked
+bttask comment <task-id> "update"    # Add a comment
+\`\`\``);
+  }
+
+  // ── Section 5: Custom context (editable by Manager/admin) ──
+  if (customPrompt) {
+    parts.push(`## Project-Specific Context
+
+${customPrompt}`);
+  }
+
+  // ── Section 6: Workflow ──
+  parts.push(buildWorkflowSection(role));
+
+  return parts.join('\n\n---\n\n');
+}
+
+function buildEnvironmentSection(group: GroupConfig): string {
+  const projects = group.projects.filter(p => p.enabled);
+
+  const projectLines = projects.map(p => {
+    const parts = [`- **${p.name}** (\`${p.identifier}\`)`];
+    if (p.description) parts.push(`— ${p.description}`);
+    parts.push(`\n  CWD: \`${p.cwd}\``);
+    return parts.join(' ');
+  }).join('\n');
+
+  return `## Environment
+
+**Platform:** BTerminal Mission Control — multi-agent orchestration system
+**Group:** ${group.name}
+**Your working directory:** Same as the monorepo root (shared across Tier 1 agents)
+
+### Projects in this group
+${projectLines}
+
+### How it works
+- Each project has its own Claude session, terminal, file browser, and context
+- Tier 1 agents (you and your peers) coordinate across ALL projects
+- Tier 2 agents (project-level) execute code within their specific project CWD
+- All communication goes through \`btmsg\`. There is no other way to talk to other agents.
+- Task tracking goes through \`bttask\`. This is the shared task board.`;
+}
+
+function buildTeamSection(group: GroupConfig, myId: string): string {
+  const agents = group.agents ?? [];
+  const projects = group.projects.filter(p => p.enabled);
+
+  const lines: string[] = ['## Team'];
+
+  // Tier 1
+  const tier1 = agents.filter(a => a.id !== myId);
+  if (tier1.length > 0) {
+    lines.push('\n### Tier 1 — Management (your peers)');
+    for (const a of tier1) {
+      const status = a.enabled ? '' : ' *(disabled)*';
+      lines.push(`- **${a.name}** (\`${a.id}\`, ${a.role})${status}`);
+    }
+  }
+
+  // Tier 2
+  if (projects.length > 0) {
+    lines.push('\n### Tier 2 — Execution (project agents)');
+    for (const p of projects) {
+      lines.push(`- **${p.name}** (\`${p.id}\`, project) — works in \`${p.cwd}\``);
+    }
+  }
+
+  // Operator
+  lines.push('\n### Operator (human admin)');
+  lines.push('- **Operator** (`admin`) — the human who controls this system. Has full visibility and authority.');
+  if (agents.find(a => a.id === myId)?.role === 'manager') {
+    lines.push('  You report directly to the Operator. Escalate decisions and blockers to them.');
+  } else {
+    lines.push('  Communicate with the Operator only through the Manager, unless directly addressed.');
+  }
+
+  // Communication hierarchy
+  lines.push(`\n### Communication hierarchy
+- **Operator** ↔ Manager (direct line)
+- **Manager** ↔ all Tier 1 agents ↔ Tier 2 agents they manage
+- **Tier 2 agents** report to Manager (and can talk to assigned Tier 1 reviewers)
+- Use \`btmsg contacts\` to see exactly who you can reach`);
+
+  return lines.join('\n');
+}
+
+function buildWorkflowSection(role: GroupAgentRole): string {
+  if (role === 'manager') {
+    return `## Multi-Agent Delegation
+
+You can spawn child agents to parallelize work across multiple tasks:
+
+\`\`\`
+Use the Agent tool to launch a subagent:
+Agent "task description for the child agent"
+\`\`\`
+
+Child agents run independently with their own context. Use delegation for:
+- **Parallel research** — send multiple agents to explore different approaches simultaneously
+- **Specialized subtasks** — delegate code review, test writing, or documentation to focused agents
+- **Exploratory analysis** — let a child agent investigate while you continue coordinating
+
+Child agent results appear in the Team Agents panel. You can monitor their progress
+and incorporate their findings into your coordination work.
+
+**When to delegate vs. do it yourself:**
+- Delegate when a task is self-contained and doesn't need your ongoing attention
+- Do it yourself when the task requires cross-project coordination or decision-making
+- Prefer delegation for tasks that would block your main coordination loop
+
+## Your Workflow
+
+1. **Check inbox:** \`btmsg inbox\` — read and respond to all messages
+2. **Review task board:** \`bttask board\` — check status of all tasks
+3. **Coordinate:** Assign new tasks, unblock agents, resolve conflicts
+4. **Delegate:** Spawn child agents for parallelizable work (see above)
+5. **Monitor:** Check agent status (\`btmsg status\`), follow up on stalled work
+6. **Report:** Summarize progress to the Operator when asked
+7. **Repeat:** Check inbox again — new messages may have arrived
+
+**Important:** You are the hub of all communication. If an agent is blocked, YOU unblock them.
+If the Operator sends a message, it's your TOP PRIORITY.`;
+  }
+
+  if (role === 'architect') {
+    return `## Your Workflow
+
+1. **Check inbox:** \`btmsg inbox\` — the Manager may have requests
+2. **Review tasks:** \`bttask board\` — look for tasks assigned to you
+3. **Analyze:** Review code, architecture, and design across projects
+4. **Document:** Write down decisions and rationale
+5. **Communicate:** Send findings to Manager, guide project agents
+6. **Update tasks:** Mark completed reviews, comment on progress`;
+  }
+
+  if (role === 'tester') {
+    return `## Your Workflow
+
+1. **Check inbox:** \`btmsg inbox\` — the Manager assigns testing tasks
+2. **Review assignments:** Check \`bttask board\` for testing tasks
+3. **Write tests:** Create test cases, scripts, or Selenium scenarios
+4. **Run tests:** Execute and collect results
+5. **Report:** Send bug reports to Manager via btmsg, update task status
+6. **Verify fixes:** Re-test when developers say a bug is fixed`;
+  }
+
+  if (role === 'reviewer') {
+    return `## Your Workflow
+
+1. **Check inbox:** \`btmsg inbox\` — read review requests and messages
+2. **Check review queue:** \`btmsg channel history review-queue\` — see newly submitted reviews
+3. **Review tasks:** \`bttask board\` — find tasks in the **review** column
+4. **Analyze:** For each review task:
+   a. Read the task description and comments (\`bttask show <id>\`)
+   b. Read the relevant code changes
+   c. Check for security issues, bugs, style violations, and test coverage
+5. **Verdict:** Add your review as a comment (\`bttask comment <id> "APPROVED: ..."\` or \`"CHANGES REQUESTED: ..."\`)
+6. **Update status:** Move task to **done** (approved) or **progress** (needs changes)
+7. **Log verdict:** Post summary to \`btmsg channel send review-log "Task <id>: APPROVED/REJECTED — reason"\`
+8. **Report:** Notify the Manager of review outcomes if significant
+
+**Review standards:**
+- Code quality: readability, naming, structure
+- Security: input validation, auth checks, injection risks
+- Error handling: all errors caught and handled visibly
+- Tests: adequate coverage for new/changed code
+- Performance: no N+1 queries, unbounded fetches, or memory leaks`;
+  }
+
+  return `## Your Workflow
+
+1. **Check inbox:** \`btmsg inbox\` — read all unread messages
+2. **Check tasks:** \`bttask board\` — see what's assigned to you
+3. **Work:** Execute your assigned tasks
+4. **Update:** \`bttask status <id> progress\` and \`bttask comment <id> "update"\`
+5. **Report:** Message the Manager when done or blocked
+6. **Repeat:** Check inbox for new messages`;
+}
+
+// ─── Legacy signature (backward compat) ─────────────────────
+
+/**
+ * @deprecated Use generateAgentPrompt(ctx) with full context instead
+ */
+export function generateAgentPromptSimple(
+  role: GroupAgentRole,
+  agentId: string,
+  customPrompt?: string,
+): string {
+  // Minimal fallback without group context
+  const roleDesc = ROLE_DESCRIPTIONS[role] ?? `You are a ${role} agent.`;
+  return [
+    `# Agent Role\n\n${roleDesc}`,
+    `\nYour agent ID: \`${agentId}\``,
+    BTMSG_DOCS,
+    customPrompt ? `\n## Additional Context\n\n${customPrompt}` : '',
+  ].filter(Boolean).join('\n');
+}
diff --git a/v2/src/lib/utils/agent-tree.test.ts b/v2/src/lib/utils/agent-tree.test.ts
new file mode 100644
index 0000000..2268244
--- /dev/null
+++ b/v2/src/lib/utils/agent-tree.test.ts
@@ -0,0 +1,297 @@
+import { describe, it, expect } from 'vitest';
+import { buildAgentTree, countTreeNodes, subtreeCost } from './agent-tree';
+import type { AgentMessage, ToolCallContent, ToolResultContent } from '../adapters/claude-messages';
+import type { AgentTreeNode } from './agent-tree';
+
+// Helper to create typed AgentMessages
+function makeToolCall(
+  uuid: string,
+  toolUseId: string,
+  name: string,
+  parentId?: string,
+): AgentMessage {
+  return {
+    id: uuid,
+    type: 'tool_call',
+    parentId,
+    content: { toolUseId, name, input: {} } satisfies ToolCallContent,
+    timestamp: Date.now(),
+  };
+}
+
+function makeToolResult(uuid: string, toolUseId: string, parentId?: string): AgentMessage {
+  return {
+    id: uuid,
+    type: 'tool_result',
+    parentId,
+    content: { toolUseId, output: 'ok' } satisfies ToolResultContent,
+    timestamp: Date.now(),
+  };
+}
+
+function makeTextMessage(uuid: string, text: string, parentId?: string): AgentMessage {
+  return {
+    id: uuid,
+    type: 'text',
+    parentId,
+    content: { text },
+    timestamp: Date.now(),
+  };
+}
+
+describe('buildAgentTree', () => {
+  it('creates a root node with no children from empty messages', () => {
+    const tree = buildAgentTree('session-1', [], 'done', 0.05, 1500);
+
+    expect(tree.id).toBe('session-1');
+    expect(tree.label).toBe('session-');
+    expect(tree.status).toBe('done');
+    expect(tree.costUsd).toBe(0.05);
+    expect(tree.tokens).toBe(1500);
+    expect(tree.children).toEqual([]);
+  });
+
+  it('maps running/starting status to running', () => {
+    const tree1 = buildAgentTree('s1', [], 'running', 0, 0);
+    expect(tree1.status).toBe('running');
+
+    const tree2 = buildAgentTree('s2', [], 'starting', 0, 0);
+    expect(tree2.status).toBe('running');
+  });
+
+  it('maps error status to error', () => {
+    const tree = buildAgentTree('s3', [], 'error', 0, 0);
+    expect(tree.status).toBe('error');
+  });
+
+  it('maps other statuses to done', () => {
+    const tree = buildAgentTree('s4', [], 'completed', 0, 0);
+    expect(tree.status).toBe('done');
+  });
+
+  it('adds tool_call messages as children of root', () => {
+    const messages: AgentMessage[] = [
+      makeToolCall('m1', 'tool-1', 'Read'),
+      makeToolCall('m2', 'tool-2', 'Write'),
+    ];
+
+    const tree = buildAgentTree('sess', messages, 'done', 0, 0);
+
+    expect(tree.children).toHaveLength(2);
+    expect(tree.children[0].id).toBe('tool-1');
+    expect(tree.children[0].label).toBe('Read');
+    expect(tree.children[0].toolName).toBe('Read');
+    expect(tree.children[1].id).toBe('tool-2');
+    expect(tree.children[1].label).toBe('Write');
+  });
+
+  it('marks tool nodes as running until a result arrives', () => {
+    const messages: AgentMessage[] = [
+      makeToolCall('m1', 'tool-1', 'Bash'),
+    ];
+
+    const tree = buildAgentTree('sess', messages, 'running', 0, 0);
+    expect(tree.children[0].status).toBe('running');
+  });
+
+  it('marks tool nodes as done when result arrives', () => {
+    const messages: AgentMessage[] = [
+      makeToolCall('m1', 'tool-1', 'Bash'),
+      makeToolResult('m2', 'tool-1'),
+    ];
+
+    const tree = buildAgentTree('sess', messages, 'done', 0, 0);
+    expect(tree.children[0].status).toBe('done');
+  });
+
+  it('nests subagent tool calls under their parent tool node', () => {
+    const messages: AgentMessage[] = [
+      makeToolCall('m1', 'tool-parent', 'Agent'),
+      makeToolCall('m2', 'tool-child', 'Read', 'tool-parent'),
+    ];
+
+    const tree = buildAgentTree('sess', messages, 'done', 0, 0);
+
+    expect(tree.children).toHaveLength(1);
+    const parentNode = tree.children[0];
+    expect(parentNode.id).toBe('tool-parent');
+    expect(parentNode.children).toHaveLength(1);
+    expect(parentNode.children[0].id).toBe('tool-child');
+    expect(parentNode.children[0].label).toBe('Read');
+  });
+
+  it('handles deeply nested subagents (3 levels)', () => {
+    const messages: AgentMessage[] = [
+      makeToolCall('m1', 'level-1', 'Agent'),
+      makeToolCall('m2', 'level-2', 'SubAgent', 'level-1'),
+      makeToolCall('m3', 'level-3', 'Read', 'level-2'),
+    ];
+
+    const tree = buildAgentTree('sess', messages, 'done', 0, 0);
+
+    expect(tree.children).toHaveLength(1);
+    expect(tree.children[0].children).toHaveLength(1);
+    expect(tree.children[0].children[0].children).toHaveLength(1);
+    expect(tree.children[0].children[0].children[0].id).toBe('level-3');
+  });
+
+  it('attaches to root when parentId references a non-existent tool node', () => {
+    const messages: AgentMessage[] = [
+      makeToolCall('m1', 'orphan-tool', 'Bash', 'nonexistent-parent'),
+    ];
+
+    const tree = buildAgentTree('sess', messages, 'done', 0, 0);
+
+    expect(tree.children).toHaveLength(1);
+    expect(tree.children[0].id).toBe('orphan-tool');
+  });
+
+  it('ignores non-tool messages (text, thinking, etc.)', () => {
+    const messages: AgentMessage[] = [
+      makeTextMessage('m1', 'Hello'),
+      makeToolCall('m2', 'tool-1', 'Read'),
+      makeTextMessage('m3', 'Done'),
+    ];
+
+    const tree = buildAgentTree('sess', messages, 'done', 0, 0);
+
+    expect(tree.children).toHaveLength(1);
+    expect(tree.children[0].id).toBe('tool-1');
+  });
+
+  it('handles tool_result for a non-existent tool gracefully', () => {
+    const messages: AgentMessage[] = [
+      makeToolResult('m1', 'nonexistent-tool'),
+    ];
+
+    // Should not throw
+    const tree = buildAgentTree('sess', messages, 'done', 0, 0);
+    expect(tree.children).toHaveLength(0);
+  });
+
+  it('truncates session ID to 8 chars for label', () => {
+    const tree = buildAgentTree('abcdefghijklmnop', [], 'done', 0, 0);
+    expect(tree.label).toBe('abcdefgh');
+  });
+});
+
+describe('countTreeNodes', () => {
+  it('returns 1 for a leaf node', () => {
+    const leaf: AgentTreeNode = {
+      id: 'leaf',
+      label: 'leaf',
+      status: 'done',
+      costUsd: 0,
+      tokens: 0,
+      children: [],
+    };
+    expect(countTreeNodes(leaf)).toBe(1);
+  });
+
+  it('counts all nodes in a flat tree', () => {
+    const root: AgentTreeNode = {
+      id: 'root',
+      label: 'root',
+      status: 'done',
+      costUsd: 0,
+      tokens: 0,
+      children: [
+        { id: 'a', label: 'a', status: 'done', costUsd: 0, tokens: 0, children: [] },
+        { id: 'b', label: 'b', status: 'done', costUsd: 0, tokens: 0, children: [] },
+        { id: 'c', label: 'c', status: 'done', costUsd: 0, tokens: 0, children: [] },
+      ],
+    };
+    expect(countTreeNodes(root)).toBe(4);
+  });
+
+  it('counts all nodes in a nested tree', () => {
+    const root: AgentTreeNode = {
+      id: 'root',
+      label: 'root',
+      status: 'done',
+      costUsd: 0,
+      tokens: 0,
+      children: [
+        {
+          id: 'a',
+          label: 'a',
+          status: 'done',
+          costUsd: 0,
+          tokens: 0,
+          children: [
+            { id: 'a1', label: 'a1', status: 'done', costUsd: 0, tokens: 0, children: [] },
+            { id: 'a2', label: 'a2', status: 'done', costUsd: 0, tokens: 0, children: [] },
+          ],
+        },
+        { id: 'b', label: 'b', status: 'done', costUsd: 0, tokens: 0, children: [] },
+      ],
+    };
+    expect(countTreeNodes(root)).toBe(5);
+  });
+});
+
+describe('subtreeCost', () => {
+  it('returns own cost for a leaf node', () => {
+    const leaf: AgentTreeNode = {
+      id: 'leaf',
+      label: 'leaf',
+      status: 'done',
+      costUsd: 0.05,
+      tokens: 0,
+      children: [],
+    };
+    expect(subtreeCost(leaf)).toBe(0.05);
+  });
+
+  it('aggregates cost across children', () => {
+    const root: AgentTreeNode = {
+      id: 'root',
+      label: 'root',
+      status: 'done',
+      costUsd: 0.10,
+      tokens: 0,
+      children: [
+        { id: 'a', label: 'a', status: 'done', costUsd: 0.03, tokens: 0, children: [] },
+        { id: 'b', label: 'b', status: 'done', costUsd: 0.02, tokens: 0, children: [] },
+      ],
+    };
+    expect(subtreeCost(root)).toBeCloseTo(0.15);
+  });
+
+  it('aggregates cost recursively across nested children', () => {
+    const root: AgentTreeNode = {
+      id: 'root',
+      label: 'root',
+      status: 'done',
+      costUsd: 1.0,
+      tokens: 0,
+      children: [
+        {
+          id: 'a',
+          label: 'a',
+          status: 'done',
+          costUsd: 0.5,
+          tokens: 0,
+          children: [
+            { id: 'a1', label: 'a1', status: 'done', costUsd: 0.25, tokens: 0, children: [] },
+          ],
+        },
+      ],
+    };
+    expect(subtreeCost(root)).toBeCloseTo(1.75);
+  });
+
+  it('returns 0 for a tree with all zero costs', () => {
+    const root: AgentTreeNode = {
+      id: 'root',
+      label: 'root',
+      status: 'done',
+      costUsd: 0,
+      tokens: 0,
+      children: [
+        { id: 'a', label: 'a', status: 'done', costUsd: 0, tokens: 0, children: [] },
+      ],
+    };
+    expect(subtreeCost(root)).toBe(0);
+  });
+});
diff --git a/v2/src/lib/utils/agent-tree.ts b/v2/src/lib/utils/agent-tree.ts
new file mode 100644
index 0000000..0f11bb2
--- /dev/null
+++ b/v2/src/lib/utils/agent-tree.ts
@@ -0,0 +1,88 @@
+// Agent tree builder — constructs hierarchical tree from agent messages
+// Subagents are identified by parent_tool_use_id on their messages
+
+import type { AgentMessage, ToolCallContent, CostContent } from '../adapters/claude-messages';
+
+export interface AgentTreeNode {
+  id: string;
+  label: string;
+  toolName?: string;
+  status: 'running' | 'done' | 'error';
+  costUsd: number;
+  tokens: number;
+  children: AgentTreeNode[];
+}
+
+/**
+ * Build a tree from a flat list of agent messages.
+ * Root node represents the main agent session.
+ * Child nodes represent tool_use calls (potential subagents).
+ */
+export function buildAgentTree(
+  sessionId: string,
+  messages: AgentMessage[],
+  sessionStatus: string,
+  sessionCost: number,
+  sessionTokens: number,
+): AgentTreeNode {
+  const root: AgentTreeNode = {
+    id: sessionId,
+    label: sessionId.slice(0, 8),
+    status: sessionStatus === 'running' || sessionStatus === 'starting' ? 'running' :
+            sessionStatus === 'error' ? 'error' : 'done',
+    costUsd: sessionCost,
+    tokens: sessionTokens,
+    children: [],
+  };
+
+  // Map tool_use_id -> node for nesting
+  const toolNodes = new Map<string, AgentTreeNode>();
+
+  for (const msg of messages) {
+    if (msg.type === 'tool_call') {
+      const tc = msg.content as ToolCallContent;
+      const node: AgentTreeNode = {
+        id: tc.toolUseId,
+        label: tc.name,
+        toolName: tc.name,
+        status: 'running', // will be updated by result
+        costUsd: 0,
+        tokens: 0,
+        children: [],
+      };
+      toolNodes.set(tc.toolUseId, node);
+
+      if (msg.parentId) {
+        // This is a subagent tool call — attach to parent tool node
+        const parent = toolNodes.get(msg.parentId);
+        if (parent) {
+          parent.children.push(node);
+        } else {
+          root.children.push(node);
+        }
+      } else {
+        root.children.push(node);
+      }
+    }
+
+    if (msg.type === 'tool_result') {
+      const tr = msg.content as { toolUseId: string };
+      const node = toolNodes.get(tr.toolUseId);
+      if (node) {
+        node.status = 'done';
+      }
+    }
+  }
+
+  return root;
+}
+
+/** Flatten tree to get total count of nodes */
+export function countTreeNodes(node: AgentTreeNode): number {
+  return 1 + node.children.reduce((sum, c) => sum + countTreeNodes(c), 0);
+}
+
+/** Aggregate cost across a subtree */
+export function subtreeCost(node: AgentTreeNode): number {
+  return node.costUsd + node.children.reduce((sum, c) => sum + subtreeCost(c), 0);
+}
diff --git a/v2/src/lib/utils/anchor-serializer.test.ts b/v2/src/lib/utils/anchor-serializer.test.ts
new file mode 100644
index 0000000..f664c18
--- /dev/null
+++ b/v2/src/lib/utils/anchor-serializer.test.ts
@@ -0,0 +1,229 @@
+// Tests for anchor-serializer.ts — turn grouping, observation masking, token budgets
+
+import { describe, it, expect } from 'vitest';
+import {
+  estimateTokens,
+  groupMessagesIntoTurns,
+  selectAutoAnchors,
+  serializeAnchorsForInjection,
+} from './anchor-serializer';
+import type { AgentMessage } from '../adapters/claude-messages';
+
+function msg(type: AgentMessage['type'], content: unknown, id?: string): AgentMessage {
+  return {
+    id: id ?? crypto.randomUUID(),
+    type,
+    content,
+    timestamp: Date.now(),
+  };
+}
+
+describe('estimateTokens', () => {
+  it('estimates ~4 chars per token', () => {
+    expect(estimateTokens('abcd')).toBe(1);
+    expect(estimateTokens('abcdefgh')).toBe(2);
+    expect(estimateTokens('')).toBe(0);
+  });
+
+  it('rounds up', () => {
+    expect(estimateTokens('ab')).toBe(1); // ceil(2/4) = 1
+    expect(estimateTokens('abcde')).toBe(2); // ceil(5/4) = 2
+  });
+});
+
+describe('groupMessagesIntoTurns', () => {
+  it('returns empty for no messages', () => {
+    expect(groupMessagesIntoTurns([])).toEqual([]);
+  });
+
+  it('groups text + tool_call + tool_result + cost into one turn', () => {
+    const messages: AgentMessage[] = [
+      msg('text', { text: 'I will help you.' }),
+      msg('tool_call', { toolUseId: 'tc1', name: 'Read', input: { file_path: '/foo.ts' } }),
+      msg('tool_result', { toolUseId: 'tc1', output: 'file content here' }),
+      msg('cost', { totalCostUsd: 0.01, durationMs: 100, inputTokens: 100, outputTokens: 50, numTurns: 1, isError: false }),
+    ];
+
+    const turns = groupMessagesIntoTurns(messages);
+    expect(turns).toHaveLength(1);
+    expect(turns[0].index).toBe(0);
+    expect(turns[0].assistantText).toBe('I will help you.');
+    expect(turns[0].toolSummaries).toHaveLength(1);
+    expect(turns[0].toolSummaries[0]).toContain('[Read');
+    expect(turns[0].toolSummaries[0]).toContain('/foo.ts');
+  });
+
+  it('splits turns on cost events', () => {
+    const messages: AgentMessage[] = [
+      msg('text', { text: 'First response' }),
+      msg('cost', { totalCostUsd: 0.01, durationMs: 100, inputTokens: 100, outputTokens: 50, numTurns: 1, isError: false }),
+      msg('text', { text: 'Second response' }),
+      msg('cost', { totalCostUsd: 0.02, durationMs: 200, inputTokens: 200, outputTokens: 100, numTurns: 1, isError: false }),
+    ];
+
+    const turns = groupMessagesIntoTurns(messages);
+    expect(turns).toHaveLength(2);
+    expect(turns[0].assistantText).toBe('First response');
+    expect(turns[1].assistantText).toBe('Second response');
+    expect(turns[0].index).toBe(0);
+    expect(turns[1].index).toBe(1);
+  });
+
+  it('handles session without final cost event', () => {
+    const messages: AgentMessage[] = [
+      msg('text', { text: 'Working on it...' }),
+      msg('tool_call', { toolUseId: 'tc1', name: 'Bash', input: { command: 'npm test' } }),
+    ];
+
+    const turns = groupMessagesIntoTurns(messages);
+    expect(turns).toHaveLength(1);
+    expect(turns[0].assistantText).toBe('Working on it...');
+    expect(turns[0].toolSummaries[0]).toContain('[Bash');
+  });
+
+  it('skips init, thinking, compaction, status messages', () => {
+    const messages: AgentMessage[] = [
+      msg('init', { sessionId: 's1', model: 'claude', cwd: '/', tools: [] }),
+      msg('thinking', { text: 'Hmm...' }),
+      msg('text', { text: 'Here is the plan.' }),
+      msg('status', { subtype: 'progress' }),
+      msg('compaction', { trigger: 'auto', preTokens: 50000 }),
+      msg('cost', { totalCostUsd: 0.01, durationMs: 100, inputTokens: 100, outputTokens: 50, numTurns: 1, isError: false }),
+    ];
+
+    const turns = groupMessagesIntoTurns(messages);
+    expect(turns).toHaveLength(1);
+    expect(turns[0].assistantText).toBe('Here is the plan.');
+  });
+
+  it('compacts tool summaries for Write with line count', () => {
+    const messages: AgentMessage[] = [
+      msg('text', { text: 'Creating file.' }),
+      msg('tool_call', { toolUseId: 'tc1', name: 'Write', input: { file_path: '/app.ts', content: 'line1\nline2\nline3' } }),
+      msg('tool_result', { toolUseId: 'tc1', output: 'ok' }),
+      msg('cost', { totalCostUsd: 0.01, durationMs: 100, inputTokens: 100, outputTokens: 50, numTurns: 1, isError: false }),
+    ];
+
+    const turns = groupMessagesIntoTurns(messages);
+    expect(turns[0].toolSummaries[0]).toContain('[Write');
+    expect(turns[0].toolSummaries[0]).toContain('/app.ts');
+    expect(turns[0].toolSummaries[0]).toContain('3 lines');
+  });
+
+  it('compacts Bash tool with truncated command', () => {
+    const longCmd = 'a'.repeat(100);
+    const messages: AgentMessage[] = [
+      msg('text', { text: 'Running command.' }),
+      msg('tool_call', { toolUseId: 'tc1', name: 'Bash', input: { command: longCmd } }),
+      msg('cost', { totalCostUsd: 0.01, durationMs: 100, inputTokens: 100, outputTokens: 50, numTurns: 1, isError: false }),
+    ];
+
+    const turns = groupMessagesIntoTurns(messages);
+    // Command should be truncated to 80 chars
+    expect(turns[0].toolSummaries[0].length).toBeLessThan(longCmd.length);
+  });
+
+  it('concatenates multiple text messages in same turn', () => {
+    const messages: AgentMessage[] = [
+      msg('text', { text: 'Part 1.' }),
+      msg('text', { text: 'Part 2.' }),
+      msg('cost', { totalCostUsd: 0.01, durationMs: 100, inputTokens: 100, outputTokens: 50, numTurns: 1, isError: false }),
+    ];
+
+    const turns = groupMessagesIntoTurns(messages);
+    expect(turns[0].assistantText).toBe('Part 1.\nPart 2.');
+  });
+});
+
+describe('selectAutoAnchors', () => {
+  const makeSessionMessages = (turnCount: number): AgentMessage[] => {
+    const messages: AgentMessage[] = [];
+    for (let i = 0; i < turnCount; i++) {
+      messages.push(msg('text', { text: `Response for turn ${i + 1}` }));
+      messages.push(msg('cost', {
+        totalCostUsd: 0.01,
+        durationMs: 100,
+        inputTokens: 100,
+        outputTokens: 50,
+        numTurns: 1,
+        isError: false,
+      }));
+    }
+    return messages;
+  };
+
+  it('selects first N turns up to maxTurns', () => {
+    const messages = makeSessionMessages(10);
+    const { turns } = selectAutoAnchors(messages, 'Build auth module', 3, 50000);
+    expect(turns).toHaveLength(3);
+  });
+
+  it('injects session prompt as turn 0 user prompt', () => {
+    const messages = makeSessionMessages(3);
+    const { turns } = selectAutoAnchors(messages, 'Build auth module', 3, 50000);
+    expect(turns[0].userPrompt).toBe('Build auth module');
+  });
+
+  it('respects token budget', () => {
+    const messages = makeSessionMessages(10);
+    // Very small budget — should only fit 1-2 turns
+    const { turns } = selectAutoAnchors(messages, 'task', 10, 30);
+    expect(turns.length).toBeLessThan(10);
+    expect(turns.length).toBeGreaterThan(0);
+  });
+
+  it('returns empty for no messages', () => {
+    const { turns, totalTokens } = selectAutoAnchors([], 'task', 3, 6000);
+    expect(turns).toHaveLength(0);
+    expect(totalTokens).toBe(0);
+  });
+});
+
+describe('serializeAnchorsForInjection', () => {
+  it('produces session-anchors XML wrapper', () => {
+    const turns = [{
+      index: 0,
+      userPrompt: 'Build auth',
+      assistantText: 'I will create auth.ts',
+      toolSummaries: ['[Write /auth.ts → 50 lines]'],
+      estimatedTokens: 30,
+    }];
+
+    const result = serializeAnchorsForInjection(turns, 6000, 'my-project');
+    expect(result).toContain('<session-anchors');
+    expect(result).toContain('project="my-project"');
+    expect(result).toContain('</session-anchors>');
+    expect(result).toContain('Build auth');
+    expect(result).toContain('auth.ts');
+  });
+
+  it('respects token budget by truncating turns', () => {
+    const turns = Array.from({ length: 10 }, (_, i) => ({
+      index: i,
+      userPrompt: `Prompt ${i}`,
+      assistantText: 'A'.repeat(200), // ~50 tokens each
+      toolSummaries: [],
+      estimatedTokens: 80,
+    }));
+
+    // Budget for ~3 turns
+    const result = serializeAnchorsForInjection(turns, 300);
+    // Should not contain all 10 turns
+    expect(result).toContain('Prompt 0');
+    expect(result).not.toContain('Prompt 9');
+  });
+
+  it('works without project name', () => {
+    const turns = [{
+      index: 0,
+      userPrompt: 'Hello',
+      assistantText: 'Hi',
+      toolSummaries: [],
+      estimatedTokens: 5,
+    }];
+
+    const result = serializeAnchorsForInjection(turns, 6000);
+    expect(result).toContain('<session-anchors>');
+    expect(result).not.toContain('project=');
+  });
+});
diff --git a/v2/src/lib/utils/anchor-serializer.ts b/v2/src/lib/utils/anchor-serializer.ts
new file mode 100644
index 0000000..e2f48f2
--- /dev/null
+++ b/v2/src/lib/utils/anchor-serializer.ts
@@ -0,0 +1,211 @@
+// Anchor Serializer — converts agent messages into observation-masked anchor text
+// Observation masking: preserve user prompts + assistant reasoning, compact tool results
+
+import type { AgentMessage, TextContent, ToolCallContent, ToolResultContent } from '../adapters/claude-messages';
+
+/** Estimate token count from text (~4 chars per token) */
+export function estimateTokens(text: string): number {
+  return Math.ceil(text.length / 4);
+}
+
+/** A turn group: one user prompt + assistant response + tool interactions */
+export interface TurnGroup {
+  index: number;
+  userPrompt: string;
+  assistantText: string;
+  toolSummaries: string[];
+  estimatedTokens: number;
+}
+
+/**
+ * Group messages into turns. A new turn starts at each 'cost' event boundary
+ * or at session start. The first turn includes messages from init to the first cost event.
+ */
+export function groupMessagesIntoTurns(messages: AgentMessage[]): TurnGroup[] {
+  const turns: TurnGroup[] = [];
+  let currentTurn: { userPrompt: string; assistantText: string; toolSummaries: string[]; messages: AgentMessage[] } = {
+    userPrompt: '',
+    assistantText: '',
+    toolSummaries: [],
+    messages: [],
+  };
+  let turnIndex = 0;
+
+  // Build a map of toolUseId -> tool_result for compact summaries
+  const toolResults = new Map<string, AgentMessage>();
+  for (const msg of messages) {
+    if (msg.type === 'tool_result') {
+      const tr = msg.content as ToolResultContent;
+      toolResults.set(tr.toolUseId, msg);
+    }
+  }
+
+  for (const msg of messages) {
+    switch (msg.type) {
+      case 'text': {
+        const text = (msg.content as TextContent).text;
+        currentTurn.assistantText += (currentTurn.assistantText ? '\n' : '') + text;
+        break;
+      }
+      case 'tool_call': {
+        const tc = msg.content as ToolCallContent;
+        const result = toolResults.get(tc.toolUseId);
+        const summary = compactToolSummary(tc, result);
+        currentTurn.toolSummaries.push(summary);
+        break;
+      }
+      case 'cost': {
+        // End of turn — finalize and start new one
+        if (currentTurn.assistantText || currentTurn.toolSummaries.length > 0) {
+          const serialized = serializeTurn(turnIndex, currentTurn);
+          turns.push({
+            index: turnIndex,
+            userPrompt: currentTurn.userPrompt,
+            assistantText: currentTurn.assistantText,
+            toolSummaries: currentTurn.toolSummaries,
+            estimatedTokens: estimateTokens(serialized),
+          });
+          turnIndex++;
+        }
+        currentTurn = { userPrompt: '', assistantText: '', toolSummaries: [], messages: [] };
+        break;
+      }
+      // Skip init, thinking, compaction, status, etc.
+    }
+  }
+
+  // Finalize last turn if it has content (session may not have ended with cost)
+  if (currentTurn.assistantText || currentTurn.toolSummaries.length > 0) {
+    const serialized = serializeTurn(turnIndex, currentTurn);
+    turns.push({
+      index: turnIndex,
+      userPrompt: currentTurn.userPrompt,
+      assistantText: currentTurn.assistantText,
+      toolSummaries: currentTurn.toolSummaries,
+      estimatedTokens: estimateTokens(serialized),
+    });
+  }
+
+  return turns;
+}
+
+/** Compact a tool_call + optional tool_result into a short summary */
+function compactToolSummary(tc: ToolCallContent, result?: AgentMessage): string {
+  const name = tc.name;
+  const input = tc.input as Record<string, unknown> | undefined;
+
+  // Extract key info based on tool type
+  let detail = '';
+  if (input) {
+    if (name === 'Read' || name === 'read_file') {
+      detail = ` ${input.file_path ?? input.path ?? ''}`;
+    } else if (name === 'Write' || name === 'write_file') {
+      const path = input.file_path ?? input.path ?? '';
+      const content = typeof input.content === 'string' ? input.content : '';
+      detail = ` ${path} → ${content.split('\n').length} lines`;
+    } else if (name === 'Edit' || name === 'edit_file') {
+      detail = ` ${input.file_path ?? input.path ?? ''}`;
+    } else if (name === 'Bash' || name === 'execute_bash') {
+      const cmd = typeof input.command === 'string' ? input.command.slice(0, 80) : '';
+      detail = ` \`${cmd}\``;
+    } else if (name === 'Glob' || name === 'Grep') {
+      const pattern = input.pattern ?? '';
+      detail = ` ${pattern}`;
+    }
+  }
+
+  // Add compact result indicator
+  let resultNote = '';
+  if (result) {
+    const output = result.content as ToolResultContent;
+    const outStr = typeof output.output === 'string' ? output.output : JSON.stringify(output.output ?? '');
+    const lineCount = outStr.split('\n').length;
+    resultNote = ` → ${lineCount} lines`;
+  }
+
+  return `[${name}${detail}${resultNote}]`;
+}
+
+/** Serialize a single turn to observation-masked text */
+function serializeTurn(
+  index: number,
+  turn: { userPrompt: string; assistantText: string; toolSummaries: string[] },
+): string {
+  const parts: string[] = [];
+
+  if (turn.userPrompt) {
+    parts.push(`[Turn ${index + 1}] User: "${turn.userPrompt}"`);
+  }
+  if (turn.assistantText) {
+    // Preserve assistant reasoning in full — research consensus (JetBrains NeurIPS 2025,
+    // SWE-agent, OpenDev ACC) is that agent reasoning must never be truncated;
+    // only tool outputs (observations) get masked
+    parts.push(`[Turn ${index + 1}] Assistant: "${turn.assistantText}"`);
+  }
+  if (turn.toolSummaries.length > 0) {
+    parts.push(`[Turn ${index + 1}] Tools: ${turn.toolSummaries.join(' ')}`);
+  }
+
+  return parts.join('\n');
+}
+
+/**
+ * Serialize turns into anchor text for system prompt re-injection.
+ * Respects token budget — stops adding turns when budget would be exceeded.
+ */
+export function serializeAnchorsForInjection(
+  turns: TurnGroup[],
+  tokenBudget: number,
+  projectName?: string,
+): string {
+  const header = `<session-anchors${projectName ? ` project="${projectName}"` : ''}>`;
+  const footer = '</session-anchors>';
+  const headerTokens = estimateTokens(header + '\n' + footer);
+
+  let remaining = tokenBudget - headerTokens;
+  const lines: string[] = [header];
+  lines.push('Key decisions and context from earlier in this project:');
+  lines.push('');
+
+  for (const turn of turns) {
+    const text = serializeTurn(turn.index, turn);
+    const tokens = estimateTokens(text);
+    if (tokens > remaining) break;
+    lines.push(text);
+    lines.push('');
+    remaining -= tokens;
+  }
+
+  lines.push(footer);
+  return lines.join('\n');
+}
+
+/**
+ * Select turns for auto-anchoring on first compaction.
+ * Takes first N turns up to token budget, using the session's original prompt as turn 0 user prompt.
+ */
+export function selectAutoAnchors(
+  messages: AgentMessage[],
+  sessionPrompt: string,
+  maxTurns: number,
+  tokenBudget: number,
+): { turns: TurnGroup[]; totalTokens: number } {
+  const allTurns = groupMessagesIntoTurns(messages);
+
+  // Inject session prompt as user prompt for turn 0
+  if (allTurns.length > 0 && !allTurns[0].userPrompt) {
+    allTurns[0].userPrompt = sessionPrompt;
+  }
+
+  const selected: TurnGroup[] = [];
+  let totalTokens = 0;
+
+  for (const turn of allTurns) {
+    if (selected.length >= maxTurns) break;
+    if (totalTokens + turn.estimatedTokens > tokenBudget) break;
+    selected.push(turn);
+    totalTokens += turn.estimatedTokens;
+  }
+
+  return { turns: selected, totalTokens };
+}
diff --git a/v2/src/lib/utils/attention-scorer.test.ts b/v2/src/lib/utils/attention-scorer.test.ts
new file mode 100644
index 0000000..d5dc4c6
--- /dev/null
+++ b/v2/src/lib/utils/attention-scorer.test.ts
@@ -0,0 +1,201 @@
+import { describe, it, expect } from 'vitest';
+import { scoreAttention, type AttentionInput } from './attention-scorer';
+
+function makeInput(overrides: Partial<AttentionInput> = {}): AttentionInput {
+  return {
+    sessionStatus: undefined,
+    sessionError: undefined,
+    activityState: 'inactive',
+    idleDurationMs: 0,
+    contextPressure: null,
+    fileConflictCount: 0,
+    externalConflictCount: 0,
+    ...overrides,
+  };
+}
+
+describe('scoreAttention', () => {
+  it('returns zero score when no attention needed', () => {
+    const result = scoreAttention(makeInput());
+    expect(result.score).toBe(0);
+    expect(result.reason).toBeNull();
+  });
+
+  it('scores error highest after stalled', () => {
+    const result = scoreAttention(makeInput({
+      sessionStatus: 'error',
+      sessionError: 'Connection refused',
+    }));
+    expect(result.score).toBe(90);
+    expect(result.reason).toContain('Connection refused');
+  });
+
+  it('truncates long error messages to 60 chars', () => {
+    const longError = 'A'.repeat(100);
+    const result = scoreAttention(makeInput({
+      sessionStatus: 'error',
+      sessionError: longError,
+    }));
+    expect(result.reason!.length).toBeLessThanOrEqual(68); // "Error: " + 60 chars + null safety
+  });
+
+  it('scores stalled at 100', () => {
+    const result = scoreAttention(makeInput({
+      activityState: 'stalled',
+      idleDurationMs: 20 * 60_000,
+    }));
+    expect(result.score).toBe(100);
+    expect(result.reason).toContain('20 min');
+  });
+
+  it('scores critical context pressure (>90%) at 80', () => {
+    const result = scoreAttention(makeInput({
+      activityState: 'running',
+      contextPressure: 0.95,
+    }));
+    expect(result.score).toBe(80);
+    expect(result.reason).toContain('95%');
+  });
+
+  it('scores file conflicts at 70', () => {
+    const result = scoreAttention(makeInput({
+      activityState: 'running',
+      fileConflictCount: 3,
+    }));
+    expect(result.score).toBe(70);
+    expect(result.reason).toContain('3 file conflicts');
+  });
+
+  it('includes external conflict note when present', () => {
+    const result = scoreAttention(makeInput({
+      activityState: 'running',
+      fileConflictCount: 2,
+      externalConflictCount: 1,
+    }));
+    expect(result.reason).toContain('(1 external)');
+  });
+
+  it('scores high context pressure (>75%) at 40', () => {
+    const result = scoreAttention(makeInput({
+      activityState: 'running',
+      contextPressure: 0.80,
+    }));
+    expect(result.score).toBe(40);
+    expect(result.reason).toContain('80%');
+  });
+
+  it('error takes priority over stalled', () => {
+    const result = scoreAttention(makeInput({
+      sessionStatus: 'error',
+      sessionError: 'fail',
+      activityState: 'stalled',
+      idleDurationMs: 30 * 60_000,
+    }));
+    expect(result.score).toBe(90);
+  });
+
+  it('stalled takes priority over context pressure', () => {
+    const result = scoreAttention(makeInput({
+      activityState: 'stalled',
+      idleDurationMs: 20 * 60_000,
+      contextPressure: 0.95,
+    }));
+    expect(result.score).toBe(100);
+  });
+
+  it('critical context takes priority over file conflicts', () => {
+    const result = scoreAttention(makeInput({
+      activityState: 'running',
+      contextPressure: 0.92,
+      fileConflictCount: 5,
+    }));
+    expect(result.score).toBe(80);
+  });
+
+  it('file conflicts take priority over high context', () => {
+    const result = scoreAttention(makeInput({
+      activityState: 'running',
+      contextPressure: 0.78,
+      fileConflictCount: 1,
+    }));
+    expect(result.score).toBe(70);
+  });
+
+  it('singular file conflict uses singular grammar', () => {
+    const result = scoreAttention(makeInput({
+      activityState: 'running',
+      fileConflictCount: 1,
+    }));
+    expect(result.reason).toBe('1 file conflict');
+  });
+
+  it('handles undefined session error gracefully', () => {
+    const result = scoreAttention(makeInput({
+      sessionStatus: 'error',
+      sessionError: undefined,
+    }));
+    expect(result.reason).toContain('Unknown');
+  });
+
+  // --- Review queue depth scoring ---
+
+  it('scores review queue depth at 10 per task', () => {
+    const result = scoreAttention(makeInput({
+      activityState: 'running',
+      reviewQueueDepth: 3,
+    }));
+    expect(result.score).toBe(30);
+    expect(result.reason).toContain('3 tasks awaiting review');
+  });
+
+  it('caps review queue score at 50', () => {
+    const result = scoreAttention(makeInput({
+      activityState: 'running',
+      reviewQueueDepth: 8,
+    }));
+    expect(result.score).toBe(50);
+    expect(result.reason).toContain('8 tasks');
+  });
+
+  it('uses singular grammar for 1 review task', () => {
+    const result = scoreAttention(makeInput({
+      activityState: 'running',
+      reviewQueueDepth: 1,
+    }));
+    expect(result.score).toBe(10);
+    expect(result.reason).toBe('1 task awaiting review');
+  });
+
+  it('review queue has lower priority than file conflicts', () => {
+    const result = scoreAttention(makeInput({
+      activityState: 'running',
+      fileConflictCount: 2,
+      reviewQueueDepth: 5,
+    }));
+    expect(result.score).toBe(70); // file conflicts win
+  });
+
+  it('review queue has higher priority than context high', () => {
+    const result = scoreAttention(makeInput({
+      activityState: 'running',
+      contextPressure: 0.80,
+      reviewQueueDepth: 2,
+    }));
+    expect(result.score).toBe(20); // review queue wins over context high (40)
+  });
+
+  it('ignores review queue when depth is 0', () => {
+    const result = scoreAttention(makeInput({
+      activityState: 'running',
+      reviewQueueDepth: 0,
+    }));
+    expect(result.score).toBe(0);
+  });
+
+  it('ignores review queue when undefined', () => {
+    const result = scoreAttention(makeInput({
+      activityState: 'running',
+    }));
+    expect(result.score).toBe(0);
+  });
+});
diff --git a/v2/src/lib/utils/attention-scorer.ts b/v2/src/lib/utils/attention-scorer.ts
new file mode 100644
index 0000000..daee32c
--- /dev/null
+++ b/v2/src/lib/utils/attention-scorer.ts
@@ -0,0 +1,82 @@
+// Attention scoring — pure function extracted from health store
+// Determines which project needs attention most urgently
+
+import type { ActivityState } from '../stores/health.svelte';
+
+// Attention score weights (higher = more urgent)
+const SCORE_STALLED = 100;
+const SCORE_ERROR = 90;
+const SCORE_CONTEXT_CRITICAL = 80; // >90% context
+const SCORE_FILE_CONFLICT = 70;
+const SCORE_CONTEXT_HIGH = 40; // >75% context
+
+// Review queue scoring: 10pts per stale review, capped at 50
+const SCORE_REVIEW_PER_TASK = 10;
+const SCORE_REVIEW_CAP = 50;
+
+export interface AttentionInput {
+  sessionStatus: string | undefined;
+  sessionError: string | undefined;
+  activityState: ActivityState;
+  idleDurationMs: number;
+  contextPressure: number | null;
+  fileConflictCount: number;
+  externalConflictCount: number;
+  /** Number of tasks in 'review' status (for reviewer agents) */
+  reviewQueueDepth?: number;
+}
+
+export interface AttentionResult {
+  score: number;
+  reason: string | null;
+}
+
+/** Score how urgently a project needs human attention. Highest-priority signal wins. */
+export function scoreAttention(input: AttentionInput): AttentionResult {
+  if (input.sessionStatus === 'error') {
+    return {
+      score: SCORE_ERROR,
+      reason: `Error: ${input.sessionError?.slice(0, 60) ?? 'Unknown'}`,
+    };
+  }
+
+  if (input.activityState === 'stalled') {
+    const mins = Math.floor(input.idleDurationMs / 60_000);
+    return {
+      score: SCORE_STALLED,
+      reason: `Stalled — ${mins} min since last activity`,
+    };
+  }
+
+  if (input.contextPressure !== null && input.contextPressure > 0.9) {
+    return {
+      score: SCORE_CONTEXT_CRITICAL,
+      reason: `Context ${Math.round(input.contextPressure * 100)}% — near limit`,
+    };
+  }
+
+  if (input.fileConflictCount > 0) {
+    const extNote = input.externalConflictCount > 0 ? ` (${input.externalConflictCount} external)` : '';
+    return {
+      score: SCORE_FILE_CONFLICT,
+      reason: `${input.fileConflictCount} file conflict${input.fileConflictCount > 1 ? 's' : ''}${extNote}`,
+    };
+  }
+
+  if (input.reviewQueueDepth && input.reviewQueueDepth > 0) {
+    const score = Math.min(input.reviewQueueDepth * SCORE_REVIEW_PER_TASK, SCORE_REVIEW_CAP);
+    return {
+      score,
+      reason: `${input.reviewQueueDepth} task${input.reviewQueueDepth > 1 ? 's' : ''} awaiting review`,
+    };
+  }
+
+  if (input.contextPressure !== null && input.contextPressure > 0.75) {
+    return {
+      score: SCORE_CONTEXT_HIGH,
+      reason: `Context ${Math.round(input.contextPressure * 100)}%`,
+    };
+  }
+
+  return { score: 0, reason: null };
+}
diff --git a/v2/src/lib/utils/auto-anchoring.ts b/v2/src/lib/utils/auto-anchoring.ts
new file mode 100644
index 0000000..604e5c0
--- /dev/null
+++ b/v2/src/lib/utils/auto-anchoring.ts
@@ -0,0 +1,52 @@
+// Auto-anchoring — creates session anchors on first compaction event
+// Extracted from agent-dispatcher.ts (SRP: anchor creation concern)
+
+import type { ProjectId as ProjectIdType } from '../types/ids';
+import type { AgentMessage } from '../adapters/claude-messages';
+import type { SessionAnchor } from '../types/anchors';
+import { getAnchorSettings, addAnchors } from '../stores/anchors.svelte';
+import { selectAutoAnchors, serializeAnchorsForInjection } from '../utils/anchor-serializer';
+import { getEnabledProjects } from '../stores/workspace.svelte';
+import { tel } from '../adapters/telemetry-bridge';
+import { notify } from '../stores/notifications.svelte';
+
+/** Auto-anchor first N turns on first compaction event for a project */
+export function triggerAutoAnchor(
+  projectId: ProjectIdType,
+  messages: AgentMessage[],
+  sessionPrompt: string,
+): void {
+  const project = getEnabledProjects().find(p => p.id === projectId);
+  const settings = getAnchorSettings(project?.anchorBudgetScale);
+  const { turns, totalTokens } = selectAutoAnchors(
+    messages,
+    sessionPrompt,
+    settings.anchorTurns,
+    settings.anchorTokenBudget,
+  );
+
+  if (turns.length === 0) return;
+
+  const nowSecs = Math.floor(Date.now() / 1000);
+  const anchors: SessionAnchor[] = turns.map((turn) => {
+    const content = serializeAnchorsForInjection([turn], settings.anchorTokenBudget);
+    return {
+      id: crypto.randomUUID(),
+      projectId,
+      messageId: `turn-${turn.index}`,
+      anchorType: 'auto' as const,
+      content: content,
+      estimatedTokens: turn.estimatedTokens,
+      turnIndex: turn.index,
+      createdAt: nowSecs,
+    };
+  });
+
+  addAnchors(projectId, anchors);
+  tel.info('auto_anchor_created', {
+    projectId,
+    anchorCount: anchors.length,
+    totalTokens,
+  });
+  notify('info', `Anchored ${anchors.length} turns (${totalTokens} tokens) for context preservation`);
+}
diff --git a/v2/src/lib/utils/detach.ts b/v2/src/lib/utils/detach.ts
new file mode 100644
index 0000000..0c57561
--- /dev/null
+++ b/v2/src/lib/utils/detach.ts
@@ -0,0 +1,68 @@
+// Detachable pane support — opens panes in separate OS windows
+// Uses Tauri's WebviewWindow API
+
+import { WebviewWindow } from '@tauri-apps/api/webviewWindow';
+import type { Pane } from '../stores/layout.svelte';
+
+let detachCounter = 0;
+
+export async function detachPane(pane: Pane): Promise<void> {
+  detachCounter++;
+  const label = `detached-${detachCounter}`;
+
+  const params = new URLSearchParams({
+    detached: 'true',
+    type: pane.type,
+    title: pane.title,
+  });
+
+  if (pane.shell) params.set('shell', pane.shell);
+  if (pane.cwd) params.set('cwd', pane.cwd);
+  if (pane.args) params.set('args', JSON.stringify(pane.args));
+  if (pane.type === 'agent') params.set('sessionId', pane.id);
+
+  const webview = new WebviewWindow(label, {
+    url: `index.html?${params.toString()}`,
+    title: `BTerminal — ${pane.title}`,
+    width: 800,
+    height: 600,
+    decorations: true,
+    resizable: true,
+  });
+
+  // Wait for the window to be created
+  await webview.once('tauri://created', () => {
+    // Window created successfully
+  });
+
+  await webview.once('tauri://error', (e) => {
+    console.error('Failed to create detached window:', e);
+  });
+}
+
+export function isDetachedMode(): boolean {
+  const params = new URLSearchParams(window.location.search);
+  return params.get('detached') === 'true';
+}
+
+export function getDetachedConfig(): {
+  type: string;
+  title: string;
+  shell?: string;
+  cwd?: string;
+  args?: string[];
+  sessionId?: string;
+} | null {
+  const params = new URLSearchParams(window.location.search);
+  if (params.get('detached') !== 'true') return null;
+
+  const argsStr = params.get('args');
+  return {
+    type: params.get('type') ?? 'terminal',
+    title: params.get('title') ?? 'Detached',
+    shell: params.get('shell') ?? undefined,
+    cwd: params.get('cwd') ?? undefined,
+    args: argsStr ? JSON.parse(argsStr) : undefined,
+    sessionId: params.get('sessionId') ?? undefined,
+  };
+}
diff --git a/v2/src/lib/utils/error-classifier.test.ts b/v2/src/lib/utils/error-classifier.test.ts
new file mode 100644
index 0000000..5e79e0e
--- /dev/null
+++ b/v2/src/lib/utils/error-classifier.test.ts
@@ -0,0 +1,120 @@
+import { describe, it, expect } from 'vitest';
+import { classifyError, type ApiErrorType } from './error-classifier';
+
+describe('classifyError', () => {
+  // --- Rate limit ---
+  it('classifies "rate_limit_error" as rate_limit', () => {
+    const result = classifyError('rate_limit_error: Too many requests');
+    expect(result.type).toBe('rate_limit');
+    expect(result.retryable).toBe(true);
+    expect(result.retryDelaySec).toBeGreaterThan(0);
+  });
+
+  it('classifies "429" as rate_limit', () => {
+    const result = classifyError('HTTP 429 Too Many Requests');
+    expect(result.type).toBe('rate_limit');
+  });
+
+  it('classifies "too many requests" as rate_limit', () => {
+    const result = classifyError('Error: too many requests, please slow down');
+    expect(result.type).toBe('rate_limit');
+  });
+
+  it('classifies "throttled" as rate_limit', () => {
+    const result = classifyError('Request throttled by API');
+    expect(result.type).toBe('rate_limit');
+  });
+
+  // --- Auth ---
+  it('classifies "invalid_api_key" as auth', () => {
+    const result = classifyError('invalid_api_key: The provided API key is invalid');
+    expect(result.type).toBe('auth');
+    expect(result.retryable).toBe(false);
+  });
+
+  it('classifies "401" as auth', () => {
+    const result = classifyError('HTTP 401 Unauthorized');
+    expect(result.type).toBe('auth');
+  });
+
+  it('classifies "authentication failed" as auth', () => {
+    const result = classifyError('Authentication failed for this request');
+    expect(result.type).toBe('auth');
+  });
+
+  // --- Quota ---
+  it('classifies "insufficient_quota" as quota', () => {
+    const result = classifyError('insufficient_quota: You have exceeded your usage limit');
+    expect(result.type).toBe('quota');
+    expect(result.retryable).toBe(false);
+  });
+
+  it('classifies "billing" as quota', () => {
+    const result = classifyError('Error: billing issue with your account');
+    expect(result.type).toBe('quota');
+  });
+
+  it('classifies "credit" as quota', () => {
+    const result = classifyError('No remaining credit on your account');
+    expect(result.type).toBe('quota');
+  });
+
+  // --- Overloaded ---
+  it('classifies "overloaded" as overloaded', () => {
+    const result = classifyError('The API is temporarily overloaded');
+    expect(result.type).toBe('overloaded');
+    expect(result.retryable).toBe(true);
+  });
+
+  it('classifies "503" as overloaded', () => {
+    const result = classifyError('HTTP 503 Service Unavailable');
+    expect(result.type).toBe('overloaded');
+  });
+
+  // --- Network ---
+  it('classifies "ECONNREFUSED" as network', () => {
+    const result = classifyError('connect ECONNREFUSED 127.0.0.1:443');
+    expect(result.type).toBe('network');
+    expect(result.retryable).toBe(true);
+  });
+
+  it('classifies "ETIMEDOUT" as network', () => {
+    const result = classifyError('connect ETIMEDOUT');
+    expect(result.type).toBe('network');
+  });
+
+  it('classifies "fetch failed" as network', () => {
+    const result = classifyError('TypeError: fetch failed');
+    expect(result.type).toBe('network');
+  });
+
+  // --- Unknown ---
+  it('classifies unrecognized errors as unknown', () => {
+    const result = classifyError('Something weird happened');
+    expect(result.type).toBe('unknown');
+    expect(result.retryable).toBe(false);
+    expect(result.message).toBe('Something weird happened');
+  });
+
+  it('preserves original message for unknown errors', () => {
+    const msg = 'Internal server error: null pointer';
+    const result = classifyError(msg);
+    expect(result.message).toBe(msg);
+  });
+
+  // --- Message quality ---
+  it('provides actionable messages for rate_limit', () => {
+    const result = classifyError('rate_limit_error');
+    expect(result.message).toContain('Rate limited');
+  });
+
+  it('provides actionable messages for auth', () => {
+    const result = classifyError('invalid_api_key');
+    expect(result.message).toContain('Settings');
+  });
+
+  it('provides actionable messages for quota', () => {
+    const result = classifyError('insufficient_quota');
+    expect(result.message).toContain('billing');
+  });
+});
diff --git a/v2/src/lib/utils/error-classifier.ts b/v2/src/lib/utils/error-classifier.ts
new file mode 100644
index 0000000..f8cc48f
--- /dev/null
+++ b/v2/src/lib/utils/error-classifier.ts
@@ -0,0 +1,121 @@
+// Error classifier — categorizes API errors for actionable user messaging
+
+export type ApiErrorType =
+  | 'rate_limit'
+  | 'auth'
+  | 'quota'
+  | 'overloaded'
+  | 'network'
+  | 'unknown';
+
+export interface ClassifiedError {
+  type: ApiErrorType;
+  message: string;
+  retryable: boolean;
+  /** Suggested retry delay in seconds (0 = no retry) */
+  retryDelaySec: number;
+}
+
+const RATE_LIMIT_PATTERNS = [
+  /rate.?limit/i,
+  /429/,
+  /too many requests/i,
+  /rate_limit_error/i,
+  /throttl/i,
+];
+
+const AUTH_PATTERNS = [
+  /401/,
+  /invalid.?api.?key/i,
+  /authentication/i,
+  /unauthorized/i,
+  /invalid.?x-api-key/i,
+  /api_key/i,
+];
+
+const QUOTA_PATTERNS = [
+  /insufficient.?quota/i,
+  /billing/i,
+  /payment/i,
+  /exceeded.*quota/i,
+  /credit/i,
+  /usage.?limit/i,
+];
+
+const OVERLOADED_PATTERNS = [
+  /overloaded/i,
+  /503/,
+  /service.?unavailable/i,
+  /capacity/i,
+  /busy/i,
+];
+
+const NETWORK_PATTERNS = [
+  /ECONNREFUSED/,
+  /ECONNRESET/,
+  /ETIMEDOUT/,
+  /network/i,
+  /fetch.?failed/i,
+  /dns/i,
+];
+
+function matchesAny(text: string, patterns: RegExp[]): boolean {
+  return patterns.some(p => p.test(text));
+}
+
+/**
+ * Classify an error message into an actionable category.
+ */
+export function classifyError(errorMessage: string): ClassifiedError {
+  if (matchesAny(errorMessage, RATE_LIMIT_PATTERNS)) {
+    return {
+      type: 'rate_limit',
+      message: 'Rate limited. The API will auto-retry shortly.',
+      retryable: true,
+      retryDelaySec: 30,
+    };
+  }
+
+  if (matchesAny(errorMessage, AUTH_PATTERNS)) {
+    return {
+      type: 'auth',
+      message: 'API key invalid or expired. Check Settings.',
+      retryable: false,
+      retryDelaySec: 0,
+    };
+  }
+
+  if (matchesAny(errorMessage, QUOTA_PATTERNS)) {
+    return {
+      type: 'quota',
+      message: 'API quota exceeded. Check your billing.',
+      retryable: false,
+      retryDelaySec: 0,
+    };
+  }
+
+  if (matchesAny(errorMessage, OVERLOADED_PATTERNS)) {
+    return {
+      type: 'overloaded',
+      message: 'API overloaded. Retrying shortly...',
+      retryable: true,
+      retryDelaySec: 15,
+    };
+  }
+
+  if (matchesAny(errorMessage, NETWORK_PATTERNS)) {
+    return {
+      type: 'network',
+      message: 'Network error. Check your connection.',
+      retryable: true,
+      retryDelaySec: 5,
+    };
+  }
+
+  return {
+    type: 'unknown',
+    message: errorMessage,
+    retryable: false,
+    retryDelaySec: 0,
+  };
+}
diff --git a/v2/src/lib/utils/highlight.ts b/v2/src/lib/utils/highlight.ts
new file mode 100644
index 0000000..4b15697
--- /dev/null
+++ b/v2/src/lib/utils/highlight.ts
@@ -0,0 +1,51 @@
+import { createHighlighter, type Highlighter } from 'shiki';
+
+let highlighter: Highlighter | null = null;
+let initPromise: Promise<Highlighter> | null = null;
+
+// Use catppuccin-mocha theme (bundled with shiki)
+const THEME = 'catppuccin-mocha';
+
+// Common languages to preload
+const LANGS = [
+  'typescript', 'javascript', 'rust', 'python', 'bash',
+  'json', 'html', 'css', 'svelte', 'sql', 'yaml', 'toml', 'markdown',
+];
+
+export async function getHighlighter(): Promise<Highlighter> {
+  if (highlighter) return highlighter;
+  if (initPromise) return initPromise;
+
+  initPromise = createHighlighter({
+    themes: [THEME],
+    langs: LANGS,
+  });
+
+  highlighter = await initPromise;
+  return highlighter;
+}
+
+export function highlightCode(code: string, lang: string): string {
+  if (!highlighter) return escapeHtml(code);
+
+  try {
+    const loadedLangs = highlighter.getLoadedLanguages();
+    if (!loadedLangs.includes(lang as any)) {
+      return escapeHtml(code);
+    }
+
+    return highlighter.codeToHtml(code, {
+      lang,
+      theme: THEME,
+    });
+  } catch {
+    return escapeHtml(code);
+  }
+}
+
+export function escapeHtml(text: string): string {
+  return text
+    .replace(/&/g, '&amp;')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;');
+}
diff --git a/v2/src/lib/utils/plantuml-encode.test.ts b/v2/src/lib/utils/plantuml-encode.test.ts
new file mode 100644
index 0000000..ef8d1d6
--- /dev/null
+++ b/v2/src/lib/utils/plantuml-encode.test.ts
@@ -0,0 +1,67 @@
+import { describe, it, expect } from 'vitest';
+
+// ---- REGRESSION: PlantUML hex encoding ----
+// Bug: ArchitectureTab had a broken encoding chain (rawDeflate returned input unchanged,
+// encode64 was hex encoding masquerading as base64). Fixed by collapsing to single
+// plantumlEncode function using ~h hex prefix (plantuml.com text encoding standard).
+//
+// This test validates the encoding algorithm matches what ArchitectureTab.svelte uses.
+
+/** Reimplementation of the plantumlEncode function from ArchitectureTab.svelte */
+function plantumlEncode(text: string): string {
+  const bytes = unescape(encodeURIComponent(text));
+  let hex = '~h';
+  for (let i = 0; i < bytes.length; i++) {
+    hex += bytes.charCodeAt(i).toString(16).padStart(2, '0');
+  }
+  return hex;
+}
+
+describe('plantumlEncode', () => {
+  it('produces ~h prefix for hex encoding', () => {
+    const result = plantumlEncode('@startuml\n@enduml');
+    expect(result.startsWith('~h')).toBe(true);
+  });
+
+  it('encodes ASCII correctly', () => {
+    const result = plantumlEncode('AB');
+    // A=0x41, B=0x42
+    expect(result).toBe('~h4142');
+  });
+
+  it('encodes simple PlantUML source', () => {
+    const result = plantumlEncode('@startuml\n@enduml');
+    // Each character maps to its hex code
+    const expected = '~h' + Array.from('@startuml\n@enduml')
+      .map(c => c.charCodeAt(0).toString(16).padStart(2, '0'))
+      .join('');
+    expect(result).toBe(expected);
+  });
+
+  it('handles Unicode characters', () => {
+    // UTF-8 multi-byte: é = 0xc3 0xa9
+    const result = plantumlEncode('café');
+    expect(result.startsWith('~h')).toBe(true);
+    // c=63, a=61, f=66, é=c3a9
+    expect(result).toBe('~h636166c3a9');
+  });
+
+  it('handles empty string', () => {
+    expect(plantumlEncode('')).toBe('~h');
+  });
+
+  it('produces valid URL-safe output (no special chars beyond hex digits)', () => {
+    const result = plantumlEncode('@startuml\ntitle Test\nA -> B\n@enduml');
+    // After ~h prefix, only hex digits [0-9a-f]
+    const hexPart = result.slice(2);
+    expect(hexPart).toMatch(/^[0-9a-f]+$/);
+  });
+
+  it('generates correct URL for plantuml.com', () => {
+    const source = '@startuml\nA -> B\n@enduml';
+    const encoded = plantumlEncode(source);
+    const url = `https://www.plantuml.com/plantuml/svg/${encoded}`;
+    expect(url).toContain('plantuml.com/plantuml/svg/~h');
+    expect(url.length).toBeGreaterThan(50);
+  });
+});
diff --git a/v2/src/lib/utils/session-persistence.ts b/v2/src/lib/utils/session-persistence.ts
new file mode 100644
index 0000000..da1825f
--- /dev/null
+++ b/v2/src/lib/utils/session-persistence.ts
@@ -0,0 +1,118 @@
+// Session persistence — maps session IDs to projects/providers and persists state to SQLite
+// Extracted from agent-dispatcher.ts (SRP: persistence concern)
+
+import type { SessionId as SessionIdType, ProjectId as ProjectIdType } from '../types/ids';
+import type { ProviderId } from '../providers/types';
+import { getAgentSession } from '../stores/agents.svelte';
+import {
+  saveProjectAgentState,
+  saveAgentMessages,
+  saveSessionMetric,
+  type AgentMessageRecord,
+} from '../adapters/groups-bridge';
+
+// Map sessionId -> projectId for persistence routing
+const sessionProjectMap = new Map<SessionIdType, ProjectIdType>();
+
+// Map sessionId -> provider for message adapter routing
+const sessionProviderMap = new Map<SessionIdType, ProviderId>();
+
+// Map sessionId -> start timestamp for metrics
+const sessionStartTimes = new Map<SessionIdType, number>();
+
+// In-flight persistence counter — prevents teardown from racing with async saves
+let pendingPersistCount = 0;
+
+export function registerSessionProject(sessionId: SessionIdType, projectId: ProjectIdType, provider: ProviderId = 'claude'): void {
+  sessionProjectMap.set(sessionId, projectId);
+  sessionProviderMap.set(sessionId, provider);
+}
+
+export function getSessionProjectId(sessionId: SessionIdType): ProjectIdType | undefined {
+  return sessionProjectMap.get(sessionId);
+}
+
+export function getSessionProvider(sessionId: SessionIdType): ProviderId {
+  return sessionProviderMap.get(sessionId) ?? 'claude';
+}
+
+export function recordSessionStart(sessionId: SessionIdType): void {
+  sessionStartTimes.set(sessionId, Date.now());
+}
+
+/** Wait until all in-flight persistence operations complete */
+export async function waitForPendingPersistence(): Promise<void> {
+  while (pendingPersistCount > 0) {
+    await new Promise(r => setTimeout(r, 10));
+  }
+}
+
+/** Persist session state + messages to SQLite for the project that owns this session */
+export async function persistSessionForProject(sessionId: SessionIdType): Promise<void> {
+  const projectId = sessionProjectMap.get(sessionId);
+  if (!projectId) return; // Not a project-scoped session
+
+  const session = getAgentSession(sessionId);
+  if (!session) return;
+
+  pendingPersistCount++;
+  try {
+    // Save agent state
+    await saveProjectAgentState({
+      project_id: projectId,
+      last_session_id: sessionId,
+      sdk_session_id: session.sdkSessionId ?? null,
+      status: session.status,
+      cost_usd: session.costUsd,
+      input_tokens: session.inputTokens,
+      output_tokens: session.outputTokens,
+      last_prompt: session.prompt,
+      updated_at: Math.floor(Date.now() / 1000),
+    });
+
+    // Save messages (use seconds to match session.rs convention)
+    const nowSecs = Math.floor(Date.now() / 1000);
+    const records: AgentMessageRecord[] = session.messages.map((m, i) => ({
+      id: i,
+      session_id: sessionId,
+      project_id: projectId,
+      sdk_session_id: session.sdkSessionId ?? null,
+      message_type: m.type,
+      content: JSON.stringify(m.content),
+      parent_id: m.parentId ?? null,
+      created_at: nowSecs,
+    }));
+
+    if (records.length > 0) {
+      await saveAgentMessages(sessionId, projectId, session.sdkSessionId, records);
+    }
+
+    // Persist session metric for historical tracking
+    const toolCallCount = session.messages.filter(m => m.type === 'tool_call').length;
+    const startTime = sessionStartTimes.get(sessionId) ?? Math.floor(Date.now() / 1000);
+    await saveSessionMetric({
+      project_id: projectId,
+      session_id: sessionId,
+      start_time: Math.floor(startTime / 1000),
+      end_time: nowSecs,
+      peak_tokens: session.inputTokens + session.outputTokens,
+      turn_count: session.numTurns,
+      tool_call_count: toolCallCount,
+      cost_usd: session.costUsd,
+      model: session.model ?? null,
+      status: session.status,
+      error_message: session.error ?? null,
+    });
+  } catch (e) {
+    console.warn('Failed to persist agent session:', e);
+  } finally {
+    pendingPersistCount--;
+  }
+}
+
+/** Clear all session maps — called on dispatcher shutdown */
+export function clearSessionMaps(): void {
+  sessionProjectMap.clear();
+  sessionProviderMap.clear();
+  sessionStartTimes.clear();
+}
diff --git a/v2/src/lib/utils/subagent-router.ts b/v2/src/lib/utils/subagent-router.ts
new file mode 100644
index 0000000..5576a15
--- /dev/null
+++ b/v2/src/lib/utils/subagent-router.ts
@@ -0,0 +1,78 @@
+// Subagent routing — manages subagent pane creation and message routing
+// Extracted from agent-dispatcher.ts (SRP: subagent lifecycle concern)
+
+import type { ToolCallContent } from '../adapters/claude-messages';
+import {
+  createAgentSession,
+  updateAgentStatus,
+  findChildByToolUseId,
+} from '../stores/agents.svelte';
+import { addPane, getPanes } from '../stores/layout.svelte';
+import { getSessionProjectId } from './session-persistence';
+
+// Tool names that indicate a subagent spawn
+const SUBAGENT_TOOL_NAMES = new Set(['Agent', 'Task', 'dispatch_agent']);
+
+// Map toolUseId -> child session pane id for routing
+const toolUseToChildPane = new Map<string, string>();
+
+/** Check if a tool call is a subagent spawn */
+export function isSubagentToolCall(toolName: string): boolean {
+  return SUBAGENT_TOOL_NAMES.has(toolName);
+}
+
+/** Get the child pane ID for a given toolUseId */
+export function getChildPaneId(toolUseId: string): string | undefined {
+  return toolUseToChildPane.get(toolUseId);
+}
+
+/** Check if a toolUseId has been mapped to a child pane */
+export function hasChildPane(toolUseId: string): boolean {
+  return toolUseToChildPane.has(toolUseId);
+}
+
+export function spawnSubagentPane(parentSessionId: string, tc: ToolCallContent): void {
+  // Don't create duplicate pane for same tool_use
+  if (toolUseToChildPane.has(tc.toolUseId)) return;
+  const existing = findChildByToolUseId(parentSessionId, tc.toolUseId);
+  if (existing) {
+    toolUseToChildPane.set(tc.toolUseId, existing.id);
+    return;
+  }
+
+  const childId = crypto.randomUUID();
+  const prompt = typeof tc.input === 'object' && tc.input !== null
+    ? (tc.input as Record<string, unknown>).prompt as string ?? tc.name
+    : tc.name;
+  const label = typeof tc.input === 'object' && tc.input !== null
+    ? (tc.input as Record<string, unknown>).name as string ?? tc.name
+    : tc.name;
+
+  // Register routing
+  toolUseToChildPane.set(tc.toolUseId, childId);
+
+  // Create agent session with parent link
+  createAgentSession(childId, prompt, {
+    sessionId: parentSessionId,
+    toolUseId: tc.toolUseId,
+  });
+  updateAgentStatus(childId, 'running');
+
+  // For project-scoped sessions, subagents render in TeamAgentsPanel (no layout pane)
+  // For non-project sessions (detached mode), create a layout pane
+  if (!getSessionProjectId(parentSessionId)) {
+    const parentPane = getPanes().find(p => p.id === parentSessionId);
+    const groupName = parentPane?.title ?? `Agent ${parentSessionId.slice(0, 8)}`;
+    addPane({
+      id: childId,
+      type: 'agent',
+      title: `Sub: ${label}`,
+      group: groupName,
+    });
+  }
+}
+
+/** Clear subagent routing maps — called on dispatcher shutdown */
+export function clearSubagentRoutes(): void {
+  toolUseToChildPane.clear();
+}
diff --git a/v2/src/lib/utils/tool-files.test.ts b/v2/src/lib/utils/tool-files.test.ts
new file mode 100644
index 0000000..be20735
--- /dev/null
+++ b/v2/src/lib/utils/tool-files.test.ts
@@ -0,0 +1,148 @@
+import { describe, it, expect } from 'vitest';
+import { extractFilePaths, extractWritePaths, extractWorktreePath } from './tool-files';
+import type { ToolCallContent } from '../adapters/claude-messages';
+
+function makeTc(name: string, input: unknown): ToolCallContent {
+  return { toolUseId: `tu-${Math.random()}`, name, input };
+}
+
+describe('extractFilePaths', () => {
+  it('extracts Read file_path', () => {
+    const result = extractFilePaths(makeTc('Read', { file_path: '/src/main.ts' }));
+    expect(result).toEqual([{ path: '/src/main.ts', op: 'read' }]);
+  });
+
+  it('extracts Write file_path as write op', () => {
+    const result = extractFilePaths(makeTc('Write', { file_path: '/src/out.ts' }));
+    expect(result).toEqual([{ path: '/src/out.ts', op: 'write' }]);
+  });
+
+  it('extracts Edit file_path as write op', () => {
+    const result = extractFilePaths(makeTc('Edit', { file_path: '/src/edit.ts' }));
+    expect(result).toEqual([{ path: '/src/edit.ts', op: 'write' }]);
+  });
+
+  it('extracts Glob pattern', () => {
+    const result = extractFilePaths(makeTc('Glob', { pattern: '**/*.ts' }));
+    expect(result).toEqual([{ path: '**/*.ts', op: 'glob' }]);
+  });
+
+  it('extracts Grep path', () => {
+    const result = extractFilePaths(makeTc('Grep', { path: '/src', pattern: 'TODO' }));
+    expect(result).toEqual([{ path: '/src', op: 'grep' }]);
+  });
+
+  it('extracts Bash read paths from common commands', () => {
+    const result = extractFilePaths(makeTc('Bash', { command: 'cat /etc/hosts' }));
+    expect(result).toEqual([{ path: '/etc/hosts', op: 'bash' }]);
+  });
+
+  it('handles lowercase tool names', () => {
+    const result = extractFilePaths(makeTc('read', { file_path: '/foo' }));
+    expect(result).toEqual([{ path: '/foo', op: 'read' }]);
+  });
+
+  it('returns empty for unknown tool', () => {
+    const result = extractFilePaths(makeTc('Agent', { prompt: 'do stuff' }));
+    expect(result).toEqual([]);
+  });
+
+  it('returns empty when input has no file_path', () => {
+    const result = extractFilePaths(makeTc('Read', {}));
+    expect(result).toEqual([]);
+  });
+
+  // Bash write detection
+  it('detects echo > redirect as write', () => {
+    const result = extractFilePaths(makeTc('Bash', { command: 'echo "hello" > /tmp/out.txt' }));
+    expect(result).toEqual([{ path: '/tmp/out.txt', op: 'write' }]);
+  });
+
+  it('detects >> append redirect as write', () => {
+    const result = extractFilePaths(makeTc('Bash', { command: 'echo "data" >> /tmp/log.txt' }));
+    expect(result).toEqual([{ path: '/tmp/log.txt', op: 'write' }]);
+  });
+
+  it('detects sed -i as write', () => {
+    const result = extractFilePaths(makeTc('Bash', { command: "sed -i 's/foo/bar/g' /src/config.ts" }));
+    expect(result).toEqual([{ path: '/src/config.ts', op: 'write' }]);
+  });
+
+  it('detects tee as write', () => {
+    const result = extractFilePaths(makeTc('Bash', { command: 'echo "content" | tee /tmp/output.log' }));
+    expect(result).toEqual([{ path: '/tmp/output.log', op: 'write' }]);
+  });
+
+  it('detects tee -a as write', () => {
+    const result = extractFilePaths(makeTc('Bash', { command: 'echo "append" | tee -a /tmp/output.log' }));
+    expect(result).toEqual([{ path: '/tmp/output.log', op: 'write' }]);
+  });
+
+  it('detects cp destination as write', () => {
+    const result = extractFilePaths(makeTc('Bash', { command: 'cp /src/a.ts /src/b.ts' }));
+    expect(result).toEqual([{ path: '/src/b.ts', op: 'write' }]);
+  });
+
+  it('detects mv destination as write', () => {
+    const result = extractFilePaths(makeTc('Bash', { command: 'mv /old/file.ts /new/file.ts' }));
+    expect(result).toEqual([{ path: '/new/file.ts', op: 'write' }]);
+  });
+
+  it('ignores /dev/null redirects', () => {
+    const result = extractFilePaths(makeTc('Bash', { command: 'echo "test" > /dev/null' }));
+    expect(result).toEqual([]);
+  });
+
+  it('prefers write detection over read for ambiguous commands', () => {
+    // "cat file > out" should detect the write target, not the read source
+    const result = extractFilePaths(makeTc('Bash', { command: 'cat /src/input.ts > /tmp/output.ts' }));
+    expect(result).toEqual([{ path: '/tmp/output.ts', op: 'write' }]);
+  });
+});
+
+describe('extractWritePaths', () => {
+  it('returns only write-op paths for Write/Edit tools', () => {
+    expect(extractWritePaths(makeTc('Write', { file_path: '/a.ts' }))).toEqual(['/a.ts']);
+    expect(extractWritePaths(makeTc('Edit', { file_path: '/b.ts' }))).toEqual(['/b.ts']);
+  });
+
+  it('returns empty for read-only tools', () => {
+    expect(extractWritePaths(makeTc('Read', { file_path: '/c.ts' }))).toEqual([]);
+    expect(extractWritePaths(makeTc('Glob', { pattern: '*.ts' }))).toEqual([]);
+    expect(extractWritePaths(makeTc('Grep', { path: '/src' }))).toEqual([]);
+  });
+
+  it('returns empty for bash read commands', () => {
+    expect(extractWritePaths(makeTc('Bash', { command: 'cat /foo' }))).toEqual([]);
+  });
+
+  it('detects bash write commands', () => {
+    expect(extractWritePaths(makeTc('Bash', { command: 'echo "x" > /tmp/out.ts' }))).toEqual(['/tmp/out.ts']);
+    expect(extractWritePaths(makeTc('Bash', { command: "sed -i 's/a/b/' /src/file.ts" }))).toEqual(['/src/file.ts']);
+    expect(extractWritePaths(makeTc('Bash', { command: 'cp /a.ts /b.ts' }))).toEqual(['/b.ts']);
+  });
+});
+
+describe('extractWorktreePath', () => {
+  it('detects Agent tool with isolation: worktree', () => {
+    const result = extractWorktreePath(makeTc('Agent', { prompt: 'do stuff', isolation: 'worktree' }));
+    expect(result).toMatch(/^worktree:/);
+  });
+
+  it('detects Task tool with isolation: worktree', () => {
+    const result = extractWorktreePath(makeTc('Task', { prompt: 'do stuff', isolation: 'worktree' }));
+    expect(result).toMatch(/^worktree:/);
+  });
+
+  it('returns null for Agent without isolation', () => {
+    expect(extractWorktreePath(makeTc('Agent', { prompt: 'do stuff' }))).toBeNull();
+  });
+
+  it('detects EnterWorktree with path', () => {
+    expect(extractWorktreePath(makeTc('EnterWorktree', { path: '/tmp/wt-1' }))).toBe('/tmp/wt-1');
+  });
+
+  it('returns null for unrelated tool', () => {
+    expect(extractWorktreePath(makeTc('Read', { file_path: '/foo' }))).toBeNull();
+  });
+});
diff --git a/v2/src/lib/utils/tool-files.ts b/v2/src/lib/utils/tool-files.ts
new file mode 100644
index 0000000..05ba8aa
--- /dev/null
+++ b/v2/src/lib/utils/tool-files.ts
@@ -0,0 +1,120 @@
+// Extracts file paths from agent tool_call inputs
+// Used by ContextTab (all file ops) and conflicts store (write ops only)
+
+import type { ToolCallContent } from '../adapters/claude-messages';
+
+export interface ToolFileRef {
+  path: string;
+  op: 'read' | 'write' | 'glob' | 'grep' | 'bash';
+}
+
+// Patterns for read-like bash commands
+const BASH_READ_RE = /(?:cat|head|tail|less|vim|nano|code)\s+["']?([^\s"'|;&]+)/;
+
+// Patterns for bash commands that write to files
+const BASH_WRITE_PATTERNS: RegExp[] = [
+  // Redirection: echo/printf/cat ... > file or >> file
+  /(?:>>?)\s*["']?([^\s"'|;&]+)/,
+  // sed -i (in-place edit)
+  /\bsed\s+(?:-[^i\s]*)?-i[^-]?\s*(?:'[^']*'|"[^"]*"|[^\s]+\s+)["']?([^\s"'|;&]+)/,
+  // tee file
+  /\btee\s+(?:-a\s+)?["']?([^\s"'|;&]+)/,
+  // cp source dest — last arg is destination
+  /\bcp\s+(?:-[^\s]*\s+)*[^\s]+\s+["']?([^\s"'|;&]+)/,
+  // mv source dest — last arg is destination
+  /\bmv\s+(?:-[^\s]*\s+)*[^\s]+\s+["']?([^\s"'|;&]+)/,
+  // chmod/chown — modifies file metadata
+  /\b(?:chmod|chown)\s+(?:-[^\s]*\s+)*[^\s]+\s+["']?([^\s"'|;&]+)/,
+];
+
+/** Extract file paths referenced by a tool call */
+export function extractFilePaths(tc: ToolCallContent): ToolFileRef[] {
+  const results: ToolFileRef[] = [];
+  const input = tc.input as Record<string, unknown>;
+
+  switch (tc.name) {
+    case 'Read':
+    case 'read':
+      if (input?.file_path) results.push({ path: String(input.file_path), op: 'read' });
+      break;
+    case 'Write':
+    case 'write':
+      if (input?.file_path) results.push({ path: String(input.file_path), op: 'write' });
+      break;
+    case 'Edit':
+    case 'edit':
+      if (input?.file_path) results.push({ path: String(input.file_path), op: 'write' });
+      break;
+    case 'Glob':
+    case 'glob':
+      if (input?.pattern) results.push({ path: String(input.pattern), op: 'glob' });
+      break;
+    case 'Grep':
+    case 'grep':
+      if (input?.path) results.push({ path: String(input.path), op: 'grep' });
+      break;
+    case 'Bash':
+    case 'bash': {
+      const cmd = String(input?.command ?? '');
+      // Check for write patterns first
+      const writeRefs = extractBashWritePaths(cmd);
+      for (const path of writeRefs) {
+        results.push({ path, op: 'write' });
+      }
+      // Check for read patterns (only if no write detected to avoid double-counting)
+      if (writeRefs.length === 0) {
+        const readMatch = cmd.match(BASH_READ_RE);
+        if (readMatch) results.push({ path: readMatch[1], op: 'bash' });
+      }
+      break;
+    }
+  }
+  return results;
+}
+
+/** Extract write-target file paths from a bash command string */
+function extractBashWritePaths(cmd: string): string[] {
+  const paths: string[] = [];
+  const seen = new Set<string>();
+
+  for (const pattern of BASH_WRITE_PATTERNS) {
+    const match = cmd.match(pattern);
+    if (match && match[1] && !seen.has(match[1])) {
+      // Filter out obvious non-file targets (flags, -, /dev/null)
+      const target = match[1];
+      if (target === '-' || target.startsWith('-') || target === '/dev/null') continue;
+      seen.add(target);
+      paths.push(target);
+    }
+  }
+
+  return paths;
+}
+
+/** Extract only write-operation file paths (Write, Edit, and Bash writes) */
+export function extractWritePaths(tc: ToolCallContent): string[] {
+  return extractFilePaths(tc)
+    .filter(r => r.op === 'write')
+    .map(r => r.path);
+}
+
+/** Extract worktree path from an Agent/Task tool call with isolation: "worktree", or EnterWorktree */
+export function extractWorktreePath(tc: ToolCallContent): string | null {
+  const input = tc.input as Record<string, unknown> | null;
+  if (!input) return null;
+
+  const name = tc.name;
+  // Agent/Task tool with isolation: "worktree"
+  if ((name === 'Agent' || name === 'Task' || name === 'dispatch_agent') && input.isolation === 'worktree') {
+    // The worktree path comes from the tool_result, not the tool_call.
+    // But we can flag this session as "worktree-isolated" with a synthetic marker.
+    return `worktree:${tc.toolUseId}`;
+  }
+
+  // EnterWorktree tool call carries the path directly
+  if (name === 'EnterWorktree' && typeof input.path === 'string') {
+    return input.path;
+  }
+
+  return null;
+}
diff --git a/v2/src/lib/utils/type-guards.ts b/v2/src/lib/utils/type-guards.ts
new file mode 100644
index 0000000..8af4b72
--- /dev/null
+++ b/v2/src/lib/utils/type-guards.ts
@@ -0,0 +1,11 @@
+// Runtime type guards for safely extracting values from untyped wire formats
+
+/** Returns value if it's a string, fallback otherwise */
+export function str(v: unknown, fallback = ''): string {
+  return typeof v === 'string' ? v : fallback;
+}
+
+/** Returns value if it's a number, fallback otherwise */
+export function num(v: unknown, fallback = 0): number {
+  return typeof v === 'number' ? v : fallback;
+}
diff --git a/v2/src/lib/utils/updater.ts b/v2/src/lib/utils/updater.ts
new file mode 100644
index 0000000..5b9313f
--- /dev/null
+++ b/v2/src/lib/utils/updater.ts
@@ -0,0 +1,75 @@
+// Auto-update checker — uses Tauri updater plugin
+// Requires signing key to be configured in tauri.conf.json before use
+
+import { check, type Update } from '@tauri-apps/plugin-updater';
+import { getVersion } from '@tauri-apps/api/app';
+
+export interface UpdateInfo {
+  available: boolean;
+  version?: string;
+  notes?: string;
+  date?: string;
+  currentVersion?: string;
+}
+
+// Cache the last check result for UI access
+let lastCheckResult: UpdateInfo | null = null;
+let lastCheckTimestamp: number | null = null;
+let cachedUpdate: Update | null = null;
+
+export function getLastCheckResult(): UpdateInfo | null {
+  return lastCheckResult;
+}
+
+export function getLastCheckTimestamp(): number | null {
+  return lastCheckTimestamp;
+}
+
+export async function getCurrentVersion(): Promise<string> {
+  try {
+    return await getVersion();
+  } catch {
+    return '0.0.0';
+  }
+}
+
+export async function checkForUpdates(): Promise<UpdateInfo> {
+  try {
+    const [update, currentVersion] = await Promise.all([check(), getCurrentVersion()]);
+    lastCheckTimestamp = Date.now();
+
+    if (update) {
+      cachedUpdate = update;
+      lastCheckResult = {
+        available: true,
+        version: update.version,
+        notes: update.body ?? undefined,
+        date: update.date ?? undefined,
+        currentVersion,
+      };
+    } else {
+      cachedUpdate = null;
+      lastCheckResult = {
+        available: false,
+        currentVersion,
+      };
+    }
+
+    return lastCheckResult;
+  } catch {
+    // Updater not configured or network error — silently skip
+    lastCheckResult = { available: false };
+    lastCheckTimestamp = Date.now();
+    return lastCheckResult;
+  }
+}
+
+export async function installUpdate(): Promise<void> {
+  // Use cached update from last check if available
+  const update = cachedUpdate ?? (await check());
+  if (update) {
+    // downloadAndInstall will restart the app after installation
+    await update.downloadAndInstall();
+    // If we reach here, the app should relaunch automatically
+  }
+}
diff --git a/v2/src/lib/utils/wake-scorer.test.ts b/v2/src/lib/utils/wake-scorer.test.ts
new file mode 100644
index 0000000..15640cc
--- /dev/null
+++ b/v2/src/lib/utils/wake-scorer.test.ts
@@ -0,0 +1,253 @@
+import { describe, it, expect } from 'vitest';
+import { evaluateWakeSignals, shouldWake, type WakeScorerInput } from './wake-scorer';
+import type { WakeProjectSnapshot, WakeTaskSummary } from '../types/wake';
+
+function makeProject(overrides: Partial<WakeProjectSnapshot> = {}): WakeProjectSnapshot {
+  return {
+    projectId: 'proj-1' as any,
+    projectName: 'TestProject',
+    activityState: 'running',
+    idleMinutes: 0,
+    burnRatePerHour: 0.50,
+    contextPressurePercent: 30,
+    fileConflicts: 0,
+    attentionScore: 0,
+    attentionReason: null,
+    ...overrides,
+  };
+}
+
+function makeInput(overrides: Partial<WakeScorerInput> = {}): WakeScorerInput {
+  return {
+    projects: [makeProject()],
+    ...overrides,
+  };
+}
+
+describe('wake-scorer — evaluateWakeSignals', () => {
+  it('always includes PeriodicFloor signal', () => {
+    const result = evaluateWakeSignals(makeInput());
+    const periodic = result.signals.find(s => s.id === 'PeriodicFloor');
+    expect(periodic).toBeDefined();
+    expect(periodic!.score).toBe(0.1);
+  });
+
+  it('returns PeriodicFloor as top signal when no issues', () => {
+    const result = evaluateWakeSignals(makeInput());
+    expect(result.score).toBe(0.1);
+    expect(result.signals[0].id).toBe('PeriodicFloor');
+  });
+
+  it('detects AttentionSpike when projects have attention score > 0', () => {
+    const result = evaluateWakeSignals(makeInput({
+      projects: [
+        makeProject({ attentionScore: 100, attentionReason: 'Stalled — 20 min' }),
+        makeProject({ projectName: 'Proj2', attentionScore: 0 }),
+      ],
+    }));
+    expect(result.score).toBe(1.0);
+    const spike = result.signals.find(s => s.id === 'AttentionSpike');
+    expect(spike).toBeDefined();
+    expect(spike!.reason).toContain('1 project');
+    expect(spike!.reason).toContain('TestProject');
+  });
+
+  it('AttentionSpike reports multiple projects', () => {
+    const result = evaluateWakeSignals(makeInput({
+      projects: [
+        makeProject({ attentionScore: 100, attentionReason: 'Stalled' }),
+        makeProject({ projectName: 'B', attentionScore: 80, attentionReason: 'Error' }),
+      ],
+    }));
+    const spike = result.signals.find(s => s.id === 'AttentionSpike');
+    expect(spike!.reason).toContain('2 projects');
+  });
+
+  it('detects ContextPressureCluster when 2+ projects above 75%', () => {
+    const result = evaluateWakeSignals(makeInput({
+      projects: [
+        makeProject({ contextPressurePercent: 80 }),
+        makeProject({ projectName: 'B', contextPressurePercent: 85 }),
+      ],
+    }));
+    const cluster = result.signals.find(s => s.id === 'ContextPressureCluster');
+    expect(cluster).toBeDefined();
+    expect(cluster!.score).toBe(0.9);
+  });
+
+  it('does not trigger ContextPressureCluster with only 1 project above 75%', () => {
+    const result = evaluateWakeSignals(makeInput({
+      projects: [
+        makeProject({ contextPressurePercent: 80 }),
+        makeProject({ projectName: 'B', contextPressurePercent: 50 }),
+      ],
+    }));
+    const cluster = result.signals.find(s => s.id === 'ContextPressureCluster');
+    expect(cluster).toBeUndefined();
+  });
+
+  it('detects BurnRateAnomaly when current rate is 3x+ average', () => {
+    const result = evaluateWakeSignals(makeInput({
+      projects: [makeProject({ burnRatePerHour: 6.0 })],
+      averageBurnRate: 1.5,
+    }));
+    const anomaly = result.signals.find(s => s.id === 'BurnRateAnomaly');
+    expect(anomaly).toBeDefined();
+    expect(anomaly!.score).toBe(0.8);
+    expect(anomaly!.reason).toContain('4.0x');
+  });
+
+  it('does not trigger BurnRateAnomaly when rate is below 3x', () => {
+    const result = evaluateWakeSignals(makeInput({
+      projects: [makeProject({ burnRatePerHour: 2.0 })],
+      averageBurnRate: 1.5,
+    }));
+    const anomaly = result.signals.find(s => s.id === 'BurnRateAnomaly');
+    expect(anomaly).toBeUndefined();
+  });
+
+  it('does not trigger BurnRateAnomaly when averageBurnRate is 0', () => {
+    const result = evaluateWakeSignals(makeInput({
+      projects: [makeProject({ burnRatePerHour: 5.0 })],
+      averageBurnRate: 0,
+    }));
+    const anomaly = result.signals.find(s => s.id === 'BurnRateAnomaly');
+    expect(anomaly).toBeUndefined();
+  });
+
+  it('detects TaskQueuePressure when 3+ tasks blocked', () => {
+    const result = evaluateWakeSignals(makeInput({
+      taskSummary: { total: 10, todo: 2, inProgress: 2, blocked: 4, review: 1, done: 1 },
+    }));
+    const pressure = result.signals.find(s => s.id === 'TaskQueuePressure');
+    expect(pressure).toBeDefined();
+    expect(pressure!.score).toBe(0.7);
+  });
+
+  it('does not trigger TaskQueuePressure when fewer than 3 blocked', () => {
+    const result = evaluateWakeSignals(makeInput({
+      taskSummary: { total: 10, todo: 2, inProgress: 4, blocked: 2, review: 1, done: 1 },
+    }));
+    const pressure = result.signals.find(s => s.id === 'TaskQueuePressure');
+    expect(pressure).toBeUndefined();
+  });
+
+  it('detects ReviewBacklog when 5+ tasks in review', () => {
+    const result = evaluateWakeSignals(makeInput({
+      taskSummary: { total: 10, todo: 0, inProgress: 0, blocked: 0, review: 5, done: 5 },
+    }));
+    const backlog = result.signals.find(s => s.id === 'ReviewBacklog');
+    expect(backlog).toBeDefined();
+    expect(backlog!.score).toBe(0.6);
+  });
+
+  it('does not trigger ReviewBacklog when fewer than 5 in review', () => {
+    const result = evaluateWakeSignals(makeInput({
+      taskSummary: { total: 10, todo: 2, inProgress: 2, blocked: 0, review: 4, done: 2 },
+    }));
+    const backlog = result.signals.find(s => s.id === 'ReviewBacklog');
+    expect(backlog).toBeUndefined();
+  });
+
+  it('signals are sorted by score descending', () => {
+    const result = evaluateWakeSignals(makeInput({
+      projects: [
+        makeProject({ attentionScore: 100, attentionReason: 'Stalled', contextPressurePercent: 80 }),
+        makeProject({ projectName: 'B', contextPressurePercent: 85, attentionScore: 0 }),
+      ],
+      taskSummary: { total: 10, todo: 0, inProgress: 0, blocked: 5, review: 0, done: 5 },
+    }));
+    for (let i = 1; i < result.signals.length; i++) {
+      expect(result.signals[i - 1].score).toBeGreaterThanOrEqual(result.signals[i].score);
+    }
+  });
+
+  it('score is the maximum signal score', () => {
+    const result = evaluateWakeSignals(makeInput({
+      projects: [
+        makeProject({ attentionScore: 100, attentionReason: 'Error', contextPressurePercent: 80 }),
+        makeProject({ projectName: 'B', contextPressurePercent: 85 }),
+      ],
+    }));
+    expect(result.score).toBe(1.0); // AttentionSpike
+  });
+
+  it('summary includes fleet stats', () => {
+    const result = evaluateWakeSignals(makeInput({
+      projects: [
+        makeProject({ activityState: 'running' }),
+        makeProject({ projectName: 'B', activityState: 'idle' }),
+        makeProject({ projectName: 'C', activityState: 'stalled' }),
+      ],
+    }));
+    expect(result.summary).toContain('1 running');
+    expect(result.summary).toContain('1 idle');
+    expect(result.summary).toContain('1 stalled');
+  });
+
+  it('summary includes task summary when provided', () => {
+    const result = evaluateWakeSignals(makeInput({
+      taskSummary: { total: 15, todo: 3, inProgress: 4, blocked: 2, review: 1, done: 5 },
+    }));
+    expect(result.summary).toContain('15 total');
+    expect(result.summary).toContain('2 blocked');
+  });
+
+  it('handles empty project list', () => {
+    const result = evaluateWakeSignals(makeInput({ projects: [] }));
+    expect(result.score).toBe(0.1); // Only PeriodicFloor
+    expect(result.signals).toHaveLength(1);
+  });
+
+  it('handles null contextPressurePercent gracefully', () => {
+    const result = evaluateWakeSignals(makeInput({
+      projects: [
+        makeProject({ contextPressurePercent: null }),
+        makeProject({ projectName: 'B', contextPressurePercent: null }),
+      ],
+    }));
+    const cluster = result.signals.find(s => s.id === 'ContextPressureCluster');
+    expect(cluster).toBeUndefined();
+  });
+});
+
+describe('wake-scorer — shouldWake', () => {
+  const lowEval = {
+    score: 0.1,
+    signals: [{ id: 'PeriodicFloor', score: 0.1, reason: 'Periodic' }],
+    shouldWake: true,
+    summary: 'test',
+  };
+
+  const highEval = {
+    score: 0.8,
+    signals: [{ id: 'BurnRateAnomaly', score: 0.8, reason: 'Spike' }],
+    shouldWake: true,
+    summary: 'test',
+  };
+
+  it('persistent always wakes', () => {
+    expect(shouldWake(lowEval, 'persistent', 0.5)).toBe(true);
+    expect(shouldWake(highEval, 'persistent', 0.5)).toBe(true);
+  });
+
+  it('on-demand always wakes', () => {
+    expect(shouldWake(lowEval, 'on-demand', 0.5)).toBe(true);
+    expect(shouldWake(highEval, 'on-demand', 0.5)).toBe(true);
+  });
+
+  it('smart wakes only when score >= threshold', () => {
+    expect(shouldWake(lowEval, 'smart', 0.5)).toBe(false);
+    expect(shouldWake(highEval, 'smart', 0.5)).toBe(true);
+  });
+
+  it('smart with threshold 0 always wakes', () => {
+    expect(shouldWake(lowEval, 'smart', 0)).toBe(true);
+  });
+
+  it('smart with threshold 1.0 only wakes on max signal', () => {
+    expect(shouldWake(highEval, 'smart', 1.0)).toBe(false);
+    const maxEval = { ...highEval, score: 1.0 };
+    expect(shouldWake(maxEval, 'smart', 1.0)).toBe(true);
+  });
+});
diff --git a/v2/src/lib/utils/wake-scorer.ts b/v2/src/lib/utils/wake-scorer.ts
new file mode 100644
index 0000000..ae65356
--- /dev/null
+++ b/v2/src/lib/utils/wake-scorer.ts
@@ -0,0 +1,163 @@
+// Wake signal scorer — pure function
+// Evaluates fleet health signals to determine if the Manager should wake
+// Signal IDs from tribunal S-3 hybrid: AttentionSpike, ContextPressureCluster,
+// BurnRateAnomaly, TaskQueuePressure, ReviewBacklog, PeriodicFloor
+
+import type { WakeSignal, WakeEvaluation, WakeProjectSnapshot, WakeTaskSummary } from '../types/wake';
+
+// --- Signal weights (0..1, higher = more urgent) ---
+
+const WEIGHT_ATTENTION_SPIKE = 1.0;
+const WEIGHT_CONTEXT_PRESSURE_CLUSTER = 0.9;
+const WEIGHT_BURN_RATE_ANOMALY = 0.8;
+const WEIGHT_TASK_QUEUE_PRESSURE = 0.7;
+const WEIGHT_REVIEW_BACKLOG = 0.6;
+const WEIGHT_PERIODIC_FLOOR = 0.1;
+
+// --- Thresholds ---
+
+const CONTEXT_PRESSURE_HIGH = 0.75;
+const CONTEXT_PRESSURE_CLUSTER_MIN = 2; // 2+ projects above threshold
+const BURN_RATE_SPIKE_MULTIPLIER = 3; // 3x average = anomaly
+const TASK_BLOCKED_CRITICAL = 3; // 3+ blocked tasks = pressure
+const REVIEW_BACKLOG_CRITICAL = 5; // 5+ tasks in review = backlog
+
+export interface WakeScorerInput {
+  projects: WakeProjectSnapshot[];
+  taskSummary?: WakeTaskSummary;
+  /** Average burn rate over last hour (for anomaly detection) */
+  averageBurnRate?: number;
+}
+
+/** Evaluate all wake signals and produce a wake evaluation */
+export function evaluateWakeSignals(input: WakeScorerInput): WakeEvaluation {
+  const signals: WakeSignal[] = [];
+
+  // Signal 1: AttentionSpike — any project in attention queue (score > 0)
+  const attentionProjects = input.projects.filter(p => p.attentionScore > 0);
+  if (attentionProjects.length > 0) {
+    const top = attentionProjects.sort((a, b) => b.attentionScore - a.attentionScore)[0];
+    signals.push({
+      id: 'AttentionSpike',
+      score: WEIGHT_ATTENTION_SPIKE,
+      reason: `${attentionProjects.length} project${attentionProjects.length > 1 ? 's' : ''} need attention: ${top.projectName} (${top.attentionReason ?? 'urgent'})`,
+    });
+  }
+
+  // Signal 2: ContextPressureCluster — 2+ projects above 75% context
+  const highContextProjects = input.projects.filter(
+    p => p.contextPressurePercent !== null && p.contextPressurePercent > CONTEXT_PRESSURE_HIGH * 100,
+  );
+  if (highContextProjects.length >= CONTEXT_PRESSURE_CLUSTER_MIN) {
+    signals.push({
+      id: 'ContextPressureCluster',
+      score: WEIGHT_CONTEXT_PRESSURE_CLUSTER,
+      reason: `${highContextProjects.length} projects above ${CONTEXT_PRESSURE_HIGH * 100}% context pressure`,
+    });
+  }
+
+  // Signal 3: BurnRateAnomaly — current total burn rate >> average
+  if (input.averageBurnRate !== undefined && input.averageBurnRate > 0) {
+    const currentTotal = input.projects.reduce((sum, p) => sum + p.burnRatePerHour, 0);
+    if (currentTotal > input.averageBurnRate * BURN_RATE_SPIKE_MULTIPLIER) {
+      signals.push({
+        id: 'BurnRateAnomaly',
+        score: WEIGHT_BURN_RATE_ANOMALY,
+        reason: `Burn rate $${currentTotal.toFixed(2)}/hr is ${(currentTotal / input.averageBurnRate).toFixed(1)}x average ($${input.averageBurnRate.toFixed(2)}/hr)`,
+      });
+    }
+  }
+
+  // Signal 4: TaskQueuePressure — too many blocked tasks
+  if (input.taskSummary) {
+    if (input.taskSummary.blocked >= TASK_BLOCKED_CRITICAL) {
+      signals.push({
+        id: 'TaskQueuePressure',
+        score: WEIGHT_TASK_QUEUE_PRESSURE,
+        reason: `${input.taskSummary.blocked} blocked tasks on the board`,
+      });
+    }
+  }
+
+  // Signal 5: ReviewBacklog — too many tasks waiting for review
+  if (input.taskSummary) {
+    if (input.taskSummary.review >= REVIEW_BACKLOG_CRITICAL) {
+      signals.push({
+        id: 'ReviewBacklog',
+        score: WEIGHT_REVIEW_BACKLOG,
+        reason: `${input.taskSummary.review} tasks pending review`,
+      });
+    }
+  }
+
+  // Signal 6: PeriodicFloor — always present (lowest priority)
+  signals.push({
+    id: 'PeriodicFloor',
+    score: WEIGHT_PERIODIC_FLOOR,
+    reason: 'Periodic check-in',
+  });
+
+  // Sort by score descending
+  signals.sort((a, b) => b.score - a.score);
+
+  const topScore = signals[0]?.score ?? 0;
+
+  // Build summary for Manager prompt
+  const summary = buildWakeSummary(signals, input);
+
+  return {
+    score: topScore,
+    signals,
+    shouldWake: true, // Caller (scheduler) gates this based on strategy + threshold
+    summary,
+  };
+}
+
+/** Check if wake should fire based on strategy and threshold */
+export function shouldWake(
+  evaluation: WakeEvaluation,
+  strategy: 'persistent' | 'on-demand' | 'smart',
+  threshold: number,
+): boolean {
+  if (strategy === 'persistent' || strategy === 'on-demand') return true;
+  // Smart: only wake if score exceeds threshold
+  return evaluation.score >= threshold;
+}
+
+function buildWakeSummary(signals: WakeSignal[], input: WakeScorerInput): string {
+  const parts: string[] = [];
+
+  // Headline
+  const urgentSignals = signals.filter(s => s.score >= 0.5);
+  if (urgentSignals.length > 0) {
+    parts.push(`**Wake reason:** ${urgentSignals.map(s => s.reason).join('; ')}`);
+  } else {
+    parts.push('**Wake reason:** Periodic check-in (no urgent signals)');
+  }
+
+  // Fleet snapshot
+  const running = input.projects.filter(p => p.activityState === 'running').length;
+  const idle = input.projects.filter(p => p.activityState === 'idle').length;
+  const stalled = input.projects.filter(p => p.activityState === 'stalled').length;
+  const totalBurn = input.projects.reduce((sum, p) => sum + p.burnRatePerHour, 0);
+  parts.push(`\n**Fleet:** ${running} running, ${idle} idle, ${stalled} stalled | $${totalBurn.toFixed(2)}/hr`);
+
+  // Project details (only those needing attention)
+  const needsAttention = input.projects.filter(p => p.attentionScore > 0);
+  if (needsAttention.length > 0) {
+    parts.push('\n**Needs attention:**');
+    for (const p of needsAttention) {
+      const ctx = p.contextPressurePercent !== null ? ` | ctx ${p.contextPressurePercent}%` : '';
+      const conflicts = p.fileConflicts > 0 ? ` | ${p.fileConflicts} conflicts` : '';
+      parts.push(`- ${p.projectName}: ${p.activityState}${p.idleMinutes > 0 ? ` (${p.idleMinutes}m idle)` : ''}${ctx}${conflicts} — ${p.attentionReason ?? 'check needed'}`);
+    }
+  }
+
+  // Task summary
+  if (input.taskSummary) {
+    const ts = input.taskSummary;
+    parts.push(`\n**Tasks:** ${ts.total} total (${ts.todo} todo, ${ts.inProgress} in progress, ${ts.blocked} blocked, ${ts.review} in review, ${ts.done} done)`);
+  }
+
+  return parts.join('\n');
+}
diff --git a/v2/src/lib/utils/worktree-detection.test.ts b/v2/src/lib/utils/worktree-detection.test.ts
new file mode 100644
index 0000000..10af0dd
--- /dev/null
+++ b/v2/src/lib/utils/worktree-detection.test.ts
@@ -0,0 +1,28 @@
+import { describe, it, expect } from 'vitest';
+import { detectWorktreeFromCwd } from './worktree-detection';
+
+describe('detectWorktreeFromCwd', () => {
+  it('detects Claude Code worktree path', () => {
+    const result = detectWorktreeFromCwd('/home/user/project/.claude/worktrees/my-session');
+    expect(result).toBe('/.claude/worktrees/my-session');
+  });
+
+  it('detects Codex worktree path', () => {
+    const result = detectWorktreeFromCwd('/home/user/project/.codex/worktrees/task-1');
+    expect(result).toBe('/.codex/worktrees/task-1');
+  });
+
+  it('detects Cursor worktree path', () => {
+    const result = detectWorktreeFromCwd('/home/user/project/.cursor/worktrees/feature-x');
+    expect(result).toBe('/.cursor/worktrees/feature-x');
+  });
+
+  it('returns null for non-worktree CWD', () => {
+    expect(detectWorktreeFromCwd('/home/user/project')).toBeNull();
+    expect(detectWorktreeFromCwd('/tmp/work')).toBeNull();
+  });
+
+  it('returns null for empty string', () => {
+    expect(detectWorktreeFromCwd('')).toBeNull();
+  });
+});
diff --git a/v2/src/lib/utils/worktree-detection.ts b/v2/src/lib/utils/worktree-detection.ts
new file mode 100644
index 0000000..745696b
--- /dev/null
+++ b/v2/src/lib/utils/worktree-detection.ts
@@ -0,0 +1,17 @@
+// Worktree path detection — extracts worktree paths from CWD strings
+// Used by agent-dispatcher for conflict suppression (agents in different worktrees don't conflict)
+
+const WORKTREE_CWD_PATTERNS = [
+  /\/\.claude\/worktrees\/([^/]+)/,    // Claude Code: <repo>/.claude/worktrees/<name>/
+  /\/\.codex\/worktrees\/([^/]+)/,     // Codex
+  /\/\.cursor\/worktrees\/([^/]+)/,    // Cursor
+];
+
+/** Extract worktree path from CWD if it matches a known worktree pattern */
+export function detectWorktreeFromCwd(cwd: string): string | null {
+  for (const pattern of WORKTREE_CWD_PATTERNS) {
+    const match = cwd.match(pattern);
+    if (match) return match[0]; // Return the full worktree path segment
+  }
+  return null;
+}
diff --git a/v2/src/main.ts b/v2/src/main.ts
new file mode 100644
index 0000000..664a057
--- /dev/null
+++ b/v2/src/main.ts
@@ -0,0 +1,9 @@
+import { mount } from 'svelte'
+import './app.css'
+import App from './App.svelte'
+
+const app = mount(App, {
+  target: document.getElementById('app')!,
+})
+
+export default app
diff --git a/v2/svelte.config.js b/v2/svelte.config.js
new file mode 100644
index 0000000..96b3455
--- /dev/null
+++ b/v2/svelte.config.js
@@ -0,0 +1,8 @@
+import { vitePreprocess } from '@sveltejs/vite-plugin-svelte'
+
+/** @type {import("@sveltejs/vite-plugin-svelte").SvelteConfig} */
+export default {
+  // Consult https://svelte.dev/docs#compile-time-svelte-preprocess
+  // for more information about preprocessors
+  preprocess: vitePreprocess(),
+}
diff --git a/v2/tests/e2e/README.md b/v2/tests/e2e/README.md
new file mode 100644
index 0000000..5e33708
--- /dev/null
+++ b/v2/tests/e2e/README.md
@@ -0,0 +1,143 @@
+# E2E Tests (WebDriver)
+
+Tauri apps use the WebDriver protocol for E2E testing (not Playwright directly).
+The app runs inside WebKit2GTK on Linux, so tests interact with the real WebView.
+
+## Prerequisites
+
+- Rust toolchain (for building the Tauri app)
+- Display server (X11 or Wayland) — headless Xvfb works for CI
+- `tauri-driver` installed: `cargo install tauri-driver`
+- `webkit2gtk-driver` system package: `sudo apt install webkit2gtk-driver`
+- npm devDeps already in package.json (`@wdio/cli`, `@wdio/local-runner`, `@wdio/mocha-framework`, `@wdio/spec-reporter`)
+
+## Running
+
+```bash
+# From v2/ directory — builds debug binary automatically, spawns tauri-driver
+npm run test:e2e
+
+# Skip rebuild (use existing binary)
+SKIP_BUILD=1 npm run test:e2e
+
+# With test isolation (custom data/config dirs)
+BTERMINAL_TEST_DATA_DIR=/tmp/bt-test/data BTERMINAL_TEST_CONFIG_DIR=/tmp/bt-test/config npm run test:e2e
+```
+
+The `wdio.conf.js` handles:
+1. Building the debug binary (`cargo tauri build --debug --no-bundle`) in `onPrepare`
+2. Spawning `tauri-driver` before each session (TCP readiness probe, 10s deadline)
+3. Killing `tauri-driver` after each session
+4. Passing `BTERMINAL_TEST=1` env var to the app for test mode isolation
+
+## Test Mode (`BTERMINAL_TEST=1`)
+
+When `BTERMINAL_TEST=1` is set:
+- File watchers (watcher.rs, fs_watcher.rs) are disabled to avoid inotify noise
+- Wake scheduler is disabled (no auto-wake timers)
+- Data/config directories can be overridden via `BTERMINAL_TEST_DATA_DIR` / `BTERMINAL_TEST_CONFIG_DIR`
+
+## CI setup (headless)
+
+```bash
+# Install virtual framebuffer + WebKit driver
+sudo apt install xvfb webkit2gtk-driver
+
+# Run with Xvfb wrapper
+xvfb-run npm run test:e2e
+```
+
+## Writing tests
+
+Tests use WebdriverIO with Mocha. Specs go in `specs/`:
+
+```typescript
+import { browser, expect } from '@wdio/globals';
+
+describe('BTerminal', () => {
+  it('should show the status bar', async () => {
+    const statusBar = await browser.$('[data-testid="status-bar"]');
+    await expect(statusBar).toBeDisplayed();
+  });
+});
+```
+
+### Stable selectors
+
+Prefer `data-testid` attributes over CSS class selectors:
+
+| Element | Selector |
+|---------|----------|
+| Status bar | `[data-testid="status-bar"]` |
+| Sidebar rail | `[data-testid="sidebar-rail"]` |
+| Settings button | `[data-testid="settings-btn"]` |
+| Project box | `[data-testid="project-box"]` |
+| Project ID | `[data-project-id="..."]` |
+| Project tabs | `[data-testid="project-tabs"]` |
+| Agent session | `[data-testid="agent-session"]` |
+| Agent pane | `[data-testid="agent-pane"]` |
+| Agent status | `[data-agent-status="idle\|running\|..."]` |
+| Agent messages | `[data-testid="agent-messages"]` |
+| Agent prompt | `[data-testid="agent-prompt"]` |
+| Agent submit | `[data-testid="agent-submit"]` |
+| Agent stop | `[data-testid="agent-stop"]` |
+| Terminal tabs | `[data-testid="terminal-tabs"]` |
+| Add tab button | `[data-testid="tab-add"]` |
+| Terminal toggle | `[data-testid="terminal-toggle"]` |
+| Command palette | `[data-testid="command-palette"]` |
+| Palette input | `[data-testid="palette-input"]` |
+
+### Key constraints
+
+- `maxInstances: 1` — Tauri doesn't support parallel WebDriver sessions
+- Mocha timeout is 60s — the app needs time to initialize
+- Tests interact with the real WebKit2GTK WebView, not a browser
+- Use `browser.execute()` for JS clicks when WebDriver clicks don't trigger Svelte handlers
+- Agent tests (Scenario 7) require a real Claude CLI install + API key — they skip gracefully if unavailable
+
+## Test infrastructure
+
+### Fixtures (`fixtures.ts`)
+
+Creates isolated test environments with temp data/config dirs and git repos:
+
+```typescript
+import { createTestFixture, destroyTestFixture } from '../fixtures';
+
+const fixture = createTestFixture('my-test');
+// fixture.dataDir, fixture.configDir, fixture.projectDir, fixture.env
+destroyTestFixture(fixture);
+```
+
+### Results DB (`results-db.ts`)
+
+JSON-based test results store for tracking runs and steps:
+
+```typescript
+import { ResultsDb } from '../results-db';
+
+const db = new ResultsDb();
+db.startRun('run-001', 'v2-mission-control', 'abc123');
+db.recordStep({ run_id: 'run-001', scenario_name: 'Smoke', step_name: 'renders', status: 'passed', ... });
+db.finishRun('run-001', 'passed', 5000);
+```
+
+## File structure
+
+```
+tests/e2e/
+├── README.md                         # This file
+├── wdio.conf.js                      # WebdriverIO config with tauri-driver lifecycle
+├── tsconfig.json                     # TypeScript config for test specs
+├── fixtures.ts                       # Test fixture generator (isolated environments)
+├── results-db.ts                     # JSON test results store
+└── specs/
+    ├── bterminal.test.ts             # Smoke tests (CSS class selectors, 50+ tests)
+    └── agent-scenarios.test.ts       # Phase A scenarios (data-testid selectors, 22 tests)
+```
+
+## References
+
+- Tauri WebDriver docs: https://v2.tauri.app/develop/tests/webdriver/
+- WebdriverIO docs: https://webdriver.io/
+- tauri-driver: https://crates.io/crates/tauri-driver
diff --git a/v2/tests/e2e/fixtures.ts b/v2/tests/e2e/fixtures.ts
new file mode 100644
index 0000000..11ff9c0
--- /dev/null
+++ b/v2/tests/e2e/fixtures.ts
@@ -0,0 +1,142 @@
+// Test fixture generator — creates isolated test environments
+// Used by E2E tests to set up temp data/config dirs with valid groups.json
+
+import { mkdirSync, writeFileSync, rmSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { execSync } from 'node:child_process';
+import { tmpdir } from 'node:os';
+
+export interface TestFixture {
+  /** Root temp directory for this test run */
+  rootDir: string;
+  /** BTERMINAL_TEST_DATA_DIR — isolated data dir */
+  dataDir: string;
+  /** BTERMINAL_TEST_CONFIG_DIR — isolated config dir */
+  configDir: string;
+  /** Path to a minimal git repo for agent testing */
+  projectDir: string;
+  /** Environment variables to pass to the app */
+  env: Record<string, string>;
+}
+
+/**
+ * Create an isolated test fixture with:
+ * - Temp data dir (sessions.db, btmsg.db created at runtime)
+ * - Temp config dir with a minimal groups.json
+ * - A simple git repo with one file for agent testing
+ */
+export function createTestFixture(name = 'bterminal-e2e'): TestFixture {
+  const rootDir = join(tmpdir(), `${name}-${Date.now()}`);
+  const dataDir = join(rootDir, 'data');
+  const configDir = join(rootDir, 'config');
+  const projectDir = join(rootDir, 'test-project');
+
+  // Create directory structure
+  mkdirSync(dataDir, { recursive: true });
+  mkdirSync(configDir, { recursive: true });
+  mkdirSync(projectDir, { recursive: true });
+
+  // Create a minimal git repo for agent testing
+  execSync('git init', { cwd: projectDir, stdio: 'ignore' });
+  execSync('git config user.email "test@bterminal.dev"', { cwd: projectDir, stdio: 'ignore' });
+  execSync('git config user.name "BTerminal Test"', { cwd: projectDir, stdio: 'ignore' });
+  writeFileSync(join(projectDir, 'README.md'), '# Test Project\n\nA simple test project for BTerminal E2E tests.\n');
+  writeFileSync(join(projectDir, 'hello.py'), 'def greet(name: str) -> str:\n    return f"Hello, {name}!"\n');
+  execSync('git add -A && git commit -m "initial commit"', { cwd: projectDir, stdio: 'ignore' });
+
+  // Write groups.json with one group containing the test project
+  const groupsJson = {
+    version: 1,
+    groups: [
+      {
+        id: 'test-group',
+        name: 'Test Group',
+        projects: [
+          {
+            id: 'test-project',
+            name: 'Test Project',
+            identifier: 'test-project',
+            description: 'E2E test project',
+            icon: '\uf120',
+            cwd: projectDir,
+            profile: 'default',
+            enabled: true,
+          },
+        ],
+        agents: [],
+      },
+    ],
+    activeGroupId: 'test-group',
+  };
+
+  writeFileSync(
+    join(configDir, 'groups.json'),
+    JSON.stringify(groupsJson, null, 2),
+  );
+
+  const env: Record<string, string> = {
+    BTERMINAL_TEST: '1',
+    BTERMINAL_TEST_DATA_DIR: dataDir,
+    BTERMINAL_TEST_CONFIG_DIR: configDir,
+  };
+
+  return { rootDir, dataDir, configDir, projectDir, env };
+}
+
+/**
+ * Clean up a test fixture's temporary directories.
+ */
+export function destroyTestFixture(fixture: TestFixture): void {
+  if (existsSync(fixture.rootDir)) {
+    rmSync(fixture.rootDir, { recursive: true, force: true });
+  }
+}
+
+/**
+ * Create a groups.json with multiple projects for multi-project testing.
+ */
+export function createMultiProjectFixture(projectCount = 3): TestFixture {
+  const fixture = createTestFixture('bterminal-multi');
+
+  const projects = [];
+  for (let i = 0; i < projectCount; i++) {
+    const projDir = join(fixture.rootDir, `project-${i}`);
+    mkdirSync(projDir, { recursive: true });
+    execSync('git init', { cwd: projDir, stdio: 'ignore' });
+    execSync('git config user.email "test@bterminal.dev"', { cwd: projDir, stdio: 'ignore' });
+    execSync('git config user.name "BTerminal Test"', { cwd: projDir, stdio: 'ignore' });
+    writeFileSync(join(projDir, 'README.md'), `# Project ${i}\n`);
+    execSync('git add -A && git commit -m "init"', { cwd: projDir, stdio: 'ignore' });
+
+    projects.push({
+      id: `project-${i}`,
+      name: `Project ${i}`,
+      identifier: `project-${i}`,
+      description: `Test project ${i}`,
+      icon: '\uf120',
+      cwd: projDir,
+      profile: 'default',
+      enabled: true,
+    });
+  }
+
+  const groupsJson = {
+    version: 1,
+    groups: [
+      {
+        id: 'multi-group',
+        name: 'Multi Project Group',
+        projects,
+        agents: [],
+      },
+    ],
+    activeGroupId: 'multi-group',
+  };
+
+  writeFileSync(
+    join(fixture.configDir, 'groups.json'),
+    JSON.stringify(groupsJson, null, 2),
+  );
+
+  return fixture;
+}
diff --git a/v2/tests/e2e/llm-judge.ts b/v2/tests/e2e/llm-judge.ts
new file mode 100644
index 0000000..f23ccba
--- /dev/null
+++ b/v2/tests/e2e/llm-judge.ts
@@ -0,0 +1,231 @@
+// LLM Judge — evaluates test outcomes via Claude.
+//
+// Two backends, configurable via LLM_JUDGE_BACKEND env var:
+//   "cli"  — Claude CLI (default, no API key needed)
+//   "api"  — Anthropic REST API (requires ANTHROPIC_API_KEY)
+//
+// CLI backend: spawns `claude` with --output-format text, parses JSON verdict.
+// API backend: raw fetch to messages API, same JSON verdict parsing.
+//
+// Skips gracefully when neither backend is available.
+
+import { execFileSync, execSync } from 'node:child_process';
+import { existsSync } from 'node:fs';
+
+const MODEL = 'claude-haiku-4-5-20251001';
+const API_URL = 'https://api.anthropic.com/v1/messages';
+const MAX_TOKENS = 512;
+
+// CLI search paths (in order)
+const CLI_PATHS = [
+  `${process.env.HOME}/.local/bin/claude`,
+  `${process.env.HOME}/.claude/local/claude`,
+  '/usr/local/bin/claude',
+  '/usr/bin/claude',
+];
+
+export type JudgeBackend = 'cli' | 'api';
+
+export interface JudgeVerdict {
+  pass: boolean;
+  reasoning: string;
+  confidence: number; // 0-1
+}
+
+/**
+ * Find the Claude CLI binary path, or null if not installed.
+ */
+function findClaudeCli(): string | null {
+  for (const p of CLI_PATHS) {
+    if (existsSync(p)) return p;
+  }
+  // Fallback: check PATH
+  try {
+    const which = execSync('which claude 2>/dev/null', { encoding: 'utf-8' }).trim();
+    if (which) return which;
+  } catch {
+    // not found
+  }
+  return null;
+}
+
+/**
+ * Determine which backend to use.
+ * Env var LLM_JUDGE_BACKEND overrides auto-detection.
+ * Auto: CLI if available, then API if key set, else null.
+ */
+function resolveBackend(): JudgeBackend | null {
+  const explicit = process.env.LLM_JUDGE_BACKEND?.toLowerCase();
+  if (explicit === 'cli') return findClaudeCli() ? 'cli' : null;
+  if (explicit === 'api') return process.env.ANTHROPIC_API_KEY ? 'api' : null;
+
+  // Auto-detect: CLI first, API fallback
+  if (findClaudeCli()) return 'cli';
+  if (process.env.ANTHROPIC_API_KEY) return 'api';
+  return null;
+}
+
+/**
+ * Check if the LLM judge is available (CLI installed or API key set).
+ */
+export function isJudgeAvailable(): boolean {
+  return resolveBackend() !== null;
+}
+
+/**
+ * Build the prompt for the judge.
+ */
+function buildPrompt(criteria: string, actual: string, context?: string): { system: string; user: string } {
+  const system = `You are a test assertion judge for a terminal emulator application called BTerminal.
+Your job is to evaluate whether actual output from the application meets the given criteria.
+Respond with EXACTLY this JSON format, nothing else:
+{"pass": true/false, "reasoning": "brief explanation", "confidence": 0.0-1.0}`;
+
+  const user = [
+    '## Criteria',
+    criteria,
+    '',
+    '## Actual Output',
+    actual,
+    ...(context ? ['', '## Additional Context', context] : []),
+    '',
+    'Does the actual output satisfy the criteria? Respond with JSON only.',
+  ].join('\n');
+
+  return { system, user };
+}
+
+/**
+ * Extract and validate a JudgeVerdict from raw text output.
+ */
+function parseVerdict(text: string): JudgeVerdict {
+  const jsonMatch = text.match(/\{[\s\S]*\}/);
+  if (!jsonMatch) {
+    throw new Error(`LLM judge returned non-JSON: ${text}`);
+  }
+
+  const verdict = JSON.parse(jsonMatch[0]) as JudgeVerdict;
+
+  if (typeof verdict.pass !== 'boolean') {
+    throw new Error(`LLM judge returned invalid verdict: ${text}`);
+  }
+  verdict.confidence = Number(verdict.confidence) || 0;
+  verdict.reasoning = String(verdict.reasoning || '');
+
+  return verdict;
+}
+
+/**
+ * Judge via Claude CLI (spawns subprocess).
+ * Unsets CLAUDECODE to avoid nested session errors.
+ */
+async function judgeCli(
+  criteria: string,
+  actual: string,
+  context?: string,
+): Promise<JudgeVerdict> {
+  const cliPath = findClaudeCli();
+  if (!cliPath) throw new Error('Claude CLI not found');
+
+  const { system, user } = buildPrompt(criteria, actual, context);
+
+  const output = execFileSync(cliPath, [
+    '-p', user,
+    '--model', MODEL,
+    '--output-format', 'text',
+    '--system-prompt', system,
+    '--setting-sources', 'user',   // skip project CLAUDE.md
+  ], {
+    encoding: 'utf-8',
+    timeout: 60_000,
+    cwd: '/tmp',                   // avoid loading project CLAUDE.md
+    env: { ...process.env, CLAUDECODE: '' },
+    maxBuffer: 1024 * 1024,
+  });
+
+  return parseVerdict(output);
+}
+
+/**
+ * Judge via Anthropic REST API (raw fetch).
+ */
+async function judgeApi(
+  criteria: string,
+  actual: string,
+  context?: string,
+): Promise<JudgeVerdict> {
+  const apiKey = process.env.ANTHROPIC_API_KEY;
+  if (!apiKey) throw new Error('ANTHROPIC_API_KEY not set');
+
+  const { system, user } = buildPrompt(criteria, actual, context);
+
+  const response = await fetch(API_URL, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      'x-api-key': apiKey,
+      'anthropic-version': '2023-06-01',
+    },
+    body: JSON.stringify({
+      model: MODEL,
+      max_tokens: MAX_TOKENS,
+      system,
+      messages: [{ role: 'user', content: user }],
+    }),
+  });
+
+  if (!response.ok) {
+    const body = await response.text();
+    throw new Error(`Anthropic API error ${response.status}: ${body}`);
+  }
+
+  const data = await response.json();
+  const text = data.content?.[0]?.text ?? '';
+
+  return parseVerdict(text);
+}
+
+/**
+ * Ask Claude to evaluate whether `actual` output satisfies `criteria`.
+ *
+ * Uses CLI backend by default, falls back to API. Override with
+ * LLM_JUDGE_BACKEND env var ("cli" or "api").
+ *
+ * Returns a structured verdict with pass/fail, reasoning, and confidence.
+ * Throws if no backend available or call fails.
+ */
+export async function judge(
+  criteria: string,
+  actual: string,
+  context?: string,
+): Promise<JudgeVerdict> {
+  const backend = resolveBackend();
+  if (!backend) {
+    throw new Error('LLM judge unavailable — no Claude CLI found and ANTHROPIC_API_KEY not set');
+  }
+
+  if (backend === 'cli') {
+    return judgeCli(criteria, actual, context);
+  }
+  return judgeApi(criteria, actual, context);
+}
+
+/**
+ * Convenience: judge with a minimum confidence threshold.
+ * Returns pass=true only if verdict.pass=true AND confidence >= threshold.
+ */
+export async function assertWithJudge(
+  criteria: string,
+  actual: string,
+  options: { context?: string; minConfidence?: number } = {},
+): Promise<JudgeVerdict> {
+  const { context, minConfidence = 0.7 } = options;
+  const verdict = await judge(criteria, actual, context);
+
+  if (verdict.pass && verdict.confidence < minConfidence) {
+    verdict.pass = false;
+    verdict.reasoning += ` (confidence ${verdict.confidence} below threshold ${minConfidence})`;
+  }
+
+  return verdict;
+}
diff --git a/v2/tests/e2e/results-db.ts b/v2/tests/e2e/results-db.ts
new file mode 100644
index 0000000..513088c
--- /dev/null
+++ b/v2/tests/e2e/results-db.ts
@@ -0,0 +1,113 @@
+// Test results store — persists test run outcomes as JSON for analysis
+// No native deps needed — reads/writes a JSON file
+
+import { resolve, dirname } from 'node:path';
+import { mkdirSync, readFileSync, writeFileSync, existsSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const DEFAULT_PATH = resolve(__dirname, '../../test-results/results.json');
+
+export interface TestRunRow {
+  run_id: string;
+  started_at: string;
+  finished_at: string | null;
+  status: 'running' | 'passed' | 'failed' | 'error';
+  total_tests: number;
+  passed_tests: number;
+  failed_tests: number;
+  duration_ms: number | null;
+  git_branch: string | null;
+  git_sha: string | null;
+}
+
+export interface TestStepRow {
+  run_id: string;
+  scenario_name: string;
+  step_name: string;
+  status: 'passed' | 'failed' | 'skipped' | 'error';
+  duration_ms: number | null;
+  error_message: string | null;
+  screenshot_path: string | null;
+  agent_cost_usd: number | null;
+  created_at: string;
+}
+
+interface ResultsStore {
+  runs: TestRunRow[];
+  steps: TestStepRow[];
+}
+
+export class ResultsDb {
+  private filePath: string;
+  private store: ResultsStore;
+
+  constructor(filePath = DEFAULT_PATH) {
+    this.filePath = filePath;
+    mkdirSync(dirname(filePath), { recursive: true });
+    this.store = this.load();
+  }
+
+  private load(): ResultsStore {
+    if (existsSync(this.filePath)) {
+      try {
+        return JSON.parse(readFileSync(this.filePath, 'utf-8'));
+      } catch {
+        return { runs: [], steps: [] };
+      }
+    }
+    return { runs: [], steps: [] };
+  }
+
+  private save(): void {
+    writeFileSync(this.filePath, JSON.stringify(this.store, null, 2));
+  }
+
+  startRun(runId: string, gitBranch?: string, gitSha?: string): void {
+    this.store.runs.push({
+      run_id: runId,
+      started_at: new Date().toISOString(),
+      finished_at: null,
+      status: 'running',
+      total_tests: 0,
+      passed_tests: 0,
+      failed_tests: 0,
+      duration_ms: null,
+      git_branch: gitBranch ?? null,
+      git_sha: gitSha ?? null,
+    });
+    this.save();
+  }
+
+  finishRun(runId: string, status: 'passed' | 'failed' | 'error', durationMs: number): void {
+    const run = this.store.runs.find(r => r.run_id === runId);
+    if (!run) return;
+
+    const steps = this.store.steps.filter(s => s.run_id === runId);
+    run.finished_at = new Date().toISOString();
+    run.status = status;
+    run.duration_ms = durationMs;
+    run.total_tests = steps.length;
+    run.passed_tests = steps.filter(s => s.status === 'passed').length;
+    run.failed_tests = steps.filter(s => s.status === 'failed' || s.status === 'error').length;
+    this.save();
+  }
+
+  recordStep(step: Omit<TestStepRow, 'created_at'>): void {
+    this.store.steps.push({
+      ...step,
+      created_at: new Date().toISOString(),
+    });
+    this.save();
+  }
+
+  getRecentRuns(limit = 20): TestRunRow[] {
+    return this.store.runs
+      .sort((a, b) => b.started_at.localeCompare(a.started_at))
+      .slice(0, limit);
+  }
+
+  getStepsForRun(runId: string): TestStepRow[] {
+    return this.store.steps.filter(s => s.run_id === runId);
+  }
+}
diff --git a/v2/tests/e2e/specs/agent-scenarios.test.ts b/v2/tests/e2e/specs/agent-scenarios.test.ts
new file mode 100644
index 0000000..b568077
--- /dev/null
+++ b/v2/tests/e2e/specs/agent-scenarios.test.ts
@@ -0,0 +1,429 @@
+import { browser, expect } from '@wdio/globals';
+
+// Phase A: Human-authored E2E scenarios with deterministic assertions.
+// These test the agent UI flow end-to-end using stable data-testid selectors.
+// Agent-interaction tests require a real Claude CLI install + API key.
+
+// ─── Helpers ──────────────────────────────────────────────────────────
+
+/** Wait for agent status to reach a target value within timeout. */
+async function waitForAgentStatus(
+  status: string,
+  timeout = 30_000,
+): Promise<void> {
+  await browser.waitUntil(
+    async () => {
+      const attr = await browser.execute(() => {
+        const el = document.querySelector('[data-testid="agent-pane"]');
+        return el?.getAttribute('data-agent-status') ?? 'idle';
+      });
+      return attr === status;
+    },
+    { timeout, timeoutMsg: `Agent did not reach status "${status}" within ${timeout}ms` },
+  );
+}
+
+/** Check if an agent pane exists and is visible. */
+async function agentPaneExists(): Promise<boolean> {
+  const el = await browser.$('[data-testid="agent-pane"]');
+  return el.isExisting();
+}
+
+/** Type a prompt into the agent textarea and submit. */
+async function sendAgentPrompt(text: string): Promise<void> {
+  const textarea = await browser.$('[data-testid="agent-prompt"]');
+  await textarea.waitForDisplayed({ timeout: 5000 });
+  await textarea.setValue(text);
+  // Small delay for Svelte reactivity
+  await browser.pause(200);
+  const submitBtn = await browser.$('[data-testid="agent-submit"]');
+  await browser.execute((el) => (el as HTMLElement).click(), submitBtn);
+}
+
+// ─── Scenario 1: App renders with project grid and data-testid anchors ───
+
+describe('Scenario 1 — App Structural Integrity', () => {
+  it('should render the status bar with data-testid', async () => {
+    const bar = await browser.$('[data-testid="status-bar"]');
+    await expect(bar).toBeDisplayed();
+  });
+
+  it('should render the sidebar rail with data-testid', async () => {
+    const rail = await browser.$('[data-testid="sidebar-rail"]');
+    await expect(rail).toBeDisplayed();
+  });
+
+  it('should render at least one project box with data-testid', async () => {
+    const boxes = await browser.$$('[data-testid="project-box"]');
+    expect(boxes.length).toBeGreaterThanOrEqual(1);
+  });
+
+  it('should have data-project-id on project boxes', async () => {
+    const projectId = await browser.execute(() => {
+      const box = document.querySelector('[data-testid="project-box"]');
+      return box?.getAttribute('data-project-id') ?? null;
+    });
+    expect(projectId).not.toBeNull();
+    expect((projectId as string).length).toBeGreaterThan(0);
+  });
+
+  it('should render project tabs with data-testid', async () => {
+    const tabs = await browser.$('[data-testid="project-tabs"]');
+    await expect(tabs).toBeDisplayed();
+  });
+
+  it('should render agent session component', async () => {
+    const session = await browser.$('[data-testid="agent-session"]');
+    await expect(session).toBeDisplayed();
+  });
+});
+
+// ─── Scenario 2: Settings panel via data-testid ──────────────────────
+
+describe('Scenario 2 — Settings Panel (data-testid)', () => {
+  it('should open settings via data-testid button', async () => {
+    // Use JS click for reliability with WebKit2GTK/tauri-driver
+    await browser.execute(() => {
+      const btn = document.querySelector('[data-testid="settings-btn"]');
+      if (btn) (btn as HTMLElement).click();
+    });
+
+    const panel = await browser.$('.sidebar-panel');
+    await panel.waitForDisplayed({ timeout: 5000 });
+    // Wait for settings content to mount
+    await browser.waitUntil(
+      async () => {
+        const count = await browser.execute(() =>
+          document.querySelectorAll('.settings-tab .settings-section').length,
+        );
+        return (count as number) >= 1;
+      },
+      { timeout: 5000 },
+    );
+    await expect(panel).toBeDisplayed();
+  });
+
+  it('should close settings with Escape', async () => {
+    await browser.keys('Escape');
+    const panel = await browser.$('.sidebar-panel');
+    await panel.waitForDisplayed({ timeout: 3000, reverse: true });
+  });
+});
+
+// ─── Scenario 3: Agent pane initial state ────────────────────────────
+
+describe('Scenario 3 — Agent Pane Initial State', () => {
+  it('should display agent pane in idle status', async () => {
+    const exists = await agentPaneExists();
+    if (!exists) {
+      // Agent pane might not be visible until Model tab is active
+      await browser.execute(() => {
+        const tab = document.querySelector('[data-testid="project-tabs"] .ptab');
+        if (tab) (tab as HTMLElement).click();
+      });
+      await browser.pause(300);
+    }
+
+    const pane = await browser.$('[data-testid="agent-pane"]');
+    await expect(pane).toBeExisting();
+
+    const status = await browser.execute(() => {
+      const el = document.querySelector('[data-testid="agent-pane"]');
+      return el?.getAttribute('data-agent-status') ?? 'unknown';
+    });
+    expect(status).toBe('idle');
+  });
+
+  it('should show prompt textarea', async () => {
+    const textarea = await browser.$('[data-testid="agent-prompt"]');
+    await expect(textarea).toBeDisplayed();
+  });
+
+  it('should show submit button', async () => {
+    const btn = await browser.$('[data-testid="agent-submit"]');
+    await expect(btn).toBeExisting();
+  });
+
+  it('should have empty messages area initially', async () => {
+    const msgArea = await browser.$('[data-testid="agent-messages"]');
+    await expect(msgArea).toBeExisting();
+
+    // No message bubbles should exist in a fresh session
+    const msgCount = await browser.execute(() => {
+      const area = document.querySelector('[data-testid="agent-messages"]');
+      if (!area) return 0;
+      return area.querySelectorAll('.message').length;
+    });
+    expect(msgCount).toBe(0);
+  });
+});
+
+// ─── Scenario 4: Terminal tab management ─────────────────────────────
+
+describe('Scenario 4 — Terminal Tab Management (data-testid)', () => {
+  before(async () => {
+    // Ensure Model tab is active and terminal section visible
+    await browser.execute(() => {
+      const tab = document.querySelector('[data-testid="project-tabs"] .ptab');
+      if (tab) (tab as HTMLElement).click();
+    });
+    await browser.pause(300);
+
+    // Expand terminal section
+    await browser.execute(() => {
+      const toggle = document.querySelector('[data-testid="terminal-toggle"]');
+      if (toggle) (toggle as HTMLElement).click();
+    });
+    await browser.pause(500);
+  });
+
+  it('should display terminal tabs container', async () => {
+    const tabs = await browser.$('[data-testid="terminal-tabs"]');
+    await expect(tabs).toBeDisplayed();
+  });
+
+  it('should add a shell tab via data-testid button', async () => {
+    await browser.execute(() => {
+      const btn = document.querySelector('[data-testid="tab-add"]');
+      if (btn) (btn as HTMLElement).click();
+    });
+    await browser.pause(500);
+
+    const tabTitle = await browser.execute(() => {
+      const el = document.querySelector('.tab-bar .tab-title');
+      return el?.textContent ?? '';
+    });
+    expect(tabTitle.toLowerCase()).toContain('shell');
+  });
+
+  it('should show active tab styling', async () => {
+    const activeTab = await browser.$('.tab.active');
+    await expect(activeTab).toBeExisting();
+  });
+
+  it('should close tab and show empty state', async () => {
+    // Close all tabs
+    await browser.execute(() => {
+      const closeBtns = document.querySelectorAll('.tab-close');
+      closeBtns.forEach(btn => (btn as HTMLElement).click());
+    });
+    await browser.pause(500);
+
+    // Should show empty terminal area with "Open terminal" button
+    const emptyBtn = await browser.$('.add-first');
+    await expect(emptyBtn).toBeDisplayed();
+  });
+
+  after(async () => {
+    // Collapse terminal section
+    await browser.execute(() => {
+      const toggle = document.querySelector('[data-testid="terminal-toggle"]');
+      const chevron = toggle?.querySelector('.toggle-chevron.expanded');
+      if (chevron) (toggle as HTMLElement).click();
+    });
+    await browser.pause(300);
+  });
+});
+
+// ─── Scenario 5: Command palette with data-testid ───────────────────
+
+describe('Scenario 5 — Command Palette (data-testid)', () => {
+  it('should open palette and show data-testid input', async () => {
+    await browser.execute(() => document.body.focus());
+    await browser.pause(200);
+    await browser.keys(['Control', 'k']);
+
+    const palette = await browser.$('[data-testid="command-palette"]');
+    await palette.waitForDisplayed({ timeout: 3000 });
+
+    const input = await browser.$('[data-testid="palette-input"]');
+    await expect(input).toBeDisplayed();
+  });
+
+  it('should have focused input', async () => {
+    // Use programmatic focus check (auto-focus may not work in WebKit2GTK/tauri-driver)
+    const isFocused = await browser.execute(() => {
+      const el = document.querySelector('[data-testid="palette-input"]') as HTMLInputElement | null;
+      if (!el) return false;
+      el.focus(); // Ensure focus programmatically
+      return el === document.activeElement;
+    });
+    expect(isFocused).toBe(true);
+  });
+
+  it('should show at least one group item', async () => {
+    const items = await browser.$$('.palette-item');
+    expect(items.length).toBeGreaterThanOrEqual(1);
+  });
+
+  it('should filter and show no-results for nonsense query', async () => {
+    const input = await browser.$('[data-testid="palette-input"]');
+    await input.setValue('zzz_no_match_xyz');
+    await browser.pause(300);
+
+    const noResults = await browser.$('.no-results');
+    await expect(noResults).toBeDisplayed();
+  });
+
+  it('should close on Escape', async () => {
+    await browser.keys('Escape');
+    const palette = await browser.$('[data-testid="command-palette"]');
+    await browser.waitUntil(
+      async () => !(await palette.isDisplayed()),
+      { timeout: 3000 },
+    );
+  });
+});
+
+// ─── Scenario 6: Project focus and tab switching ─────────────────────
+
+describe('Scenario 6 — Project Focus & Tab Switching', () => {
+  it('should focus project on header click', async () => {
+    await browser.execute(() => {
+      const header = document.querySelector('.project-header');
+      if (header) (header as HTMLElement).click();
+    });
+    await browser.pause(300);
+
+    const activeBox = await browser.$('.project-box.active');
+    await expect(activeBox).toBeDisplayed();
+  });
+
+  it('should switch to Files tab and back without losing agent session', async () => {
+    // Get current agent session element reference
+    const sessionBefore = await browser.execute(() => {
+      const el = document.querySelector('[data-testid="agent-session"]');
+      return el !== null;
+    });
+    expect(sessionBefore).toBe(true);
+
+    // Switch to Files tab (second tab)
+    await browser.execute(() => {
+      const tabs = document.querySelectorAll('[data-testid="project-tabs"] .ptab');
+      if (tabs.length >= 2) (tabs[1] as HTMLElement).click();
+    });
+    await browser.pause(500);
+
+    // AgentSession should still exist in DOM (display:none, not unmounted)
+    const sessionDuring = await browser.execute(() => {
+      const el = document.querySelector('[data-testid="agent-session"]');
+      return el !== null;
+    });
+    expect(sessionDuring).toBe(true);
+
+    // Switch back to Model tab
+    await browser.execute(() => {
+      const tab = document.querySelector('[data-testid="project-tabs"] .ptab');
+      if (tab) (tab as HTMLElement).click();
+    });
+    await browser.pause(300);
+
+    // Agent session should be visible again
+    const session = await browser.$('[data-testid="agent-session"]');
+    await expect(session).toBeDisplayed();
+  });
+
+  it('should preserve agent status across tab switches', async () => {
+    const statusBefore = await browser.execute(() => {
+      const el = document.querySelector('[data-testid="agent-pane"]');
+      return el?.getAttribute('data-agent-status') ?? 'unknown';
+    });
+
+    // Switch to Context tab (third tab) and back
+    await browser.execute(() => {
+      const tabs = document.querySelectorAll('[data-testid="project-tabs"] .ptab');
+      if (tabs.length >= 3) (tabs[2] as HTMLElement).click();
+    });
+    await browser.pause(300);
+    await browser.execute(() => {
+      const tab = document.querySelector('[data-testid="project-tabs"] .ptab');
+      if (tab) (tab as HTMLElement).click();
+    });
+    await browser.pause(300);
+
+    const statusAfter = await browser.execute(() => {
+      const el = document.querySelector('[data-testid="agent-pane"]');
+      return el?.getAttribute('data-agent-status') ?? 'unknown';
+    });
+    expect(statusAfter).toBe(statusBefore);
+  });
+});
+
+// ─── Scenario 7: Agent prompt interaction (requires Claude CLI) ──────
+
+describe('Scenario 7 — Agent Prompt Submission', () => {
+  // This scenario requires a real Claude CLI + API key.
+  // Skip gracefully if agent doesn't transition to "running" within timeout.
+
+  it('should accept text in prompt textarea', async () => {
+    const textarea = await browser.$('[data-testid="agent-prompt"]');
+    await textarea.waitForDisplayed({ timeout: 5000 });
+    await textarea.setValue('Say hello');
+    await browser.pause(200);
+
+    const value = await textarea.getValue();
+    expect(value).toBe('Say hello');
+
+    // Clear without submitting
+    await textarea.clearValue();
+  });
+
+  it('should enable submit button when prompt has text', async () => {
+    const textarea = await browser.$('[data-testid="agent-prompt"]');
+    await textarea.setValue('Test prompt');
+    await browser.pause(200);
+
+    // Submit button should be interactable (not disabled)
+    const isDisabled = await browser.execute(() => {
+      const btn = document.querySelector('[data-testid="agent-submit"]');
+      if (!btn) return true;
+      return (btn as HTMLButtonElement).disabled;
+    });
+    expect(isDisabled).toBe(false);
+
+    await textarea.clearValue();
+  });
+
+  it('should show stop button during agent execution (if Claude available)', async function () {
+    // Send a minimal prompt
+    await sendAgentPrompt('Reply with exactly: BTERMINAL_TEST_OK');
+
+    // Wait for running status (generous timeout for sidecar spin-up)
+    try {
+      await waitForAgentStatus('running', 15_000);
+    } catch {
+      // Claude CLI not available — skip remaining assertions
+      console.log('Agent did not start — Claude CLI may not be available. Skipping.');
+      this.skip();
+      return;
+    }
+
+    // If agent is still running, check for stop button
+    const status = await browser.execute(() => {
+      const el = document.querySelector('[data-testid="agent-pane"]');
+      return el?.getAttribute('data-agent-status') ?? 'unknown';
+    });
+
+    if (status === 'running') {
+      const stopBtn = await browser.$('[data-testid="agent-stop"]');
+      await expect(stopBtn).toBeDisplayed();
+    }
+
+    // Wait for completion (with shorter timeout to avoid mocha timeout)
+    try {
+      await waitForAgentStatus('idle', 40_000);
+    } catch {
+      console.log('Agent did not complete within 40s — skipping completion checks.');
+      this.skip();
+      return;
+    }
+
+    // Messages area should now have content
+    const msgCount = await browser.execute(() => {
+      const area = document.querySelector('[data-testid="agent-messages"]');
+      if (!area) return 0;
+      return area.children.length;
+    });
+    expect(msgCount).toBeGreaterThan(0);
+  });
+});
diff --git a/v2/tests/e2e/specs/bterminal.test.ts b/v2/tests/e2e/specs/bterminal.test.ts
new file mode 100644
index 0000000..a556e14
--- /dev/null
+++ b/v2/tests/e2e/specs/bterminal.test.ts
@@ -0,0 +1,799 @@
+import { browser, expect } from '@wdio/globals';
+
+// All E2E tests run in a single spec file because Tauri launches one app
+// instance per session, and tauri-driver doesn't support re-creating sessions.
+
+describe('BTerminal — Smoke Tests', () => {
+  it('should render the application window', async () => {
+    // Wait for the app to fully load before any tests
+    await browser.waitUntil(
+      async () => (await browser.getTitle()) === 'BTerminal',
+      { timeout: 10_000, timeoutMsg: 'App did not load within 10s' },
+    );
+    const title = await browser.getTitle();
+    expect(title).toBe('BTerminal');
+  });
+
+  it('should display the status bar', async () => {
+    const statusBar = await browser.$('.status-bar');
+    await expect(statusBar).toBeDisplayed();
+  });
+
+  it('should show version text in status bar', async () => {
+    const version = await browser.$('.status-bar .version');
+    await expect(version).toBeDisplayed();
+    const text = await version.getText();
+    expect(text).toContain('BTerminal');
+  });
+
+  it('should display the sidebar rail', async () => {
+    const sidebarRail = await browser.$('.sidebar-rail');
+    await expect(sidebarRail).toBeDisplayed();
+  });
+
+  it('should display the workspace area', async () => {
+    const workspace = await browser.$('.workspace');
+    await expect(workspace).toBeDisplayed();
+  });
+
+  it('should toggle sidebar with settings button', async () => {
+    const settingsBtn = await browser.$('.rail-btn');
+    await settingsBtn.click();
+
+    const sidebarPanel = await browser.$('.sidebar-panel');
+    await expect(sidebarPanel).toBeDisplayed();
+
+    // Click again to close
+    await settingsBtn.click();
+    await expect(sidebarPanel).not.toBeDisplayed();
+  });
+});
+
+describe('BTerminal — Workspace & Projects', () => {
+  it('should display the project grid', async () => {
+    const grid = await browser.$('.project-grid');
+    await expect(grid).toBeDisplayed();
+  });
+
+  it('should render at least one project box', async () => {
+    const boxes = await browser.$$('.project-box');
+    expect(boxes.length).toBeGreaterThanOrEqual(1);
+  });
+
+  it('should show project header with name', async () => {
+    const header = await browser.$('.project-header');
+    await expect(header).toBeDisplayed();
+
+    const name = await browser.$('.project-name');
+    const text = await name.getText();
+    expect(text.length).toBeGreaterThan(0);
+  });
+
+  it('should show project-level tabs (Model, Docs, Context, Files, SSH, Memory, ...)', async () => {
+    const box = await browser.$('.project-box');
+    const tabs = await box.$$('.ptab');
+    // v3 has 6+ tabs: Model, Docs, Context, Files, SSH, Memory (+ role-specific)
+    expect(tabs.length).toBeGreaterThanOrEqual(6);
+  });
+
+  it('should highlight active project on click', async () => {
+    const header = await browser.$('.project-header');
+    await header.click();
+
+    const activeBox = await browser.$('.project-box.active');
+    await expect(activeBox).toBeDisplayed();
+  });
+
+  it('should switch project tabs', async () => {
+    // Use JS click — WebDriver clicks don't always trigger Svelte onclick
+    // on buttons inside complex components via WebKit2GTK/tauri-driver
+    const switched = await browser.execute(() => {
+      const box = document.querySelector('.project-box');
+      if (!box) return false;
+      const tabs = box.querySelectorAll('.ptab');
+      if (tabs.length < 2) return false;
+      (tabs[1] as HTMLElement).click();
+      return true;
+    });
+    expect(switched).toBe(true);
+    await browser.pause(500);
+
+    const box = await browser.$('.project-box');
+    const activeTab = await box.$('.ptab.active');
+    const text = await activeTab.getText();
+    // Tab[1] is "Docs" in v3 tab bar (Model, Docs, Context, Files, ...)
+    expect(text.toLowerCase()).toContain('docs');
+
+    // Switch back to Model tab
+    await browser.execute(() => {
+      const tab = document.querySelector('.project-box .ptab');
+      if (tab) (tab as HTMLElement).click();
+    });
+    await browser.pause(300);
+  });
+
+  it('should display the status bar with project count', async () => {
+    const statusBar = await browser.$('.status-bar .left');
+    const text = await statusBar.getText();
+    expect(text).toContain('projects');
+  });
+
+  it('should display project and agent info in status bar', async () => {
+    const statusBar = await browser.$('.status-bar .left');
+    const text = await statusBar.getText();
+    // Status bar always shows project count; agent counts only when > 0
+    // (shows "X running", "X idle", "X stalled" — not the word "agents")
+    expect(text).toContain('projects');
+  });
+});
+
+/** Open the settings panel, waiting for content to render. */
+async function openSettings(): Promise<void> {
+  const panel = await browser.$('.sidebar-panel');
+  const isOpen = await panel.isDisplayed().catch(() => false);
+  if (!isOpen) {
+    // Use data-testid for unambiguous selection
+    await browser.execute(() => {
+      const btn = document.querySelector('[data-testid="settings-btn"]');
+      if (btn) (btn as HTMLElement).click();
+    });
+    await panel.waitForDisplayed({ timeout: 5000 });
+  }
+  // Wait for settings content to mount
+  await browser.waitUntil(
+    async () => {
+      const count = await browser.execute(() =>
+        document.querySelectorAll('.settings-tab .settings-section').length,
+      );
+      return (count as number) >= 1;
+    },
+    { timeout: 5000, timeoutMsg: 'Settings sections did not render within 5s' },
+  );
+  await browser.pause(200);
+}
+
+/** Close the settings panel if open. */
+async function closeSettings(): Promise<void> {
+  const panel = await browser.$('.sidebar-panel');
+  if (await panel.isDisplayed().catch(() => false)) {
+    await browser.execute(() => {
+      const btn = document.querySelector('.panel-close');
+      if (btn) (btn as HTMLElement).click();
+    });
+    await browser.pause(500);
+  }
+}
+
+describe('BTerminal — Settings Panel', () => {
+  before(async () => {
+    await openSettings();
+  });
+
+  after(async () => {
+    await closeSettings();
+  });
+
+  it('should display the settings tab container', async () => {
+    const settingsTab = await browser.$('.settings-tab');
+    await expect(settingsTab).toBeDisplayed();
+  });
+
+  it('should show settings sections', async () => {
+    const sections = await browser.$$('.settings-section');
+    expect(sections.length).toBeGreaterThanOrEqual(1);
+  });
+
+  it('should display theme dropdown', async () => {
+    const dropdown = await browser.$('.custom-dropdown .dropdown-trigger');
+    await expect(dropdown).toBeDisplayed();
+  });
+
+  it('should open theme dropdown and show options', async () => {
+    // Use JS click — WebDriver clicks don't reliably trigger Svelte onclick
+    // on buttons inside scrollable panels via WebKit2GTK/tauri-driver
+    await browser.execute(() => {
+      const trigger = document.querySelector('.custom-dropdown .dropdown-trigger');
+      if (trigger) (trigger as HTMLElement).click();
+    });
+    await browser.pause(500);
+
+    const menu = await browser.$('.dropdown-menu');
+    await menu.waitForExist({ timeout: 3000 });
+
+    const options = await browser.$$('.dropdown-option');
+    expect(options.length).toBeGreaterThan(0);
+
+    // Close dropdown by clicking trigger again
+    await browser.execute(() => {
+      const trigger = document.querySelector('.custom-dropdown .dropdown-trigger');
+      if (trigger) (trigger as HTMLElement).click();
+    });
+    await browser.pause(300);
+  });
+
+  it('should display group list', async () => {
+    // Groups section is below Appearance/Defaults/Providers — scroll into view
+    await browser.execute(() => {
+      const el = document.querySelector('.group-list');
+      if (el) el.scrollIntoView({ behavior: 'instant', block: 'center' });
+    });
+    await browser.pause(300);
+    const groupList = await browser.$('.group-list');
+    await expect(groupList).toBeDisplayed();
+  });
+
+  it('should close settings panel with close button', async () => {
+    // Ensure settings is open
+    await openSettings();
+
+    // Use JS click for reliability
+    await browser.execute(() => {
+      const btn = document.querySelector('.panel-close');
+      if (btn) (btn as HTMLElement).click();
+    });
+    await browser.pause(500);
+
+    const panel = await browser.$('.sidebar-panel');
+    await expect(panel).not.toBeDisplayed();
+  });
+});
+
+/** Open command palette — idempotent (won't toggle-close if already open). */
+async function openCommandPalette(): Promise<void> {
+  // Ensure sidebar is closed first (it can intercept keyboard events)
+  await closeSettings();
+
+  // Check if already open
+  const alreadyOpen = await browser.execute(() => {
+    const p = document.querySelector('.palette');
+    return p !== null && getComputedStyle(p).display !== 'none';
+  });
+  if (alreadyOpen) return;
+
+  // Dispatch Ctrl+K via JS for reliability with WebKit2GTK/tauri-driver
+  await browser.execute(() => {
+    document.dispatchEvent(new KeyboardEvent('keydown', {
+      key: 'k', code: 'KeyK', ctrlKey: true, bubbles: true, cancelable: true,
+    }));
+  });
+  await browser.pause(300);
+
+  const palette = await browser.$('.palette');
+  await palette.waitForDisplayed({ timeout: 5000 });
+}
+
+/** Close command palette if open — uses backdrop click (more reliable than Escape). */
+async function closeCommandPalette(): Promise<void> {
+  const isOpen = await browser.execute(() => {
+    const p = document.querySelector('.palette');
+    return p !== null && getComputedStyle(p).display !== 'none';
+  });
+  if (!isOpen) return;
+
+  // Click backdrop to close (more reliable than dispatching Escape)
+  await browser.execute(() => {
+    const backdrop = document.querySelector('.palette-backdrop');
+    if (backdrop) (backdrop as HTMLElement).click();
+  });
+  await browser.pause(500);
+}
+
+describe('BTerminal — Command Palette', () => {
+  beforeEach(async () => {
+    await closeCommandPalette();
+  });
+
+  it('should show palette input', async () => {
+    await openCommandPalette();
+
+    const input = await browser.$('.palette-input');
+    await expect(input).toBeDisplayed();
+
+    // Verify input accepts text (functional focus test, not activeElement check
+    // which is unreliable in WebKit2GTK/tauri-driver)
+    const canType = await browser.execute(() => {
+      const el = document.querySelector('.palette-input') as HTMLInputElement | null;
+      if (!el) return false;
+      el.focus();
+      return el === document.activeElement;
+    });
+    expect(canType).toBe(true);
+
+    await closeCommandPalette();
+  });
+
+  it('should show palette items with command labels and categories', async () => {
+    await openCommandPalette();
+
+    const items = await browser.$$('.palette-item');
+    expect(items.length).toBeGreaterThanOrEqual(1);
+
+    // Each command item should have a label
+    const cmdLabel = await browser.$('.palette-item .cmd-label');
+    await expect(cmdLabel).toBeDisplayed();
+    const labelText = await cmdLabel.getText();
+    expect(labelText.length).toBeGreaterThan(0);
+
+    // Commands should be grouped under category headers
+    const categories = await browser.$$('.palette-category');
+    expect(categories.length).toBeGreaterThanOrEqual(1);
+
+    await closeCommandPalette();
+  });
+
+  it('should highlight selected item in palette', async () => {
+    await openCommandPalette();
+
+    // First item should be selected by default
+    const selectedItem = await browser.$('.palette-item.selected');
+    await expect(selectedItem).toBeExisting();
+
+    await closeCommandPalette();
+  });
+
+  it('should filter palette items by typing', async () => {
+    await openCommandPalette();
+
+    const itemsBefore = await browser.$$('.palette-item');
+    const countBefore = itemsBefore.length;
+
+    // Type a nonsense string that won't match any group name
+    const input = await browser.$('.palette-input');
+    await input.setValue('zzz_nonexistent_group_xyz');
+    await browser.pause(300);
+
+    // Should show no results or fewer items
+    const noResults = await browser.$('.no-results');
+    const itemsAfter = await browser.$$('.palette-item');
+    // Either no-results message appears OR item count decreased
+    const filtered = (await noResults.isExisting()) || itemsAfter.length < countBefore;
+    expect(filtered).toBe(true);
+
+    await closeCommandPalette();
+  });
+
+  it('should close palette by clicking backdrop', async () => {
+    await openCommandPalette();
+    const palette = await browser.$('.palette');
+
+    // Click the backdrop (outside the palette)
+    await browser.execute(() => {
+      const backdrop = document.querySelector('.palette-backdrop');
+      if (backdrop) (backdrop as HTMLElement).click();
+    });
+    await browser.pause(500);
+
+    await expect(palette).not.toBeDisplayed();
+  });
+});
+
+describe('BTerminal — Terminal Tabs', () => {
+  before(async () => {
+    // Ensure Claude tab is active so terminal section is visible
+    await browser.execute(() => {
+      const tab = document.querySelector('.project-box .ptab');
+      if (tab) (tab as HTMLElement).click();
+    });
+    await browser.pause(300);
+  });
+
+  it('should show terminal toggle on Claude tab', async () => {
+    const toggle = await browser.$('.terminal-toggle');
+    await expect(toggle).toBeDisplayed();
+
+    const label = await browser.$('.toggle-label');
+    const text = await label.getText();
+    expect(text.toLowerCase()).toContain('terminal');
+  });
+
+  it('should expand terminal area on toggle click', async () => {
+    // Click terminal toggle via JS
+    await browser.execute(() => {
+      const toggle = document.querySelector('.terminal-toggle');
+      if (toggle) (toggle as HTMLElement).click();
+    });
+    await browser.pause(500);
+
+    const termArea = await browser.$('.project-terminal-area');
+    await expect(termArea).toBeDisplayed();
+
+    // Chevron should have expanded class
+    const chevron = await browser.$('.toggle-chevron.expanded');
+    await expect(chevron).toBeExisting();
+  });
+
+  it('should show add tab button when terminal expanded', async () => {
+    const addBtn = await browser.$('.tab-add');
+    await expect(addBtn).toBeDisplayed();
+  });
+
+  it('should add a shell tab', async () => {
+    // Click add tab button via JS (Svelte onclick)
+    await browser.execute(() => {
+      const btn = document.querySelector('.tab-bar .tab-add');
+      if (btn) (btn as HTMLElement).click();
+    });
+    await browser.pause(500);
+
+    // Verify tab title via JS to avoid stale element issues
+    const title = await browser.execute(() => {
+      const el = document.querySelector('.tab-bar .tab-title');
+      return el ? el.textContent : '';
+    });
+    expect((title as string).toLowerCase()).toContain('shell');
+  });
+
+  it('should show active tab styling', async () => {
+    const activeTab = await browser.$('.tab.active');
+    await expect(activeTab).toBeExisting();
+  });
+
+  it('should add a second shell tab and switch between them', async () => {
+    // Add second tab via JS
+    await browser.execute(() => {
+      const btn = document.querySelector('.tab-bar .tab-add');
+      if (btn) (btn as HTMLElement).click();
+    });
+    await browser.pause(500);
+
+    const tabCount = await browser.execute(() => {
+      return document.querySelectorAll('.tab-bar .tab').length;
+    });
+    expect(tabCount as number).toBeGreaterThanOrEqual(2);
+
+    // Click first tab and verify it becomes active with Shell title
+    await browser.execute(() => {
+      const tabs = document.querySelectorAll('.tab-bar .tab');
+      if (tabs[0]) (tabs[0] as HTMLElement).click();
+    });
+    await browser.pause(300);
+
+    const activeTitle = await browser.execute(() => {
+      const active = document.querySelector('.tab-bar .tab.active .tab-title');
+      return active ? active.textContent : '';
+    });
+    expect(activeTitle as string).toContain('Shell');
+  });
+
+  it('should close a tab', async () => {
+    const tabsBefore = await browser.$$('.tab');
+    const countBefore = tabsBefore.length;
+
+    // Close the last tab
+    await browser.execute(() => {
+      const closeBtns = document.querySelectorAll('.tab-close');
+      if (closeBtns.length > 0) {
+        (closeBtns[closeBtns.length - 1] as HTMLElement).click();
+      }
+    });
+    await browser.pause(500);
+
+    const tabsAfter = await browser.$$('.tab');
+    expect(tabsAfter.length).toBe(Number(countBefore) - 1);
+  });
+
+  after(async () => {
+    // Clean up: close remaining tabs and collapse terminal
+    await browser.execute(() => {
+      // Close all tabs
+      const closeBtns = document.querySelectorAll('.tab-close');
+      closeBtns.forEach(btn => (btn as HTMLElement).click());
+    });
+    await browser.pause(300);
+
+    // Collapse terminal
+    await browser.execute(() => {
+      const toggle = document.querySelector('.terminal-toggle');
+      if (toggle) {
+        const chevron = toggle.querySelector('.toggle-chevron.expanded');
+        if (chevron) (toggle as HTMLElement).click();
+      }
+    });
+    await browser.pause(300);
+  });
+});
+
+describe('BTerminal — Theme Switching', () => {
+  before(async () => {
+    await openSettings();
+    // Scroll to top for theme dropdown
+    await browser.execute(() => {
+      const content = document.querySelector('.panel-content') || document.querySelector('.sidebar-panel');
+      if (content) content.scrollTop = 0;
+    });
+    await browser.pause(300);
+  });
+
+  after(async () => {
+    await closeSettings();
+  });
+
+  it('should show theme dropdown with group labels', async () => {
+    // Close any open dropdowns first
+    await browser.execute(() => {
+      const openMenu = document.querySelector('.dropdown-menu');
+      if (openMenu) {
+        const trigger = openMenu.closest('.custom-dropdown')?.querySelector('.dropdown-trigger');
+        if (trigger) (trigger as HTMLElement).click();
+      }
+    });
+    await browser.pause(200);
+
+    // Click the first dropdown trigger (theme dropdown)
+    await browser.execute(() => {
+      const trigger = document.querySelector('.settings-tab .custom-dropdown .dropdown-trigger');
+      if (trigger) (trigger as HTMLElement).click();
+    });
+    await browser.pause(500);
+
+    const menu = await browser.$('.dropdown-menu');
+    await menu.waitForExist({ timeout: 5000 });
+
+    // Should have group labels (Catppuccin, Editor, Deep Dark)
+    const groupLabels = await browser.$$('.dropdown-group-label');
+    expect(groupLabels.length).toBeGreaterThanOrEqual(2);
+
+    // Close dropdown
+    await browser.execute(() => {
+      const trigger = document.querySelector('.settings-tab .custom-dropdown .dropdown-trigger');
+      if (trigger) (trigger as HTMLElement).click();
+    });
+    await browser.pause(300);
+  });
+
+  it('should switch theme and update CSS variables', async () => {
+    // Get current base color
+    const baseBefore = await browser.execute(() => {
+      return getComputedStyle(document.documentElement).getPropertyValue('--ctp-base').trim();
+    });
+
+    // Open theme dropdown (first custom-dropdown in settings)
+    await browser.execute(() => {
+      const trigger = document.querySelector('.settings-tab .custom-dropdown .dropdown-trigger');
+      if (trigger) (trigger as HTMLElement).click();
+    });
+    await browser.pause(500);
+
+    // Wait for dropdown menu
+    const menu = await browser.$('.dropdown-menu');
+    await menu.waitForExist({ timeout: 5000 });
+
+    // Click the first non-active theme option
+    const changed = await browser.execute(() => {
+      const options = document.querySelectorAll('.dropdown-menu .dropdown-option:not(.active)');
+      if (options.length > 0) {
+        (options[0] as HTMLElement).click();
+        return true;
+      }
+      return false;
+    });
+    expect(changed).toBe(true);
+    await browser.pause(500);
+
+    // Verify CSS variable changed
+    const baseAfter = await browser.execute(() => {
+      return getComputedStyle(document.documentElement).getPropertyValue('--ctp-base').trim();
+    });
+    expect(baseAfter).not.toBe(baseBefore);
+
+    // Switch back to Catppuccin Mocha (first option) to restore state
+    await browser.execute(() => {
+      const trigger = document.querySelector('.settings-tab .custom-dropdown .dropdown-trigger');
+      if (trigger) (trigger as HTMLElement).click();
+    });
+    await browser.pause(500);
+    await browser.execute(() => {
+      const options = document.querySelectorAll('.dropdown-menu .dropdown-option');
+      if (options.length > 0) (options[0] as HTMLElement).click();
+    });
+    await browser.pause(300);
+  });
+
+  it('should show active theme option', async () => {
+    await browser.execute(() => {
+      const trigger = document.querySelector('.settings-tab .custom-dropdown .dropdown-trigger');
+      if (trigger) (trigger as HTMLElement).click();
+    });
+    await browser.pause(500);
+
+    const menu = await browser.$('.dropdown-menu');
+    await menu.waitForExist({ timeout: 5000 });
+
+    const activeOption = await browser.$('.dropdown-option.active');
+    await expect(activeOption).toBeExisting();
+
+    await browser.execute(() => {
+      const trigger = document.querySelector('.settings-tab .custom-dropdown .dropdown-trigger');
+      if (trigger) (trigger as HTMLElement).click();
+    });
+    await browser.pause(300);
+  });
+});
+
+describe('BTerminal — Settings Interaction', () => {
+  before(async () => {
+    await openSettings();
+    // Scroll to top for font controls
+    await browser.execute(() => {
+      const content = document.querySelector('.panel-content') || document.querySelector('.sidebar-panel');
+      if (content) content.scrollTop = 0;
+    });
+    await browser.pause(300);
+  });
+
+  after(async () => {
+    await closeSettings();
+  });
+
+  it('should show font size controls with increment/decrement', async () => {
+    const sizeControls = await browser.$$('.size-control');
+    expect(sizeControls.length).toBeGreaterThanOrEqual(1);
+
+    const sizeBtns = await browser.$$('.size-btn');
+    expect(sizeBtns.length).toBeGreaterThanOrEqual(2); // at least - and + for one control
+
+    const sizeInput = await browser.$('.size-input');
+    await expect(sizeInput).toBeExisting();
+  });
+
+  it('should increment font size', async () => {
+    const sizeInput = await browser.$('.size-input');
+    const valueBefore = await sizeInput.getValue();
+
+    // Click the + button (second .size-btn in first .size-control)
+    await browser.execute(() => {
+      const btns = document.querySelectorAll('.size-control .size-btn');
+      // Second button is + (first is -)
+      if (btns.length >= 2) (btns[1] as HTMLElement).click();
+    });
+    await browser.pause(300);
+
+    const afterEl = await browser.$('.size-input');
+    const valueAfter = await afterEl.getValue();
+    expect(parseInt(valueAfter as string)).toBe(parseInt(valueBefore as string) + 1);
+  });
+
+  it('should decrement font size back', async () => {
+    const sizeInput = await browser.$('.size-input');
+    const valueBefore = await sizeInput.getValue();
+
+    // Click the - button (first .size-btn)
+    await browser.execute(() => {
+      const btns = document.querySelectorAll('.size-control .size-btn');
+      if (btns.length >= 1) (btns[0] as HTMLElement).click();
+    });
+    await browser.pause(300);
+
+    const afterEl = await browser.$('.size-input');
+    const valueAfter = await afterEl.getValue();
+    expect(parseInt(valueAfter as string)).toBe(parseInt(valueBefore as string) - 1);
+  });
+
+  it('should display group rows with active indicator', async () => {
+    // Scroll to Groups section (below Appearance, Defaults, Providers)
+    await browser.execute(() => {
+      const el = document.querySelector('.group-list');
+      if (el) el.scrollIntoView({ behavior: 'instant', block: 'center' });
+    });
+    await browser.pause(300);
+
+    const groupRows = await browser.$$('.group-row');
+    expect(groupRows.length).toBeGreaterThanOrEqual(1);
+
+    const activeGroup = await browser.$('.group-row.active');
+    await expect(activeGroup).toBeExisting();
+  });
+
+  it('should show project cards', async () => {
+    // Scroll to Projects section
+    await browser.execute(() => {
+      const el = document.querySelector('.project-cards');
+      if (el) el.scrollIntoView({ behavior: 'instant', block: 'center' });
+    });
+    await browser.pause(300);
+
+    const cards = await browser.$$('.project-card');
+    expect(cards.length).toBeGreaterThanOrEqual(1);
+  });
+
+  it('should display project card with name and path', async () => {
+    const nameInput = await browser.$('.card-name-input');
+    await expect(nameInput).toBeExisting();
+    const name = await nameInput.getValue() as string;
+    expect(name.length).toBeGreaterThan(0);
+
+    const cwdInput = await browser.$('.cwd-input');
+    await expect(cwdInput).toBeExisting();
+    const cwd = await cwdInput.getValue() as string;
+    expect(cwd.length).toBeGreaterThan(0);
+  });
+
+  it('should show project toggle switch', async () => {
+    const toggle = await browser.$('.card-toggle');
+    await expect(toggle).toBeExisting();
+
+    const track = await browser.$('.toggle-track');
+    await expect(track).toBeDisplayed();
+  });
+
+  it('should show add project form', async () => {
+    // Scroll to add project form (at bottom of Projects section)
+    await browser.execute(() => {
+      const el = document.querySelector('.add-project-form');
+      if (el) el.scrollIntoView({ behavior: 'instant', block: 'center' });
+    });
+    await browser.pause(300);
+
+    const addForm = await browser.$('.add-project-form');
+    await expect(addForm).toBeDisplayed();
+
+    const addBtn = await browser.$('.add-project-form .btn-primary');
+    await expect(addBtn).toBeExisting();
+  });
+});
+
+describe('BTerminal — Keyboard Shortcuts', () => {
+  before(async () => {
+    await closeSettings();
+    await closeCommandPalette();
+  });
+
+  it('should open command palette with Ctrl+K', async () => {
+    await openCommandPalette();
+
+    const input = await browser.$('.palette-input');
+    await expect(input).toBeDisplayed();
+
+    // Close with Escape
+    await closeCommandPalette();
+    const palette = await browser.$('.palette');
+    const isGone = !(await palette.isDisplayed().catch(() => false));
+    expect(isGone).toBe(true);
+  });
+
+  it('should toggle settings with Ctrl+,', async () => {
+    await browser.keys(['Control', ',']);
+
+    const panel = await browser.$('.sidebar-panel');
+    await panel.waitForDisplayed({ timeout: 3000 });
+
+    // Close with Ctrl+,
+    await browser.keys(['Control', ',']);
+    await panel.waitForDisplayed({ timeout: 3000, reverse: true });
+  });
+
+  it('should toggle sidebar with Ctrl+B', async () => {
+    // Open sidebar first
+    await browser.keys(['Control', ',']);
+    const panel = await browser.$('.sidebar-panel');
+    await panel.waitForDisplayed({ timeout: 3000 });
+
+    // Toggle off with Ctrl+B
+    await browser.keys(['Control', 'b']);
+    await panel.waitForDisplayed({ timeout: 3000, reverse: true });
+  });
+
+  it('should close sidebar with Escape', async () => {
+    // Open sidebar
+    await browser.keys(['Control', ',']);
+    const panel = await browser.$('.sidebar-panel');
+    await panel.waitForDisplayed({ timeout: 3000 });
+
+    // Close with Escape
+    await browser.keys('Escape');
+    await panel.waitForDisplayed({ timeout: 3000, reverse: true });
+  });
+
+  it('should show command palette with categorized commands', async () => {
+    await openCommandPalette();
+
+    const items = await browser.$$('.palette-item');
+    expect(items.length).toBeGreaterThanOrEqual(1);
+
+    // Commands should have labels
+    const cmdLabel = await browser.$('.palette-item .cmd-label');
+    await expect(cmdLabel).toBeDisplayed();
+
+    await closeCommandPalette();
+  });
+});
diff --git a/v2/tests/e2e/specs/phase-b.test.ts b/v2/tests/e2e/specs/phase-b.test.ts
new file mode 100644
index 0000000..568abf7
--- /dev/null
+++ b/v2/tests/e2e/specs/phase-b.test.ts
@@ -0,0 +1,377 @@
+import { browser, expect } from '@wdio/globals';
+import { isJudgeAvailable, assertWithJudge } from '../llm-judge';
+
+// Phase B: Multi-project scenarios + LLM-judged assertions.
+// Extends Phase A with tests that exercise multiple project boxes simultaneously
+// and use Claude API to evaluate agent response quality.
+//
+// Prerequisites:
+// - Built debug binary (or SKIP_BUILD=1)
+// - groups.json with 2+ projects (use BTERMINAL_TEST_CONFIG_DIR or default)
+// - ANTHROPIC_API_KEY env var for LLM-judged tests (skipped if absent)
+
+// ─── Helpers ──────────────────────────────────────────────────────────
+
+/** Get all project box IDs currently rendered. */
+async function getProjectIds(): Promise<string[]> {
+  return browser.execute(() => {
+    const boxes = document.querySelectorAll('[data-testid="project-box"]');
+    return Array.from(boxes).map(
+      (b) => b.getAttribute('data-project-id') ?? '',
+    ).filter(Boolean);
+  });
+}
+
+/** Focus a specific project box by its project ID. */
+async function focusProject(projectId: string): Promise<void> {
+  await browser.execute((id) => {
+    const box = document.querySelector(`[data-project-id="${id}"]`);
+    const header = box?.querySelector('.project-header');
+    if (header) (header as HTMLElement).click();
+  }, projectId);
+  await browser.pause(300);
+}
+
+/** Get the agent status for a specific project box. */
+async function getAgentStatus(projectId: string): Promise<string> {
+  return browser.execute((id) => {
+    const box = document.querySelector(`[data-project-id="${id}"]`);
+    const pane = box?.querySelector('[data-testid="agent-pane"]');
+    return pane?.getAttribute('data-agent-status') ?? 'not-found';
+  }, projectId);
+}
+
+/** Send a prompt to the agent in a specific project box. */
+async function sendPromptInProject(projectId: string, text: string): Promise<void> {
+  await focusProject(projectId);
+  await browser.execute((id, prompt) => {
+    const box = document.querySelector(`[data-project-id="${id}"]`);
+    const textarea = box?.querySelector('[data-testid="agent-prompt"]') as HTMLTextAreaElement | null;
+    if (textarea) {
+      textarea.value = prompt;
+      textarea.dispatchEvent(new Event('input', { bubbles: true }));
+    }
+  }, projectId, text);
+  await browser.pause(200);
+  await browser.execute((id) => {
+    const box = document.querySelector(`[data-project-id="${id}"]`);
+    const btn = box?.querySelector('[data-testid="agent-submit"]') as HTMLElement | null;
+    if (btn) btn.click();
+  }, projectId);
+}
+
+/** Wait for agent in a specific project to reach target status. */
+async function waitForProjectAgentStatus(
+  projectId: string,
+  status: string,
+  timeout = 60_000,
+): Promise<void> {
+  await browser.waitUntil(
+    async () => (await getAgentStatus(projectId)) === status,
+    { timeout, timeoutMsg: `Agent in project ${projectId} did not reach "${status}" within ${timeout}ms` },
+  );
+}
+
+/** Get all message text from an agent pane in a specific project. */
+async function getAgentMessages(projectId: string): Promise<string> {
+  return browser.execute((id) => {
+    const box = document.querySelector(`[data-project-id="${id}"]`);
+    const area = box?.querySelector('[data-testid="agent-messages"]');
+    return area?.textContent ?? '';
+  }, projectId);
+}
+
+/** Switch to a tab in a specific project box. Tab index: 0=Model, 1=Docs, 2=Context, etc. */
+async function switchProjectTab(projectId: string, tabIndex: number): Promise<void> {
+  await browser.execute((id, idx) => {
+    const box = document.querySelector(`[data-project-id="${id}"]`);
+    const tabs = box?.querySelectorAll('[data-testid="project-tabs"] .ptab');
+    if (tabs && tabs[idx]) (tabs[idx] as HTMLElement).click();
+  }, projectId, tabIndex);
+  await browser.pause(300);
+}
+
+// ─── Scenario B1: Multi-project grid renders correctly ────────────────
+
+describe('Scenario B1 — Multi-Project Grid', () => {
+  it('should render multiple project boxes', async () => {
+    // Wait for app to fully render project boxes
+    await browser.waitUntil(
+      async () => {
+        const count = await browser.execute(() =>
+          document.querySelectorAll('[data-testid="project-box"]').length,
+        );
+        return (count as number) >= 1;
+      },
+      { timeout: 10_000, timeoutMsg: 'No project boxes rendered within 10s' },
+    );
+
+    const ids = await getProjectIds();
+    // May be 1 project in minimal fixture; test structure regardless
+    expect(ids.length).toBeGreaterThanOrEqual(1);
+    // Each ID should be unique
+    const unique = new Set(ids);
+    expect(unique.size).toBe(ids.length);
+  });
+
+  it('should show project headers with CWD paths', async () => {
+    const headers = await browser.execute(() => {
+      const els = document.querySelectorAll('.project-header .cwd');
+      return Array.from(els).map((e) => e.textContent?.trim() ?? '');
+    });
+    // Each header should have a non-empty CWD
+    for (const cwd of headers) {
+      expect(cwd.length).toBeGreaterThan(0);
+    }
+  });
+
+  it('should have independent agent panes per project', async () => {
+    const ids = await getProjectIds();
+    for (const id of ids) {
+      const status = await getAgentStatus(id);
+      expect(['idle', 'running', 'stalled']).toContain(status);
+    }
+  });
+
+  it('should focus project on click and show active styling', async () => {
+    const ids = await getProjectIds();
+    if (ids.length < 1) return;
+
+    await focusProject(ids[0]);
+    const isActive = await browser.execute((id) => {
+      const box = document.querySelector(`[data-project-id="${id}"]`);
+      return box?.classList.contains('active') ?? false;
+    }, ids[0]);
+    expect(isActive).toBe(true);
+  });
+});
+
+// ─── Scenario B2: Independent tab switching across projects ───────────
+
+describe('Scenario B2 — Independent Tab Switching', () => {
+  it('should allow different tabs active in different projects', async () => {
+    const ids = await getProjectIds();
+    if (ids.length < 2) {
+      console.log('Skipping B2 — need 2+ projects');
+      return;
+    }
+
+    // Switch first project to Files tab (index 3)
+    await switchProjectTab(ids[0], 3);
+    // Keep second project on Model tab (index 0)
+    await switchProjectTab(ids[1], 0);
+
+    // Verify first project has Files tab active
+    const firstActiveTab = await browser.execute((id) => {
+      const box = document.querySelector(`[data-project-id="${id}"]`);
+      const active = box?.querySelector('[data-testid="project-tabs"] .ptab.active');
+      return active?.textContent?.trim() ?? '';
+    }, ids[0]);
+
+    const secondActiveTab = await browser.execute((id) => {
+      const box = document.querySelector(`[data-project-id="${id}"]`);
+      const active = box?.querySelector('[data-testid="project-tabs"] .ptab.active');
+      return active?.textContent?.trim() ?? '';
+    }, ids[1]);
+
+    // They should be different tabs
+    expect(firstActiveTab).not.toBe(secondActiveTab);
+
+    // Restore first project to Model tab
+    await switchProjectTab(ids[0], 0);
+  });
+});
+
+// ─── Scenario B3: Status bar reflects fleet state ────────────────────
+
+describe('Scenario B3 — Status Bar Fleet State', () => {
+  it('should show agent count in status bar', async () => {
+    const barText = await browser.execute(() => {
+      const bar = document.querySelector('[data-testid="status-bar"]');
+      return bar?.textContent ?? '';
+    });
+    // Status bar should contain at least one count (idle agents)
+    expect(barText.length).toBeGreaterThan(0);
+  });
+
+  it('should show no burn rate when all agents idle', async () => {
+    // When all agents are idle, burn-rate and cost elements are not rendered
+    // (they only appear when totalBurnRatePerHour > 0 or totalCost > 0)
+    const hasBurnRate = await browser.execute(() => {
+      const bar = document.querySelector('[data-testid="status-bar"]');
+      const burnEl = bar?.querySelector('.burn-rate');
+      const costEl = bar?.querySelector('.cost');
+      return { burn: burnEl?.textContent ?? null, cost: costEl?.textContent ?? null };
+    });
+    // Either no burn rate shown (idle) or it shows $0
+    if (hasBurnRate.burn !== null) {
+      expect(hasBurnRate.burn).toMatch(/\$0|0\.00/);
+    }
+    if (hasBurnRate.cost !== null) {
+      expect(hasBurnRate.cost).toMatch(/\$0|0\.00/);
+    }
+    // If both are null, agents are idle — that's the expected state
+  });
+});
+
+// ─── Scenario B4: LLM-judged agent response (requires API key) ──────
+
+describe('Scenario B4 — LLM-Judged Agent Response', () => {
+  const SKIP_MSG = 'Skipping — LLM judge not available (no CLI or API key)';
+
+  it('should send prompt and get meaningful response', async function () {
+    this.timeout(180_000); // agent needs time to start + run + respond
+    if (!isJudgeAvailable()) {
+      console.log(SKIP_MSG);
+      this.skip();
+      return;
+    }
+
+    const ids = await getProjectIds();
+    if (ids.length < 1) {
+      this.skip();
+      return;
+    }
+    const projectId = ids[0];
+
+    // Send a prompt that requires a specific kind of response
+    await sendPromptInProject(projectId, 'List the files in the current directory. Just list them, nothing else.');
+
+    // Wait for agent to start
+    try {
+      await waitForProjectAgentStatus(projectId, 'running', 15_000);
+    } catch {
+      console.log('Agent did not start — Claude CLI may not be available');
+      this.skip();
+      return;
+    }
+
+    // Wait for completion
+    await waitForProjectAgentStatus(projectId, 'idle', 120_000);
+
+    // Get the agent's output
+    const messages = await getAgentMessages(projectId);
+
+    // Use LLM judge to evaluate the response
+    const verdict = await assertWithJudge(
+      'The output should contain a file listing that includes at least one filename (like README.md or hello.py). It should look like a directory listing, not an error message.',
+      messages,
+      { context: 'BTerminal agent was asked to list files in a test project directory containing README.md and hello.py' },
+    );
+
+    expect(verdict.pass).toBe(true);
+    if (!verdict.pass) {
+      console.log(`LLM Judge: ${verdict.reasoning} (confidence: ${verdict.confidence})`);
+    }
+  });
+
+  it('should produce response with appropriate tool usage', async function () {
+    if (!isJudgeAvailable()) {
+      console.log(SKIP_MSG);
+      this.skip();
+      return;
+    }
+
+    const ids = await getProjectIds();
+    if (ids.length < 1) {
+      this.skip();
+      return;
+    }
+    const projectId = ids[0];
+
+    // Check that the previous response (from prior test) involved tool calls
+    const messages = await getAgentMessages(projectId);
+
+    const verdict = await assertWithJudge(
+      'The output should show evidence that the agent used tools (like Bash, Read, Glob, or LS commands) to list files. Tool usage typically appears as tool call names, command text, or file paths in the output.',
+      messages,
+      { context: 'BTerminal renders agent tool calls in collapsible sections showing the tool name and output' },
+    );
+
+    expect(verdict.pass).toBe(true);
+    if (!verdict.pass) {
+      console.log(`LLM Judge: ${verdict.reasoning} (confidence: ${verdict.confidence})`);
+    }
+  });
+});
+
+// ─── Scenario B5: LLM-judged code generation quality ─────────────────
+
+describe('Scenario B5 — LLM-Judged Code Generation', () => {
+  const SKIP_MSG = 'Skipping — LLM judge not available (no CLI or API key)';
+
+  it('should generate valid code when asked', async function () {
+    this.timeout(180_000); // agent needs time to start + run + respond
+    if (!isJudgeAvailable()) {
+      console.log(SKIP_MSG);
+      this.skip();
+      return;
+    }
+
+    const ids = await getProjectIds();
+    if (ids.length < 1) {
+      this.skip();
+      return;
+    }
+    const projectId = ids[0];
+
+    // Ask agent to read and explain existing code
+    await sendPromptInProject(
+      projectId,
+      'Read hello.py and tell me what the greet function does. One sentence answer.',
+    );
+
+    try {
+      await waitForProjectAgentStatus(projectId, 'running', 15_000);
+    } catch {
+      console.log('Agent did not start — Claude CLI may not be available');
+      this.skip();
+      return;
+    }
+
+    await waitForProjectAgentStatus(projectId, 'idle', 120_000);
+
+    const messages = await getAgentMessages(projectId);
+
+    const verdict = await assertWithJudge(
+      'The response should correctly describe that the greet function takes a name parameter and returns a greeting string like "Hello, {name}!". The explanation should be roughly one sentence as requested.',
+      messages,
+      { context: 'hello.py contains: def greet(name: str) -> str:\n    return f"Hello, {name}!"' },
+    );
+
+    expect(verdict.pass).toBe(true);
+    if (!verdict.pass) {
+      console.log(`LLM Judge: ${verdict.reasoning} (confidence: ${verdict.confidence})`);
+    }
+  });
+});
+
+// ─── Scenario B6: Context tab reflects agent activity ────────────────
+
+describe('Scenario B6 — Context Tab After Agent Activity', () => {
+  it('should show token usage in Context tab after agent ran', async () => {
+    const ids = await getProjectIds();
+    if (ids.length < 1) return;
+    const projectId = ids[0];
+
+    // Switch to Context tab (index 2)
+    await switchProjectTab(projectId, 2);
+
+    // Check if context tab has any content
+    const contextContent = await browser.execute((id) => {
+      const box = document.querySelector(`[data-project-id="${id}"]`);
+      // Look for stats or token meter elements
+      const stats = box?.querySelector('.context-stats, .token-meter, .stat-value');
+      return stats?.textContent ?? '';
+    }, projectId);
+
+    // If an agent has run, context tab should have data
+    // If no agent ran (skipped), this may be empty — that's OK
+    if (contextContent) {
+      expect(contextContent.length).toBeGreaterThan(0);
+    }
+
+    // Switch back to Model tab
+    await switchProjectTab(projectId, 0);
+  });
+});
diff --git a/v2/tests/e2e/specs/phase-c.test.ts b/v2/tests/e2e/specs/phase-c.test.ts
new file mode 100644
index 0000000..00771d0
--- /dev/null
+++ b/v2/tests/e2e/specs/phase-c.test.ts
@@ -0,0 +1,626 @@
+import { browser, expect } from '@wdio/globals';
+import { isJudgeAvailable, assertWithJudge } from '../llm-judge';
+
+// Phase C: Hardening feature tests.
+// Tests the v3 production-readiness features added in the hardening sprint:
+// - Command palette new commands
+// - Search overlay (Ctrl+Shift+F)
+// - Notification center
+// - Keyboard shortcuts (vi-nav, project jump)
+// - Settings panel new sections
+// - Error states and recovery UI
+
+// ─── Helpers ──────────────────────────────────────────────────────────
+
+/** Get all project box IDs currently rendered. */
+async function getProjectIds(): Promise<string[]> {
+  return browser.execute(() => {
+    const boxes = document.querySelectorAll('[data-testid="project-box"]');
+    return Array.from(boxes).map(
+      (b) => b.getAttribute('data-project-id') ?? '',
+    ).filter(Boolean);
+  });
+}
+
+/** Focus a specific project box by its project ID. */
+async function focusProject(projectId: string): Promise<void> {
+  await browser.execute((id) => {
+    const box = document.querySelector(`[data-project-id="${id}"]`);
+    const header = box?.querySelector('.project-header');
+    if (header) (header as HTMLElement).click();
+  }, projectId);
+  await browser.pause(300);
+}
+
+/** Switch to a tab in a specific project box. */
+async function switchProjectTab(projectId: string, tabIndex: number): Promise<void> {
+  await browser.execute((id, idx) => {
+    const box = document.querySelector(`[data-project-id="${id}"]`);
+    const tabs = box?.querySelectorAll('[data-testid="project-tabs"] .ptab');
+    if (tabs && tabs[idx]) (tabs[idx] as HTMLElement).click();
+  }, projectId, tabIndex);
+  await browser.pause(300);
+}
+
+/** Open command palette via Ctrl+K. */
+async function openPalette(): Promise<void> {
+  await browser.execute(() => document.body.focus());
+  await browser.pause(100);
+  await browser.keys(['Control', 'k']);
+  const palette = await browser.$('[data-testid="command-palette"]');
+  await palette.waitForDisplayed({ timeout: 3000 });
+}
+
+/** Close command palette via Escape. */
+async function closePalette(): Promise<void> {
+  await browser.keys('Escape');
+  await browser.pause(300);
+}
+
+/** Type into palette input and get filtered results. */
+async function paletteSearch(query: string): Promise<string[]> {
+  const input = await browser.$('[data-testid="palette-input"]');
+  await input.setValue(query);
+  await browser.pause(300);
+  return browser.execute(() => {
+    const items = document.querySelectorAll('.palette-item .cmd-label');
+    return Array.from(items).map(el => el.textContent?.trim() ?? '');
+  });
+}
+
+// ─── Scenario C1: Command Palette — Hardening Commands ────────────────
+
+describe('Scenario C1 — Command Palette Hardening Commands', () => {
+  afterEach(async () => {
+    // Ensure palette is closed after each test
+    try {
+      const isVisible = await browser.execute(() => {
+        const el = document.querySelector('[data-testid="command-palette"]');
+        return el !== null && window.getComputedStyle(el).display !== 'none';
+      });
+      if (isVisible) {
+        await closePalette();
+      }
+    } catch {
+      // Ignore if palette doesn't exist
+    }
+  });
+
+  it('should find settings command in palette', async () => {
+    await openPalette();
+    const results = await paletteSearch('settings');
+    expect(results.length).toBeGreaterThanOrEqual(1);
+    const hasSettings = results.some(r => r.toLowerCase().includes('settings'));
+    expect(hasSettings).toBe(true);
+  });
+
+  it('should find terminal command in palette', async () => {
+    await openPalette();
+    const results = await paletteSearch('terminal');
+    expect(results.length).toBeGreaterThanOrEqual(1);
+    const hasTerminal = results.some(r => r.toLowerCase().includes('terminal'));
+    expect(hasTerminal).toBe(true);
+  });
+
+  it('should find keyboard shortcuts command in palette', async () => {
+    await openPalette();
+    const results = await paletteSearch('keyboard');
+    expect(results.length).toBeGreaterThanOrEqual(1);
+    const hasShortcuts = results.some(r => r.toLowerCase().includes('keyboard'));
+    expect(hasShortcuts).toBe(true);
+  });
+
+  it('should list all commands grouped by category when input is empty', async () => {
+    await openPalette();
+    const input = await browser.$('[data-testid="palette-input"]');
+    await input.clearValue();
+    await browser.pause(200);
+
+    const itemCount = await browser.execute(() =>
+      document.querySelectorAll('.palette-item').length,
+    );
+    // v3 has 18+ commands
+    expect(itemCount).toBeGreaterThanOrEqual(10);
+
+    // Commands should be organized in groups (categories)
+    const groups = await browser.execute(() => {
+      const headers = document.querySelectorAll('.palette-category');
+      return Array.from(headers).map(h => h.textContent?.trim() ?? '');
+    });
+    // Should have at least 2 command groups
+    expect(groups.length).toBeGreaterThanOrEqual(2);
+  });
+});
+
+// ─── Scenario C2: Search Overlay (Ctrl+Shift+F) ──────────────────────
+
+describe('Scenario C2 — Search Overlay (FTS5)', () => {
+  it('should open search overlay with Ctrl+Shift+F', async () => {
+    await browser.execute(() => document.body.focus());
+    await browser.pause(100);
+    await browser.keys(['Control', 'Shift', 'f']);
+    await browser.pause(500);
+
+    const overlay = await browser.execute(() => {
+      // SearchOverlay uses .search-overlay class
+      const el = document.querySelector('.search-overlay, [data-testid="search-overlay"]');
+      return el !== null;
+    });
+    expect(overlay).toBe(true);
+  });
+
+  it('should have search input focused', async () => {
+    const isFocused = await browser.execute(() => {
+      const input = document.querySelector('.search-overlay input, [data-testid="search-input"]') as HTMLInputElement | null;
+      if (!input) return false;
+      input.focus();
+      return input === document.activeElement;
+    });
+    expect(isFocused).toBe(true);
+  });
+
+  it('should show no results for nonsense query', async () => {
+    await browser.execute(() => {
+      const input = document.querySelector('.search-overlay input, [data-testid="search-input"]') as HTMLInputElement | null;
+      if (input) {
+        input.value = 'zzz_nonexistent_xyz_999';
+        input.dispatchEvent(new Event('input', { bubbles: true }));
+      }
+    });
+    await browser.pause(500); // 300ms debounce + render time
+
+    const resultCount = await browser.execute(() => {
+      const results = document.querySelectorAll('.search-result, .search-result-item');
+      return results.length;
+    });
+    expect(resultCount).toBe(0);
+  });
+
+  it('should close search overlay with Escape', async () => {
+    await browser.keys('Escape');
+    await browser.pause(300);
+
+    const overlay = await browser.execute(() => {
+      const el = document.querySelector('.search-overlay, [data-testid="search-overlay"]');
+      if (!el) return false;
+      const style = window.getComputedStyle(el);
+      return style.display !== 'none' && style.visibility !== 'hidden';
+    });
+    expect(overlay).toBe(false);
+  });
+});
+
+// ─── Scenario C3: Notification Center ─────────────────────────────────
+
+describe('Scenario C3 — Notification Center', () => {
+  it('should render notification bell in status bar', async () => {
+    const hasBell = await browser.execute(() => {
+      const bar = document.querySelector('[data-testid="status-bar"]');
+      // NotificationCenter is in status bar with bell icon
+      const bell = bar?.querySelector('.notification-bell, .bell-icon, [data-testid="notification-bell"]');
+      return bell !== null;
+    });
+    expect(hasBell).toBe(true);
+  });
+
+  it('should open notification panel on bell click', async () => {
+    await browser.execute(() => {
+      const bell = document.querySelector('.notification-bell, .bell-icon, [data-testid="notification-bell"]');
+      if (bell) (bell as HTMLElement).click();
+    });
+    await browser.pause(300);
+
+    const panelOpen = await browser.execute(() => {
+      const panel = document.querySelector('.notification-panel, .notification-dropdown, [data-testid="notification-panel"]');
+      if (!panel) return false;
+      const style = window.getComputedStyle(panel);
+      return style.display !== 'none';
+    });
+    expect(panelOpen).toBe(true);
+  });
+
+  it('should show empty state or notification history', async () => {
+    const content = await browser.execute(() => {
+      const panel = document.querySelector('.notification-panel, .notification-dropdown, [data-testid="notification-panel"]');
+      return panel?.textContent ?? '';
+    });
+    // Panel should have some text content (either "No notifications" or actual notifications)
+    expect(content.length).toBeGreaterThan(0);
+  });
+
+  it('should close notification panel on outside click', async () => {
+    // Click the backdrop overlay to close the panel
+    await browser.execute(() => {
+      const backdrop = document.querySelector('.notification-center .backdrop');
+      if (backdrop) (backdrop as HTMLElement).click();
+    });
+    await browser.pause(300);
+
+    const panelOpen = await browser.execute(() => {
+      const panel = document.querySelector('.notification-panel, .notification-dropdown, [data-testid="notification-panel"]');
+      if (!panel) return false;
+      const style = window.getComputedStyle(panel);
+      return style.display !== 'none';
+    });
+    expect(panelOpen).toBe(false);
+  });
+});
+
+// ─── Scenario C4: Keyboard Navigation ────────────────────────────────
+
+describe('Scenario C4 — Keyboard-First Navigation', () => {
+  it('should toggle settings with Ctrl+Comma', async () => {
+    await browser.execute(() => document.body.focus());
+    await browser.pause(100);
+    await browser.keys(['Control', ',']);
+    await browser.pause(500);
+
+    const settingsVisible = await browser.execute(() => {
+      const panel = document.querySelector('.sidebar-panel');
+      if (!panel) return false;
+      const style = window.getComputedStyle(panel);
+      return style.display !== 'none';
+    });
+    expect(settingsVisible).toBe(true);
+
+    // Close it
+    await browser.keys('Escape');
+    await browser.pause(300);
+  });
+
+  it('should toggle sidebar with Ctrl+B', async () => {
+    await browser.execute(() => document.body.focus());
+    await browser.pause(100);
+
+    // First open settings to have sidebar content
+    await browser.keys(['Control', ',']);
+    await browser.pause(300);
+
+    const initialState = await browser.execute(() => {
+      const panel = document.querySelector('.sidebar-panel');
+      return panel !== null && window.getComputedStyle(panel).display !== 'none';
+    });
+
+    // Toggle sidebar
+    await browser.keys(['Control', 'b']);
+    await browser.pause(300);
+
+    const afterToggle = await browser.execute(() => {
+      const panel = document.querySelector('.sidebar-panel');
+      if (!panel) return false;
+      return window.getComputedStyle(panel).display !== 'none';
+    });
+
+    // State should have changed
+    if (initialState) {
+      expect(afterToggle).toBe(false);
+    }
+
+    // Clean up — close sidebar if still open
+    await browser.keys('Escape');
+    await browser.pause(200);
+  });
+
+  it('should focus project with Alt+1', async () => {
+    await browser.execute(() => document.body.focus());
+    await browser.pause(100);
+    await browser.keys(['Alt', '1']);
+    await browser.pause(300);
+
+    const hasActive = await browser.execute(() => {
+      const active = document.querySelector('.project-box.active');
+      return active !== null;
+    });
+    expect(hasActive).toBe(true);
+  });
+});
+
+// ─── Scenario C5: Settings Panel Sections ─────────────────────────────
+
+describe('Scenario C5 — Settings Panel Sections', () => {
+  before(async () => {
+    // Open settings
+    await browser.execute(() => {
+      const btn = document.querySelector('[data-testid="settings-btn"]');
+      if (btn) (btn as HTMLElement).click();
+    });
+    await browser.pause(500);
+  });
+
+  it('should show Appearance section with theme dropdown', async () => {
+    const hasTheme = await browser.execute(() => {
+      const panel = document.querySelector('.sidebar-panel, .settings-tab');
+      if (!panel) return false;
+      const text = panel.textContent ?? '';
+      return text.toLowerCase().includes('theme') || text.toLowerCase().includes('appearance');
+    });
+    expect(hasTheme).toBe(true);
+  });
+
+  it('should show font settings (UI font and Terminal font)', async () => {
+    const hasFonts = await browser.execute(() => {
+      const panel = document.querySelector('.sidebar-panel, .settings-tab');
+      if (!panel) return false;
+      const text = panel.textContent ?? '';
+      return text.toLowerCase().includes('font');
+    });
+    expect(hasFonts).toBe(true);
+  });
+
+  it('should show default shell setting', async () => {
+    const hasShell = await browser.execute(() => {
+      const panel = document.querySelector('.sidebar-panel, .settings-tab');
+      if (!panel) return false;
+      const text = panel.textContent ?? '';
+      return text.toLowerCase().includes('shell');
+    });
+    expect(hasShell).toBe(true);
+  });
+
+  it('should have theme dropdown with 17 themes', async () => {
+    // Click the theme dropdown to see options
+    const themeCount = await browser.execute(() => {
+      // Find the theme dropdown (custom dropdown, not native select)
+      const dropdowns = document.querySelectorAll('.settings-tab .custom-dropdown, .settings-tab .dropdown');
+      for (const dd of dropdowns) {
+        const label = dd.closest('.settings-row, .setting-row')?.textContent ?? '';
+        if (label.toLowerCase().includes('theme')) {
+          // Click to open it
+          const trigger = dd.querySelector('.dropdown-trigger, .dropdown-selected, button');
+          if (trigger) (trigger as HTMLElement).click();
+          return -1; // Flag: opened dropdown
+        }
+      }
+      return 0;
+    });
+
+    if (themeCount === -1) {
+      // Dropdown was opened, wait and count options
+      await browser.pause(300);
+      const optionCount = await browser.execute(() => {
+        const options = document.querySelectorAll('.dropdown-option, .dropdown-item, .theme-option');
+        return options.length;
+      });
+      // Should have 17 themes
+      expect(optionCount).toBeGreaterThanOrEqual(15);
+
+      // Close dropdown
+      await browser.keys('Escape');
+      await browser.pause(200);
+    }
+  });
+
+  after(async () => {
+    await browser.keys('Escape');
+    await browser.pause(300);
+  });
+});
+
+// ─── Scenario C6: Project Health Indicators ───────────────────────────
+
+describe('Scenario C6 — Project Health Indicators', () => {
+  it('should show status dots on project headers', async () => {
+    const hasDots = await browser.execute(() => {
+      const dots = document.querySelectorAll('.project-header .status-dot, .project-header .health-dot');
+      return dots.length;
+    });
+    // At least one project should have a status dot
+    expect(hasDots).toBeGreaterThanOrEqual(1);
+  });
+
+  it('should show idle status when no agents running', async () => {
+    const ids = await getProjectIds();
+    if (ids.length < 1) return;
+
+    const dotColor = await browser.execute((id) => {
+      const box = document.querySelector(`[data-project-id="${id}"]`);
+      const dot = box?.querySelector('.status-dot, .health-dot');
+      if (!dot) return 'not-found';
+      const style = window.getComputedStyle(dot);
+      return style.backgroundColor || style.color || 'unknown';
+    }, ids[0]);
+
+    // Should have some color value (not 'not-found')
+    expect(dotColor).not.toBe('not-found');
+  });
+
+  it('should show status bar agent counts', async () => {
+    const counts = await browser.execute(() => {
+      const bar = document.querySelector('[data-testid="status-bar"]');
+      if (!bar) return '';
+      // Status bar shows running/idle/stalled counts
+      return bar.textContent ?? '';
+    });
+    // Should contain at least idle count
+    expect(counts).toMatch(/idle|running|stalled|\d/i);
+  });
+});
+
+// ─── Scenario C7: Metrics Tab ─────────────────────────────────────────
+
+describe('Scenario C7 — Metrics Tab', () => {
+  it('should show Metrics tab in project tab bar', async () => {
+    const ids = await getProjectIds();
+    if (ids.length < 1) return;
+
+    const hasMetrics = await browser.execute((id) => {
+      const box = document.querySelector(`[data-project-id="${id}"]`);
+      const tabs = box?.querySelectorAll('[data-testid="project-tabs"] .ptab');
+      if (!tabs) return false;
+      return Array.from(tabs).some(t => t.textContent?.trim().toLowerCase().includes('metric'));
+    }, ids[0]);
+
+    expect(hasMetrics).toBe(true);
+  });
+
+  it('should render Metrics panel content when tab clicked', async () => {
+    const ids = await getProjectIds();
+    if (ids.length < 1) return;
+    const projectId = ids[0];
+
+    // Find and click Metrics tab
+    await browser.execute((id) => {
+      const box = document.querySelector(`[data-project-id="${id}"]`);
+      const tabs = box?.querySelectorAll('[data-testid="project-tabs"] .ptab');
+      if (!tabs) return;
+      for (const tab of tabs) {
+        if (tab.textContent?.trim().toLowerCase().includes('metric')) {
+          (tab as HTMLElement).click();
+          break;
+        }
+      }
+    }, projectId);
+    await browser.pause(500);
+
+    const hasContent = await browser.execute((id) => {
+      const box = document.querySelector(`[data-project-id="${id}"]`);
+      // MetricsPanel has live view with fleet stats
+      const panel = box?.querySelector('.metrics-panel, .metrics-tab');
+      return panel !== null;
+    }, projectId);
+
+    expect(hasContent).toBe(true);
+
+    // Switch back to Model tab
+    await switchProjectTab(projectId, 0);
+  });
+});
+
+// ─── Scenario C8: Context Tab ─────────────────────────────────────────
+
+describe('Scenario C8 — Context Tab Visualization', () => {
+  it('should render Context tab with token meter', async () => {
+    const ids = await getProjectIds();
+    if (ids.length < 1) return;
+    const projectId = ids[0];
+
+    // Switch to Context tab (index 2)
+    await switchProjectTab(projectId, 2);
+
+    const hasContextUI = await browser.execute((id) => {
+      const box = document.querySelector(`[data-project-id="${id}"]`);
+      // ContextTab has stats, token meter, file references
+      const ctx = box?.querySelector('.context-tab, .context-stats, .token-meter, .stat-value');
+      return ctx !== null;
+    }, projectId);
+
+    expect(hasContextUI).toBe(true);
+
+    // Switch back to Model tab
+    await switchProjectTab(projectId, 0);
+  });
+});
+
+// ─── Scenario C9: Files Tab with Editor ───────────────────────────────
+
+describe('Scenario C9 — Files Tab & Code Editor', () => {
+  it('should render Files tab with directory tree', async () => {
+    const ids = await getProjectIds();
+    if (ids.length < 1) return;
+    const projectId = ids[0];
+
+    // Switch to Files tab (index 3)
+    await switchProjectTab(projectId, 3);
+    await browser.pause(500);
+
+    const hasTree = await browser.execute((id) => {
+      const box = document.querySelector(`[data-project-id="${id}"]`);
+      // FilesTab has a directory tree
+      const tree = box?.querySelector('.file-tree, .directory-tree, .files-tab');
+      return tree !== null;
+    }, projectId);
+
+    expect(hasTree).toBe(true);
+  });
+
+  it('should list files from the project directory', async () => {
+    const ids = await getProjectIds();
+    if (ids.length < 1) return;
+
+    const fileNames = await browser.execute((id) => {
+      const box = document.querySelector(`[data-project-id="${id}"]`);
+      const items = box?.querySelectorAll('.tree-name');
+      return Array.from(items ?? []).map(el => el.textContent?.trim() ?? '');
+    }, ids[0]);
+
+    // Test project has README.md and hello.py
+    const hasFiles = fileNames.some(f =>
+      f.includes('README') || f.includes('hello') || f.includes('.py') || f.includes('.md'),
+    );
+    expect(hasFiles).toBe(true);
+
+    // Switch back to Model tab
+    await switchProjectTab(ids[0], 0);
+  });
+});
+
+// ─── Scenario C10: LLM-Judged Settings Completeness ──────────────────
+
+describe('Scenario C10 — LLM-Judged Settings Completeness', () => {
+  it('should have comprehensive settings panel', async function () {
+    if (!isJudgeAvailable()) {
+      console.log('Skipping — LLM judge not available (no CLI or API key)');
+      this.skip();
+      return;
+    }
+
+    // Open settings
+    await browser.execute(() => {
+      const btn = document.querySelector('[data-testid="settings-btn"]');
+      if (btn) (btn as HTMLElement).click();
+    });
+    await browser.pause(500);
+
+    const settingsContent = await browser.execute(() => {
+      const panel = document.querySelector('.sidebar-panel, .settings-tab');
+      return panel?.textContent ?? '';
+    });
+
+    const verdict = await assertWithJudge(
+      'The settings panel should contain configuration options for: (1) theme/appearance, (2) font settings (UI and terminal), (3) default shell, and optionally (4) provider settings. It should look like a real settings UI, not an error message.',
+      settingsContent,
+      { context: 'BTerminal v3 settings panel with Appearance section (theme dropdown, UI font, terminal font) and Defaults section (shell, CWD). May also have Providers section.' },
+    );
+
+    expect(verdict.pass).toBe(true);
+    if (!verdict.pass) {
+      console.log(`LLM Judge: ${verdict.reasoning} (confidence: ${verdict.confidence})`);
+    }
+
+    await browser.keys('Escape');
+    await browser.pause(300);
+  });
+});
+
+// ─── Scenario C11: LLM-Judged Status Bar ──────────────────────────────
+
+describe('Scenario C11 — LLM-Judged Status Bar Completeness', () => {
+  it('should render a comprehensive status bar', async function () {
+    if (!isJudgeAvailable()) {
+      console.log('Skipping — LLM judge not available (no CLI or API key)');
+      this.skip();
+      return;
+    }
+
+    const statusBarContent = await browser.execute(() => {
+      const bar = document.querySelector('[data-testid="status-bar"]');
+      return bar?.textContent ?? '';
+    });
+
+    const statusBarHtml = await browser.execute(() => {
+      const bar = document.querySelector('[data-testid="status-bar"]');
+      return bar?.innerHTML ?? '';
+    });
+
+    const verdict = await assertWithJudge(
+      'The status bar should display agent fleet information including: agent status counts (idle/running/stalled with numbers), and optionally burn rate ($/hr) and cost tracking. It should look like a real monitoring dashboard status bar.',
+      `Text: ${statusBarContent}\n\nHTML structure: ${statusBarHtml.substring(0, 2000)}`,
+      { context: 'BTerminal Mission Control status bar shows running/idle/stalled agent counts, total $/hr burn rate, attention queue, and total cost.' },
+    );
+
+    expect(verdict.pass).toBe(true);
+    if (!verdict.pass) {
+      console.log(`LLM Judge: ${verdict.reasoning} (confidence: ${verdict.confidence})`);
+    }
+  });
+});
diff --git a/v2/tests/e2e/tsconfig.json b/v2/tests/e2e/tsconfig.json
new file mode 100644
index 0000000..a1c3b70
--- /dev/null
+++ b/v2/tests/e2e/tsconfig.json
@@ -0,0 +1,11 @@
+{
+  "compilerOptions": {
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "target": "ESNext",
+    "types": ["@wdio/mocha-framework", "@wdio/globals/types"],
+    "esModuleInterop": true,
+    "skipLibCheck": true
+  },
+  "include": ["specs/**/*.ts", "*.ts"]
+}
diff --git a/v2/tests/e2e/wdio.conf.js b/v2/tests/e2e/wdio.conf.js
new file mode 100644
index 0000000..3b68d68
--- /dev/null
+++ b/v2/tests/e2e/wdio.conf.js
@@ -0,0 +1,213 @@
+import { spawn, execSync } from 'node:child_process';
+import { createConnection } from 'node:net';
+import { resolve, dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { mkdirSync, writeFileSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const projectRoot = resolve(__dirname, '../..');
+
+// Debug binary path (built with `cargo tauri build --debug --no-bundle`)
+// Cargo workspace target dir is at v2/target/, not v2/src-tauri/target/
+const tauriBinary = resolve(projectRoot, 'target/debug/bterminal');
+
+let tauriDriver;
+
+// ── Test Fixture (created eagerly so env vars are available for capabilities) ──
+const fixtureRoot = join(tmpdir(), `bterminal-e2e-${Date.now()}`);
+const fixtureDataDir = join(fixtureRoot, 'data');
+const fixtureConfigDir = join(fixtureRoot, 'config');
+const fixtureProjectDir = join(fixtureRoot, 'test-project');
+
+mkdirSync(fixtureDataDir, { recursive: true });
+mkdirSync(fixtureConfigDir, { recursive: true });
+mkdirSync(fixtureProjectDir, { recursive: true });
+
+// Create a minimal git repo for agent testing
+execSync('git init', { cwd: fixtureProjectDir, stdio: 'ignore' });
+execSync('git config user.email "test@bterminal.dev"', { cwd: fixtureProjectDir, stdio: 'ignore' });
+execSync('git config user.name "BTerminal Test"', { cwd: fixtureProjectDir, stdio: 'ignore' });
+writeFileSync(join(fixtureProjectDir, 'README.md'), '# Test Project\n\nA simple test project for BTerminal E2E tests.\n');
+writeFileSync(join(fixtureProjectDir, 'hello.py'), 'def greet(name: str) -> str:\n    return f"Hello, {name}!"\n');
+execSync('git add -A && git commit -m "initial commit"', { cwd: fixtureProjectDir, stdio: 'ignore' });
+
+// Write groups.json with one group containing the test project
+writeFileSync(
+  join(fixtureConfigDir, 'groups.json'),
+  JSON.stringify({
+    version: 1,
+    groups: [{
+      id: 'test-group',
+      name: 'Test Group',
+      projects: [{
+        id: 'test-project',
+        name: 'Test Project',
+        identifier: 'test-project',
+        description: 'E2E test project',
+        icon: '\uf120',
+        cwd: fixtureProjectDir,
+        profile: 'default',
+        enabled: true,
+      }],
+      agents: [],
+    }],
+    activeGroupId: 'test-group',
+  }, null, 2),
+);
+
+// Inject env vars into process.env so tauri-driver inherits them
+// (tauri:options.env may not reliably set process-level env vars)
+process.env.BTERMINAL_TEST = '1';
+process.env.BTERMINAL_TEST_DATA_DIR = fixtureDataDir;
+process.env.BTERMINAL_TEST_CONFIG_DIR = fixtureConfigDir;
+
+console.log(`Test fixture created at ${fixtureRoot}`);
+
+export const config = {
+  // ── Runner ──
+  runner: 'local',
+  maxInstances: 1, // Tauri doesn't support parallel sessions
+
+  // ── Connection (external tauri-driver on port 4444) ──
+  hostname: 'localhost',
+  port: 4444,
+  path: '/',
+
+  // ── Specs ──
+  // Single spec file — Tauri launches one app instance per session,
+  // and tauri-driver can't re-create sessions between spec files.
+  specs: [
+    resolve(__dirname, 'specs/bterminal.test.ts'),
+    resolve(__dirname, 'specs/agent-scenarios.test.ts'),
+    resolve(__dirname, 'specs/phase-b.test.ts'),
+    resolve(__dirname, 'specs/phase-c.test.ts'),
+  ],
+
+  // ── Capabilities ──
+  capabilities: [{
+    // Disable BiDi negotiation — tauri-driver doesn't support webSocketUrl
+    'wdio:enforceWebDriverClassic': true,
+    'tauri:options': {
+      application: tauriBinary,
+      // Test isolation: fixture-created data/config dirs, disable watchers/telemetry
+      env: {
+        BTERMINAL_TEST: '1',
+        BTERMINAL_TEST_DATA_DIR: fixtureDataDir,
+        BTERMINAL_TEST_CONFIG_DIR: fixtureConfigDir,
+      },
+    },
+  }],
+
+  // ── Framework ──
+  framework: 'mocha',
+  mochaOpts: {
+    ui: 'bdd',
+    timeout: 180_000,
+  },
+
+  // ── Reporter ──
+  reporters: ['spec'],
+
+  // ── Logging ──
+  logLevel: 'warn',
+
+  // ── Timeouts ──
+  waitforTimeout: 10_000,
+  connectionRetryTimeout: 30_000,
+  connectionRetryCount: 3,
+
+  // ── Hooks ──
+
+  /**
+   * Build the debug binary before the test run.
+   * Uses --debug --no-bundle for fastest build time.
+   */
+  onPrepare() {
+    if (process.env.SKIP_BUILD) {
+      console.log('SKIP_BUILD set — using existing debug binary.');
+      return Promise.resolve();
+    }
+    return new Promise((resolve, reject) => {
+      console.log('Building Tauri debug binary...');
+      const build = spawn('cargo', ['tauri', 'build', '--debug', '--no-bundle'], {
+        cwd: projectRoot,
+        stdio: 'inherit',
+      });
+      build.on('close', (code) => {
+        if (code === 0) {
+          console.log('Debug binary ready.');
+          resolve();
+        } else {
+          reject(new Error(`Tauri build failed with exit code ${code}`));
+        }
+      });
+      build.on('error', reject);
+    });
+  },
+
+  /**
+   * Spawn tauri-driver before the session.
+   * tauri-driver bridges WebDriver protocol to WebKit2GTK's inspector.
+   * Uses TCP probe to confirm port 4444 is accepting connections.
+   */
+  beforeSession() {
+    return new Promise((res, reject) => {
+      tauriDriver = spawn('tauri-driver', [], {
+        stdio: ['ignore', 'pipe', 'pipe'],
+      });
+
+      tauriDriver.on('error', (err) => {
+        reject(new Error(
+          `Failed to start tauri-driver: ${err.message}. ` +
+          'Install it with: cargo install tauri-driver'
+        ));
+      });
+
+      // TCP readiness probe — poll port 4444 until it accepts a connection
+      const maxWaitMs = 10_000;
+      const intervalMs = 200;
+      const deadline = Date.now() + maxWaitMs;
+
+      function probe() {
+        if (Date.now() > deadline) {
+          reject(new Error('tauri-driver did not become ready within 10s'));
+          return;
+        }
+        const sock = createConnection({ port: 4444, host: 'localhost' }, () => {
+          sock.destroy();
+          res();
+        });
+        sock.on('error', () => {
+          sock.destroy();
+          setTimeout(probe, intervalMs);
+        });
+      }
+
+      // Give it a moment before first probe
+      setTimeout(probe, 300);
+    });
+  },
+
+  /**
+   * Kill tauri-driver after the test run.
+   */
+  afterSession() {
+    if (tauriDriver) {
+      tauriDriver.kill();
+      tauriDriver = null;
+    }
+    // Clean up test fixture
+    try {
+      rmSync(fixtureRoot, { recursive: true, force: true });
+      console.log('Test fixture cleaned up.');
+    } catch { /* best-effort cleanup */ }
+  },
+
+  // ── TypeScript (auto-compile via tsx) ──
+  autoCompileOpts: {
+    tsNodeOpts: {
+      project: resolve(__dirname, 'tsconfig.json'),
+    },
+  },
+};
diff --git a/v2/tsconfig.app.json b/v2/tsconfig.app.json
new file mode 100644
index 0000000..31c18cf
--- /dev/null
+++ b/v2/tsconfig.app.json
@@ -0,0 +1,21 @@
+{
+  "extends": "@tsconfig/svelte/tsconfig.json",
+  "compilerOptions": {
+    "tsBuildInfoFile": "./node_modules/.tmp/tsconfig.app.tsbuildinfo",
+    "target": "ES2022",
+    "useDefineForClassFields": true,
+    "module": "ESNext",
+    "types": ["svelte", "vite/client"],
+    "noEmit": true,
+    /**
+     * Typecheck JS in `.svelte` and `.js` files by default.
+     * Disable checkJs if you'd like to use dynamic types in JS.
+     * Note that setting allowJs false does not prevent the use
+     * of JS in `.svelte` files.
+     */
+    "allowJs": true,
+    "checkJs": true,
+    "moduleDetection": "force"
+  },
+  "include": ["src/**/*.ts", "src/**/*.js", "src/**/*.svelte"]
+}
diff --git a/v2/tsconfig.json b/v2/tsconfig.json
new file mode 100644
index 0000000..1ffef60
--- /dev/null
+++ b/v2/tsconfig.json
@@ -0,0 +1,7 @@
+{
+  "files": [],
+  "references": [
+    { "path": "./tsconfig.app.json" },
+    { "path": "./tsconfig.node.json" }
+  ]
+}
diff --git a/v2/tsconfig.node.json b/v2/tsconfig.node.json
new file mode 100644
index 0000000..8a67f62
--- /dev/null
+++ b/v2/tsconfig.node.json
@@ -0,0 +1,26 @@
+{
+  "compilerOptions": {
+    "tsBuildInfoFile": "./node_modules/.tmp/tsconfig.node.tsbuildinfo",
+    "target": "ES2023",
+    "lib": ["ES2023"],
+    "module": "ESNext",
+    "types": ["node"],
+    "skipLibCheck": true,
+
+    /* Bundler mode */
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "moduleDetection": "force",
+    "noEmit": true,
+
+    /* Linting */
+    "strict": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "erasableSyntaxOnly": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedSideEffectImports": true
+  },
+  "include": ["vite.config.ts"]
+}
diff --git a/v2/vite.config.ts b/v2/vite.config.ts
new file mode 100644
index 0000000..6a5bb20
--- /dev/null
+++ b/v2/vite.config.ts
@@ -0,0 +1,14 @@
+import { defineConfig } from 'vite'
+import { svelte } from '@sveltejs/vite-plugin-svelte'
+
+export default defineConfig({
+  plugins: [svelte()],
+  server: {
+    port: 9700,
+    strictPort: true,
+  },
+  clearScreen: false,
+  test: {
+    include: ['src/**/*.test.ts'],
+  },
+})